//-----------------------------------------------------------------------------
// Purpose: Override so only reload one shell at a time
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CWeaponShotgun::Reload( void )
{
// Check that StartReload was called first
if (!m_bInReload)
{
Warning("ERROR: Shotgun Reload called incorrectly!\n");
}
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return false;
if (pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
return false;
if (m_iClip1 >= GetMaxClip1())
return false;
int j = MIN(1, pOwner->GetAmmoCount(m_iPrimaryAmmoType));
if (j <= 0)
return false;
FillClip();
// Play reload on different channel as otherwise steals channel away from fire sound
WeaponSound(RELOAD);
SendWeaponAnim( ACT_VM_RELOAD );
pOwner->m_flNextAttack = gpGlobals->curtime;
m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Same as base reload but doesn't change the owner's next attack time. This
// lets us zoom out while reloading. This hack is necessary because our
// ItemPostFrame is only called when the owner's next attack time has
// expired.
// Output : Returns true if the weapon was reloaded, false if no more ammo.
//-----------------------------------------------------------------------------
bool CWeaponSniperRifle::Reload( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
{
return false;
}
if (pOwner->GetAmmoCount(m_iPrimaryAmmoType) > 0)
{
int primary = MIN(GetMaxClip1() - m_iClip1, pOwner->GetAmmoCount(m_iPrimaryAmmoType));
int secondary = MIN(GetMaxClip2() - m_iClip2, pOwner->GetAmmoCount(m_iSecondaryAmmoType));
if (primary > 0 || secondary > 0)
{
// Play reload on different channel as it happens after every fire
// and otherwise steals channel away from fire sound
WeaponSound(RELOAD);
SendWeaponAnim( ACT_VM_RELOAD );
m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
m_bInReload = true;
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Override so only reload one shell at a time
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CWeaponShotgun::StartReload( void )
{
if ( m_bNeedPump )
return false;
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return false;
if (pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
return false;
if (m_iClip1 >= GetMaxClip1())
return false;
int j = MIN(1, pOwner->GetAmmoCount(m_iPrimaryAmmoType));
if (j <= 0)
return false;
SendWeaponAnim( ACT_SHOTGUN_RELOAD_START );
// Make shotgun shell visible
SetBodygroup(1,0);
pOwner->m_flNextAttack = gpGlobals->curtime;
m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
m_bInReload = true;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Override so only reload one shell at a time
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CWeapon870AE::StartReload( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return false;
if (m_iItemID == 0)
{
if (pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
return false;
if (m_iClip1 >= GetMaxClip1())
return false;
// If shotgun totally emptied then a pump animation is needed
//NOTENOTE: This is kinda lame because the player doesn't get strong feedback on when the reload has finished,
// without the pump. Technically, it's incorrect, but it's good for feedback...
int j = MIN(1, pOwner->GetAmmoCount(m_iPrimaryAmmoType));
if (j <= 0)
return false;
}
else
{
CBasePlayer *pPlayer = ToBasePlayer(GetOwner());
if (pPlayer)
{
if (pPlayer->Inventory_CountAllObjectContentsOfID(GetPrimaryAmmoID()) <= 0)
return false;
if (m_iClip1 >= GetMaxClip1())
return false;
int j = MIN(1, pPlayer->Inventory_CountAllObjectContentsOfID(GetPrimaryAmmoID()));
if (j <= 0)
return false;
}
}
SendWeaponAnim( ACT_SHOTGUN_RELOAD_START );
// Make shotgun shell visible
SetBodygroup(1,0);
pOwner->m_flNextAttack = gpGlobals->curtime;
m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
m_bInReload = true;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CWeapon_Tripwire::WeaponIdle( void )
{
// Ready to switch animations?
if ( HasWeaponIdleTimeElapsed() )
{
if (m_bClearReload)
{
m_bNeedReload = false;
m_bClearReload = false;
}
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
{
return;
}
int iAnim = 0;
if (m_bAttachTripwire)
{
TripwireAttach();
iAnim = ACT_SLAM_TRIPMINE_ATTACH2;
}
else if (m_bNeedReload)
{
// If owner had ammo draw the correct tripwire type
if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) > 0)
{
iAnim = ACT_SLAM_TRIPMINE_DRAW;
m_bClearReload = true;
}
else
{
pOwner->Weapon_Drop( this );
UTIL_Remove(this);
}
}
else if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) <= 0)
{
pOwner->Weapon_Drop( this );
UTIL_Remove(this);
}
// If I don't need to reload just do the appropriate idle
else
{
iAnim = ACT_SLAM_TRIPMINE_IDLE;
}
SendWeaponAnim( iAnim );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CWeapon_SLAM::PrimaryAttack( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
{
return;
}
if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) <= 0)
{
return;
}
switch (m_tSlamState)
{
case SLAM_TRIPMINE_READY:
if (CanAttachSLAM())
{
StartTripmineAttach();
}
break;
case SLAM_SATCHEL_THROW:
StartSatchelThrow();
break;
case SLAM_SATCHEL_ATTACH:
StartSatchelAttach();
break;
}
}
void CWeaponMine::WeaponIdle( void )
{
if(gpGlobals->curtime > m_flNextPrimaryAttack){
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
return;
//Si on a une mine à finir de poser
if(m_bAttachMine)
FinishAttach();
//Sinon si on doit recharger
if( m_bNeedReload )
{
if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) > 0){
SendWeaponAnim(ACT_SLAM_TRIPMINE_DRAW);
m_bNeedReload = false;
}
#ifndef CLIENT_DLL
//Sinon on a pas assez de munitions et on drop l'arme
else
{
pOwner->Weapon_Drop(this);
UTIL_Remove(this);
}
#endif
}
//Sinon on idle
else
{
SendWeaponAnim(ACT_SLAM_TRIPMINE_IDLE);
m_flWallSwitchTime = 0;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponTranquilizer::CreateLaserPointer( void )
{
#ifndef CLIENT_DLL
if ( m_hLaserDot != NULL )
return;
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return;
if ( pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
return;
m_hLaserDot = CLaserDot::Create( GetAbsOrigin(), GetOwner() );
m_hLaserDot->TurnOff();
m_hLaserDot->SetRenderMode(kRenderWorldGlow);
if(HL2MPRules()->IsTeamplay())
{
if(pOwner->GetTeamNumber() == TEAM_PINK)
m_hLaserDot->SetRenderColor(255,100,255,255);
else
m_hLaserDot->SetRenderColor(153,255,153,255);
}
else
m_hLaserDot->SetRenderColor(255,0,0,255);
UpdateLaserPosition();
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Switch to next best weapon
// Input :
// Output :
//-----------------------------------------------------------------------------
void CWeapon_SLAM::Weapon_Switch( void )
{
// Note that we may pick the SLAM again, when we switch
// weapons, in which case we have to save and restore the
// detonator armed state.
// The SLAMs may be about to blow up, but haven't done so yet
// and the deploy function will find the undetonated charges
// and we are armed
bool saveState = m_bDetonatorArmed;
CBaseCombatCharacter *pOwner = GetOwner();
pOwner->SwitchToNextBestWeapon( pOwner->GetActiveWeapon() );
if (pOwner->GetActiveWeapon() == this)
{
m_bDetonatorArmed = saveState;
}
#ifndef CLIENT_DLL
// If not armed and have no ammo
if (!m_bDetonatorArmed && pOwner->GetAmmoCount(m_iSecondaryAmmoType) <= 0)
{
pOwner->ClearActiveWeapon();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CWeapon_SLAM::SLAMThink( void )
{
if (m_flWallSwitchTime <= gpGlobals->curtime)
{
// If not in tripmine mode we need to check to see if we are close to
// a wall. If we are we go into satchel_attach mode
CBaseCombatCharacter *pOwner = GetOwner();
if ((m_tSlamState != SLAM_TRIPMINE_READY) && (pOwner && pOwner->GetAmmoCount(m_iSecondaryAmmoType) > 0))
{
if (CanAttachSLAM())
{
if (m_tSlamState == SLAM_SATCHEL_THROW)
{
SetSlamState(SLAM_SATCHEL_ATTACH);
int iAnim = m_bDetonatorArmed ? ACT_SLAM_THROW_TO_STICKWALL : ACT_SLAM_THROW_TO_STICKWALL_ND;
SendWeaponAnim( iAnim );
m_flWallSwitchTime = gpGlobals->curtime + SequenceDuration();
}
}
else
{
if (m_tSlamState == SLAM_SATCHEL_ATTACH)
{
SetSlamState(SLAM_SATCHEL_THROW);
int iAnim = m_bDetonatorArmed ? ACT_SLAM_STICKWALL_TO_THROW : ACT_SLAM_STICKWALL_TO_THROW_ND;
SendWeaponAnim( iAnim );
m_flWallSwitchTime = gpGlobals->curtime + SequenceDuration();
}
}
}
}
SetNextThink( gpGlobals->curtime + 0.1f );
}
bool CWeapon_SLAM::Deploy( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
{
return false;
}
m_bDetonatorArmed = AnyUndetonatedCharges();
SetModel( GetViewModel() );
m_tSlamState = (int)SLAM_SATCHEL_THROW;
// ------------------------------
// Pick the right draw animation
// ------------------------------
int iActivity;
// If detonator is already armed
m_bNeedReload = false;
if (m_bDetonatorArmed)
{
if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) <= 0)
{
iActivity = ACT_SLAM_DETONATOR_DRAW;
m_bNeedReload = true;
}
else if (CanAttachSLAM())
{
iActivity = ACT_SLAM_DETONATOR_STICKWALL_DRAW;
SetSlamState(SLAM_TRIPMINE_READY);
}
else
{
iActivity = ACT_SLAM_DETONATOR_THROW_DRAW;
SetSlamState(SLAM_SATCHEL_THROW);
}
}
else
{
if (CanAttachSLAM())
{
iActivity = ACT_SLAM_TRIPMINE_DRAW;
SetSlamState(SLAM_TRIPMINE_READY);
}
else
{
iActivity = ACT_SLAM_THROW_ND_DRAW;
SetSlamState(SLAM_SATCHEL_THROW);
}
}
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), iActivity, (char*)GetAnimPrefix() );
}
void CWeapon_Manhack::WeaponSwitch( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if (pOwner==NULL) return;
pOwner->SwitchToNextBestWeapon( pOwner->GetActiveWeapon() );
if (CPropVehicleManhack::GetManhackVehicle() == NULL && pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
{
pOwner->ClearActiveWeapon();
}
}
void CWeaponMine::PrimaryAttack( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
return;
if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) <= 0)
return;
if (!m_bAttachMine)
StartAttach();
}
bool CWeaponShotgun::Reload( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return false;
if ( pOwner->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
return false;
if ( m_iClip1 >= GetMaxClip1() )
return false;
// don't reload until recoil is done
if ( m_flNextPrimaryAttack > gpGlobals->curtime )
return false;
// check to see if we're ready to reload
if ( m_fInSpecialReload == 0 )
{
SendWeaponAnim( ACT_SHOTGUN_RELOAD_START );
m_fInSpecialReload = 1;
pOwner->m_flNextAttack = gpGlobals->curtime + 0.6;
SetWeaponIdleTime( gpGlobals->curtime + 0.6 );
m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
m_flNextSecondaryAttack = gpGlobals->curtime + 1.0;
return true;
}
else if ( m_fInSpecialReload == 1 )
{
if ( !HasWeaponIdleTimeElapsed() )
return false;
// was waiting for gun to move to side
m_fInSpecialReload = 2;
// Play reload on different channel as otherwise steals channel away from fire sound
WeaponSound( RELOAD );
SendWeaponAnim( ACT_VM_RELOAD );
SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
}
else
{
FillClip();
m_fInSpecialReload = 1;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if this weapon has some ammo
//-----------------------------------------------------------------------------
bool CASW_Weapon::HasAmmo( void )
{
// Weapons with no ammo types can always be selected
if ( m_iPrimaryAmmoType == -1 && m_iSecondaryAmmoType == -1 )
return true;
if ( GetWeaponFlags() & ITEM_FLAG_SELECTONEMPTY )
return true;
CBaseCombatCharacter *pOwner = GetOwner();
if ( !pOwner )
return false;
return ( m_iClip1 > 0 || pOwner->GetAmmoCount( m_iPrimaryAmmoType ) || m_iClip2 > 0 || pOwner->GetAmmoCount( m_iSecondaryAmmoType ) );
}
//-----------------------------------------------------------------------------
// Purpose: Secondary attack switches between satchel charge and tripmine mode
// Input :
// Output :
//-----------------------------------------------------------------------------
void CWeapon_SLAM::SecondaryAttack( void )
{
return; // Nothin for now. SLAM's just a tripmine.
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
{
return;
}
if (m_bDetonatorArmed)
{
StartSatchelDetonate();
}
else if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) > 0)
{
if (m_tSlamState == SLAM_TRIPMINE_READY)
{
// Play sound for going to throw mode
EmitSound( "Weapon_SLAM.ThrowMode" );
if (CanAttachSLAM())
{
SetSlamState(SLAM_SATCHEL_ATTACH);
SendWeaponAnim( ACT_SLAM_TRIPMINE_TO_STICKWALL_ND );
}
else
{
SetSlamState(SLAM_SATCHEL_THROW);
SendWeaponAnim( ACT_SLAM_TRIPMINE_TO_THROW_ND );
}
}
else
{
// Play sound for going to tripmine mode
EmitSound( "Weapon_SLAM.TripMineMode" );
if (m_tSlamState == SLAM_SATCHEL_ATTACH)
{
SetSlamState(SLAM_TRIPMINE_READY);
SendWeaponAnim( ACT_SLAM_STICKWALL_TO_TRIPMINE_ND );
}
else
{
SetSlamState(SLAM_TRIPMINE_READY);
SendWeaponAnim( ACT_SLAM_THROW_TO_TRIPMINE_ND );
}
}
m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Purpose: Override so only reload one shell at a time
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CWeaponShotgun::StartReload( void )
{
if ( m_bNeedPump )
return false;
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return false;
if (pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
return false;
if (m_iClip1 >= GetMaxClip1())
return false;
int j = min(1, pOwner->GetAmmoCount(m_iPrimaryAmmoType));
if (j <= 0)
return false;
SendWeaponAnim( ACT_SHOTGUN_RELOAD_START );
//Tony; BUG BUG BUG!!! shotgun does one shell at a time!!! -- player model only has a single reload!!! so I'm just going to dispatch the singular for now.
ToHL2MPPlayer( pOwner )->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
// Make shotgun shell visible
SetBodygroup(1,0);
pOwner->m_flNextAttack = gpGlobals->curtime;
m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
m_bInReload = true;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Override so only reload one shell at a time
//-----------------------------------------------------------------------------
bool CWeaponRemington::Reload( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return false;
if (pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
return false;
if (m_iClip1 >= GetMaxClip1())
return false;
int j = min(1, pOwner->GetAmmoCount(m_iPrimaryAmmoType));
if (j <= 0)
return false;
FillClip();
// Play reload on different channel as otherwise steals channel away from fire sound
WeaponSound(RELOAD);
SendWeaponAnim( ACT_VM_RELOAD );
pOwner->m_flNextAttack = gpGlobals->curtime;
m_flNextPrimaryAttack = gpGlobals->curtime + 0.5f;
return true;
}
bool CWeapon_Manhack::HasAnyAmmo( void )
{
FindVehicleManhack();
if ( HasNPCManhack() )
{
return true;
}
CBaseCombatCharacter *pOwner = GetOwner();
if (pOwner==NULL) return false;
if (pOwner->GetAmmoCount(m_iPrimaryAmmoType) > 0)
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Play finish reload anim and fill clip
// Input :
// Output :
//-----------------------------------------------------------------------------
void CWeaponShotgun::FillClip( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return;
// Add them to the clip
if ( pOwner->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
{
if ( Clip1() < GetMaxClip1() )
{
m_iClip1++;
pOwner->RemoveAmmo( 1, m_iPrimaryAmmoType );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CWeapon_Tripwire::PrimaryAttack( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
{
return;
}
if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) <= 0)
{
return;
}
if (CanAttachTripwire())
{
StartTripwireAttach();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//
//
//-----------------------------------------------------------------------------
void CWeaponMolotov::DrawAmmo( void )
{
// -------------------------------------------
// Make sure I have ammo of the current type
// -------------------------------------------
CBaseCombatCharacter *pOwner = GetOwner();
if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) <=0)
{
pOwner->Weapon_Drop( this );
UTIL_Remove(this);
return;
}
Msg("Drawing Molotov...\n");
m_bNeedDraw = false;
//<<TEMP>> - till real animation is avaible
m_flNextPrimaryAttack = gpGlobals->curtime + 2.0;
m_flNextSecondaryAttack = gpGlobals->curtime + 2.0;
}
void CWeaponShotgun::CalculateShellVis(bool fillclip)
{
// Shells on the shotgun viewmodel will be removed if the reserve ammo is less than 5.
// Each time we draw and reload, we check to see if this is the case, and if it is we change bodygroups accordingly.
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
return;
int reserveammo = pOwner->GetAmmoCount(m_iPrimaryAmmoType);
if (fillclip) //If we need to fill the clip, just subtract the difference between the max capacity and the current value.
reserveammo -= GetMaxClip1() - m_iClip1; //This can be negative, it won't change the comparision results.
for (int i = 4; i >= 0; i--)
{
if (reserveammo > i)
SwitchBodygroup(m_iShellBodyGroup[i], 0);
else
SwitchBodygroup(m_iShellBodyGroup[i], 1);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CWeapon_SLAM::WeaponIdle( void )
{
// Ready to switch animations?
if ( HasWeaponIdleTimeElapsed() )
{
// Don't allow throw to attach switch unless in idle
m_flWallSwitchTime = gpGlobals->curtime + 50;
if (m_bClearReload)
{
m_bNeedReload = false;
m_bClearReload = false;
}
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
{
return;
}
int iAnim = 0;
if (m_bThrowSatchel)
{
SatchelThrow();
if (m_bDetonatorArmed && !m_bNeedDetonatorDraw)
{
iAnim = ACT_SLAM_THROW_THROW2;
}
else
{
iAnim = ACT_SLAM_THROW_THROW_ND2;
}
}
else if (m_bAttachSatchel)
{
SatchelAttach();
if (m_bDetonatorArmed && !m_bNeedDetonatorDraw)
{
iAnim = ACT_SLAM_STICKWALL_ATTACH2;
}
else
{
iAnim = ACT_SLAM_STICKWALL_ND_ATTACH2;
}
}
else if (m_bAttachTripmine)
{
TripmineAttach();
iAnim = ACT_SLAM_TRIPMINE_ATTACH2;
}
else if (m_bNeedReload)
{
// If owner had ammo draw the correct SLAM type
if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) > 0)
{
switch( m_tSlamState)
{
case SLAM_TRIPMINE_READY:
{
iAnim = ACT_SLAM_TRIPMINE_DRAW;
}
break;
case SLAM_SATCHEL_ATTACH:
{
if (m_bNeedDetonatorHolster)
{
iAnim = ACT_SLAM_STICKWALL_DETONATOR_HOLSTER;
m_bNeedDetonatorHolster = false;
}
else if (m_bDetonatorArmed)
{
iAnim = m_bNeedDetonatorDraw ? ACT_SLAM_DETONATOR_STICKWALL_DRAW : ACT_SLAM_STICKWALL_DRAW;
m_bNeedDetonatorDraw = false;
}
else
{
iAnim = ACT_SLAM_STICKWALL_ND_DRAW;
}
}
break;
case SLAM_SATCHEL_THROW:
{
if (m_bNeedDetonatorHolster)
{
iAnim = ACT_SLAM_THROW_DETONATOR_HOLSTER;
m_bNeedDetonatorHolster = false;
}
else if (m_bDetonatorArmed)
{
iAnim = m_bNeedDetonatorDraw ? ACT_SLAM_DETONATOR_THROW_DRAW : ACT_SLAM_THROW_DRAW;
m_bNeedDetonatorDraw = false;
}
else
{
iAnim = ACT_SLAM_THROW_ND_DRAW;
}
}
break;
}
m_bClearReload = true;
}
// If no ammo and armed, idle with only the detonator
else if (m_bDetonatorArmed)
{
iAnim = m_bNeedDetonatorDraw ? ACT_SLAM_DETONATOR_DRAW : ACT_SLAM_DETONATOR_IDLE;
m_bNeedDetonatorDraw = false;
}
else
{
pOwner->Weapon_Drop( this );
UTIL_Remove(this);
}
}
else if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) <= 0)
{
pOwner->Weapon_Drop( this );
UTIL_Remove(this);
}
// If I don't need to reload just do the appropriate idle
else
{
switch( m_tSlamState)
{
case SLAM_TRIPMINE_READY:
{
iAnim = ACT_SLAM_TRIPMINE_IDLE;
}
break;
case SLAM_SATCHEL_THROW:
{
if (m_bNeedDetonatorHolster)
{
iAnim = ACT_SLAM_THROW_DETONATOR_HOLSTER;
m_bNeedDetonatorHolster = false;
}
else
{
iAnim = m_bDetonatorArmed ? ACT_SLAM_THROW_IDLE : ACT_SLAM_THROW_ND_IDLE;
m_flWallSwitchTime = 0;
}
}
break;
case SLAM_SATCHEL_ATTACH:
{
if (m_bNeedDetonatorHolster)
{
iAnim = ACT_SLAM_STICKWALL_DETONATOR_HOLSTER;
m_bNeedDetonatorHolster = false;
}
else
{
iAnim = m_bDetonatorArmed ? ACT_SLAM_STICKWALL_IDLE : ACT_SLAM_STICKWALL_ND_IDLE;
m_flWallSwitchTime = 0;
}
}
break;
}
}
SendWeaponAnim( iAnim );
}
}
bool CWeaponDODBase::DefaultReload( int iClipSize1, int iClipSize2, int iActivity )
{
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
return false;
// If I don't have any spare ammo, I can't reload
if ( pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
return false;
bool bReload = false;
// If you don't have clips, then don't try to reload them.
if ( UsesClipsForAmmo1() )
{
// need to reload primary clip?
int primary = min(iClipSize1 - m_iClip1, pOwner->GetAmmoCount(m_iPrimaryAmmoType));
if ( primary != 0 )
{
bReload = true;
}
}
if ( UsesClipsForAmmo2() )
{
// need to reload secondary clip?
int secondary = min(iClipSize2 - m_iClip2, pOwner->GetAmmoCount(m_iSecondaryAmmoType));
if ( secondary != 0 )
{
bReload = true;
}
}
if ( !bReload )
return false;
CDODPlayer *pPlayer = GetDODPlayerOwner();
if ( pPlayer )
{
#ifdef CLIENT_DLL
PlayWorldReloadSound( pPlayer );
#else
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
#endif
}
SendWeaponAnim( iActivity );
// Play the player's reload animation
if ( pOwner->IsPlayer() )
{
( ( CBasePlayer * )pOwner)->SetAnimation( PLAYER_RELOAD );
}
float flSequenceEndTime = gpGlobals->curtime + SequenceDuration();
pOwner->SetNextAttack( flSequenceEndTime );
m_flNextPrimaryAttack = m_flNextSecondaryAttack = flSequenceEndTime;
m_bInReload = true;
return true;
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CWeapon_Manhack::ItemPostFrame( void )
{
m_bHasAmmo = false;
m_bHasFreeSlot = HasFreeSlot();
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if (pOwner)
{
if (pOwner->GetAmmoCount(m_iPrimaryAmmoType) > 0)
{
m_bHasAmmo=true;
}
if ( pOwner->m_nButtons & IN_ATTACK )
{
m_bHoldingSpawn = true;
}
else
{
m_bHoldingSpawn = false;
}
}
if (pOwner && !m_bIsDoingShit && !m_bIsDrawing && !m_bIsDoingShitToo && HasAnyAmmo() )
{
if( pOwner->m_nButtons & IN_ATTACK )
{
if ( m_bHasAmmo && (CPropVehicleManhack::GetManhackVehicle() == NULL || m_bHasFreeSlot ) && !m_bIsDoingController)
{
PrimaryAttack();
}
else
{
SecondaryAttack();
}
return;
}
else
{
if ( pOwner->m_nButtons & IN_ATTACK2 && m_bHasFreeSlot )
{
//SendWeaponAnim(ACT_SLAM_DETONATOR_THROW_DRAW);
//m_bIsDoingShitToo=true;
CBaseCombatCharacter *pOwner = GetOwner();
if (pOwner && pOwner->GetAmmoCount(m_iPrimaryAmmoType) > 0 && !m_bSpawnSomeMore )
{
m_bSpawnSomeMore=true;
m_bIsDoingShitToo=true;
}
else if ( HasNPCManhack() && m_bSpawnSomeMore)
{
m_bSpawnSomeMore=false;
//m_bIsDoingShitToo=true;
//m_bIsDoingController=true;
m_bIsDoingShitToo=true;
m_bRedraw=true;
m_bSkip = true;
}
}
}
}
WeaponIdle( );
}
