const char *CHudChat::GetDisplayedSubtitlePlayerName( int clientIndex )
{
C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( clientIndex ) );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pPlayer || !pLocalPlayer )
return BaseClass::GetDisplayedSubtitlePlayerName( clientIndex );
// If they are disguised as the enemy, and not on our team
if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) &&
pPlayer->m_Shared.GetDisguiseTeam() != pPlayer->GetTeamNumber() &&
!pLocalPlayer->InSameTeam( pPlayer ) )
{
C_TFPlayer *pDisguiseTarget = ToTFPlayer( pPlayer->m_Shared.GetDisguiseTarget() );
Assert( pDisguiseTarget );
if ( !pDisguiseTarget )
{
return BaseClass::GetDisplayedSubtitlePlayerName( clientIndex );
}
return pDisguiseTarget->GetPlayerName();
}
return BaseClass::GetDisplayedSubtitlePlayerName( clientIndex );
}
//-----------------------------------------------------------------------------
// Purpose: Player holding this weapon has started building something
// Assumes we are in a valid build position
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::StartBuilding( void )
{
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
CBaseObject *pObj = m_hObjectBeingBuilt.Get();
if ( pPlayer && pPlayer->m_Shared.IsCarryingObject() )
{
Assert( pObj );
pObj->RedeployBuilding( ToTFPlayer( GetOwner() ) );
m_hObjectBeingBuilt = NULL;
pPlayer->m_Shared.SetCarriedObject( NULL );
return;
}
Assert( pObj );
pObj->StartBuilding( GetOwner() );
pObj->AddSpawnFlags( SF_OBJ_UPGRADABLE );
m_hObjectBeingBuilt = NULL;
if ( pPlayer )
{
pPlayer->RemoveInvisibility();
}
}
void CTFViewModel::CalcViewModelView( CBasePlayer *owner, const Vector& eyePosition, const QAngle& eyeAngles )
{
#if defined( CLIENT_DLL )
Vector vecNewOrigin = eyePosition;
QAngle vecNewAngles = eyeAngles;
// Check for lowering the weapon
C_TFPlayer *pPlayer = ToTFPlayer( owner );
Assert( pPlayer );
bool bLowered = pPlayer->IsWeaponLowered();
QAngle vecLoweredAngles(0,0,0);
m_vLoweredWeaponOffset.x = Approach( bLowered ? cl_gunlowerangle.GetFloat() : 0, m_vLoweredWeaponOffset.x, cl_gunlowerspeed.GetFloat() );
vecLoweredAngles.x += m_vLoweredWeaponOffset.x;
vecNewAngles += vecLoweredAngles;
// Viewmodel offset
Vector forward, right, up;
AngleVectors(eyeAngles, &forward, &right, &up);
vecNewOrigin += forward*v_viewmodel_offset_x.GetFloat() + right*v_viewmodel_offset_y.GetFloat() + up*v_viewmodel_offset_z.GetFloat();
if (owner->GetActiveWeapon())
ToTFPlayer(owner)->GetActiveTFWeapon()->UpdateViewModel();
BaseClass::CalcViewModelView( owner, vecNewOrigin, vecNewAngles );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Burn charge level to generate invulnerability
//-----------------------------------------------------------------------------
void CWeaponMedigun::SecondaryAttack( void )
{
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( !pOwner )
return;
if ( !CanAttack() )
return;
// Ensure they have a full charge and are not already in charge release mode
if ( m_flChargeLevel < 1.0 || m_bChargeRelease )
{
#ifdef CLIENT_DLL
// Deny, flash
if ( !m_bChargeRelease && m_flFlashCharge <= 0 )
{
m_flFlashCharge = 10;
pOwner->EmitSound( "Player.DenyWeaponSelection" );
}
#endif
return;
}
if ( pOwner->HasTheFlag() )
{
#ifdef GAME_DLL
CSingleUserRecipientFilter filter( pOwner );
TFGameRules()->SendHudNotification( filter, HUD_NOTIFY_NO_INVULN_WITH_FLAG );
#endif
pOwner->EmitSound( "Player.DenyWeaponSelection" );
return;
}
// Start super charge
m_bChargeRelease = true;
m_flReleaseStartedAt = 0;//gpGlobals->curtime;
#ifdef GAME_DLL
CTF_GameStats.Event_PlayerInvulnerable( pOwner );
pOwner->m_Shared.RecalculateChargeEffects();
pOwner->SpeakConceptIfAllowed( MP_CONCEPT_MEDIC_CHARGEDEPLOYED );
if ( m_hHealingTarget && m_hHealingTarget->IsPlayer() )
{
CTFPlayer *pTFPlayer = ToTFPlayer( m_hHealingTarget );
pTFPlayer->m_Shared.RecalculateChargeEffects();
pTFPlayer->SpeakConceptIfAllowed( MP_CONCEPT_HEALTARGET_CHARGEDEPLOYED );
}
IGameEvent * event = gameeventmanager->CreateEvent( "player_chargedeployed" );
if ( event )
{
event->SetInt( "userid", pOwner->GetUserID() );
gameeventmanager->FireEvent( event, true ); // don't send to clients
}
#endif
}
bool CUsefulHealTargetFilter::IsAllowed(CBaseEntity *ent) const
{
if (ent == nullptr || !ent->IsPlayer() ||
ent->GetTeamNumber() != this->m_iTeamNum) {
return false;
}
if (ToTFPlayer(ent)->IsPlayerClass(TF_CLASS_MEDIC) ||
ToTFPlayer(ent)->IsPlayerClass(TF_CLASS_SNIPER)) {
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Stop placement when holstering
//-----------------------------------------------------------------------------
bool CTFWeaponBuilder::Holster( CBaseCombatWeapon *pSwitchingTo )
{
if ( GetOwner() && ToTFPlayer(GetOwner()) && ToTFPlayer(GetOwner())->m_Shared.IsCarryingObject() )
return false;
if ( m_iBuildState == BS_PLACING || m_iBuildState == BS_PLACING_INVALID )
{
SetCurrentState( BS_IDLE );
}
StopPlacement();
return BaseClass::Holster(pSwitchingTo);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBaseMelee::CalcIsAttackCriticalHelper( void )
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return false;
int nCvarValue = tf_weapon_criticals_melee.GetInt();
if ( nCvarValue == 0 )
return false;
if ( nCvarValue == 1 && !tf_weapon_criticals.GetBool() )
return false;
float flPlayerCritMult = pPlayer->GetCritMult();
float flCritChance = TF_DAMAGE_CRIT_CHANCE_MELEE * flPlayerCritMult;
CALL_ATTRIB_HOOK_FLOAT( flCritChance, mult_crit_chance );
// If the chance is 0, just bail.
if ( flCritChance == 0.0f )
return false;
return ( RandomInt( 0, WEAPON_RANDOM_RANGE-1 ) <= flCritChance * WEAPON_RANDOM_RANGE );
}
//-----------------------------------------------------------------------------
// Purpose: Overridden to allow players to run faster than the maxspeed
//-----------------------------------------------------------------------------
void CTFGameMovement::ProcessMovement( CBasePlayer *pBasePlayer, CMoveData *pMove )
{
// Verify data.
Assert( pBasePlayer );
Assert( pMove );
if ( !pBasePlayer || !pMove )
return;
// Reset point contents for water check.
ResetGetPointContentsCache();
// Cropping movement speed scales mv->m_fForwardSpeed etc. globally
// Once we crop, we don't want to recursively crop again, so we set the crop
// flag globally here once per usercmd cycle.
m_iSpeedCropped = SPEED_CROPPED_RESET;
// Get the current TF player.
m_pTFPlayer = ToTFPlayer( pBasePlayer );
player = m_pTFPlayer;
mv = pMove;
// The max speed is currently set to the scout - if this changes we need to change this!
mv->m_flMaxSpeed = TF_MAX_SPEED; /*tf_maxspeed.GetFloat();*/
// Run the command.
PlayerMove();
FinishMove();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponMedigun::DrainCharge( void )
{
// If we're in charge release mode, drain our charge
if ( m_bChargeRelease )
{
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( !pOwner )
return;
float flChargeAmount = gpGlobals->frametime / weapon_medigun_chargerelease_rate.GetFloat();
m_flChargeLevel = max( m_flChargeLevel - flChargeAmount, 0.0 );
if ( !m_flChargeLevel )
{
m_bChargeRelease = false;
m_flReleaseStartedAt = 0;
#ifdef GAME_DLL
/*
if ( m_bHealingSelf )
{
m_bHealingSelf = false;
pOwner->m_Shared.StopHealing( pOwner );
}
*/
pOwner->m_Shared.RecalculateChargeEffects();
pOwner->m_Shared.RecalculateCrits();
#endif
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponMedigun::AddCharge( void )
{
#ifdef GAME_DLL
CTFPlayer *pPlayer = GetTFPlayerOwner();
CTFPlayer *pHealingTarget = ToTFPlayer( m_hHealingTarget );
#endif
float flNewLevel = min( m_flChargeLevel + 0.25, 1.0 );
if ( flNewLevel >= 1.0 && m_flChargeLevel < 1.0 )
{
#ifdef GAME_DLL
if ( pPlayer )
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_MEDIC_CHARGEREADY );
}
if ( pHealingTarget )
{
pHealingTarget->SpeakConceptIfAllowed( MP_CONCEPT_HEALTARGET_CHARGEREADY );
}
#endif
}
m_flChargeLevel = flNewLevel;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWeaponMedigun::Deploy( void )
{
if ( BaseClass::Deploy() )
{
m_bHolstered = false;
#ifdef GAME_DLL
CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( m_bChargeRelease && pOwner )
{
pOwner->m_Shared.RecalculateChargeEffects();
}
#endif
#ifdef CLIENT_DLL
ManageChargeEffect();
#endif
m_flNextTargetCheckTime = gpGlobals->curtime;
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: only called for local player
//-----------------------------------------------------------------------------
void C_TFWeaponBuilder::Redraw()
{
if ( m_iValidBuildPoseParam >= 0 )
{
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
if ( !pOwner )
return;
// Assuming here that our model is the same as our viewmodel's model!
CBaseViewModel *pViewModel = pOwner->GetViewModel(0);
if ( pViewModel )
{
float flPoseParamValue = pViewModel->GetPoseParameter( m_iValidBuildPoseParam );
C_BaseObject *pObj = m_hObjectBeingBuilt.Get();
if ( pObj && pObj->WasLastPlacementPosValid() )
{
// pose param approach 1.0
flPoseParamValue = Approach( 1.0, flPoseParamValue, 3.0 * gpGlobals->frametime );
}
else
{
// pose param approach 0.0
flPoseParamValue = Approach( 0.0, flPoseParamValue, 1.5 * gpGlobals->frametime );
}
pViewModel->SetPoseParameter( m_iValidBuildPoseParam, flPoseParamValue );
}
}
BaseClass::Redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFMinigun::WindUp( void )
{
// Get the player owning the weapon.
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return;
// Play wind-up animation and sound (SPECIAL1).
SendWeaponAnim( ACT_MP_ATTACK_STAND_PREFIRE );
// Set the appropriate firing state.
m_iWeaponState = AC_STATE_STARTFIRING;
pPlayer->m_Shared.AddCond( TF_COND_AIMING );
#ifndef CLIENT_DLL
pPlayer->StopRandomExpressions();
#endif
#ifdef CLIENT_DLL
WeaponSoundUpdate();
#endif
// Update player's speed
pPlayer->TeamFortress_SetSpeed();
}
//-----------------------------------------------------------------------------
// Found a Target
//-----------------------------------------------------------------------------
void CObjectSentrygun::FoundTarget( CBaseEntity *pTarget, const Vector &vecSoundCenter )
{
m_hEnemy = pTarget;
if ( ( m_iAmmoShells > 0 ) || ( m_iAmmoRockets > 0 && m_iUpgradeLevel == 3 ) )
{
// Play one sound to everyone but the target.
CPASFilter filter( vecSoundCenter );
if ( pTarget->IsPlayer() )
{
CTFPlayer *pPlayer = ToTFPlayer( pTarget );
// Play a specific sound just to the target and remove it from the genral recipient list.
CSingleUserRecipientFilter singleFilter( pPlayer );
EmitSound( singleFilter, entindex(), "Building_Sentrygun.AlertTarget" );
filter.RemoveRecipient( pPlayer );
}
EmitSound( filter, entindex(), "Building_Sentrygun.Alert" );
}
// Update timers, we are attacking now!
m_iState.Set( SENTRY_STATE_ATTACKING );
m_flNextAttack = gpGlobals->curtime + SENTRY_THINK_DELAY;
if ( m_flNextRocketAttack < gpGlobals->curtime )
{
m_flNextRocketAttack = gpGlobals->curtime + 0.5;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFFlareGun::LaunchProjectile(void)
{
// Get the player owning the weapon.
CTFPlayer *pPlayer = ToTFPlayer(GetPlayerOwner());
if (!pPlayer)
return;
CalcIsAttackCritical();
SendWeaponAnim(ACT_VM_PRIMARYATTACK);
pPlayer->SetAnimation(PLAYER_ATTACK1);
pPlayer->DoAnimationEvent(PLAYERANIMEVENT_ATTACK_PRIMARY);
FireProjectile(pPlayer);
#if !defined( CLIENT_DLL )
pPlayer->SpeakWeaponFire();
CTF_GameStats.Event_PlayerFiredWeapon(pPlayer, IsCurrentAttackACrit());
#endif
// Set next attack times.
m_flNextPrimaryAttack = gpGlobals->curtime + m_pWeaponInfo->GetWeaponData(m_iWeaponMode).m_flTimeFireDelay;
SetWeaponIdleTime(gpGlobals->curtime + SequenceDuration());
// Check the reload mode and behave appropriately.
if (m_bReloadsSingly)
{
m_iReloadMode.Set(TF_RELOAD_START);
}
}
void CTFWeaponBuilder::SecondaryAttack( void )
{
if ( m_bInAttack2 )
return;
// require a re-press
m_bInAttack2 = true;
CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
if ( !pOwner )
return;
if ( pOwner->DoClassSpecialSkill() )
{
// intentionally blank
}
else if ( m_iBuildState == BS_PLACING )
{
if ( m_hObjectBeingBuilt )
{
pOwner->StopHintTimer( HINT_ALTFIRE_ROTATE_BUILDING );
m_hObjectBeingBuilt->RotateBuildAngles();
}
}
m_flNextSecondaryAttack = gpGlobals->curtime + 0.2f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHunterRifle::ItemPostFrame( void )
{
// If we're lowered, we're not allowed to fire
if ( m_bLowered )
return;
// Get the owning player.
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( !pPlayer )
return;
CheckReload();
if ( !CanAttack() )
{
if ( IsZoomed() )
{
ToggleZoom();
}
return;
}
HandleZooms();
if ( m_flNextSecondaryAttack <= gpGlobals->curtime )
{
// Don't start charging in the time just after a shot before we unzoom to play rack anim.
if ( pPlayer->m_Shared.InCond( TF_COND_AIMING ) && !m_bRezoomAfterShot )
{
m_flChargedSpread = max(m_flChargedSpread - gpGlobals->frametime * TF_WEAPON_HUNTERRIFLE_CHARGE_PER_SEC, TF_WEAPON_HUNTERRIFLE_SPREAD_MIN);
}
else
{
m_flChargedSpread = min(TF_WEAPON_HUNTERRIFLE_SPREAD_MAX, m_flChargedSpread + gpGlobals->frametime * TF_WEAPON_HUNTERRIFLE_UNCHARGE_PER_SEC);
}
}
// Fire.
if ( pPlayer->m_nButtons & IN_ATTACK )
{
Fire( pPlayer );
}
// Reload pressed / Clip Empty
if ( ( pPlayer->m_nButtons & IN_RELOAD ) && !m_bInReload )
{
// reload when reload is pressed, or if no buttons are down and weapon is empty.
Reload();
}
// Idle.
if ( !( ( pPlayer->m_nButtons & IN_ATTACK) || ( pPlayer->m_nButtons & IN_ATTACK2 ) ) )
{
// No fire buttons down or reloading
if ( !ReloadOrSwitchWeapons() && ( m_bInReload == false ) )
{
WeaponIdle();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
//-----------------------------------------------------------------------------
void CViewModelInvisProxy::OnBind( C_BaseEntity *pEnt )
{
if ( !m_pPercentInvisible )
return;
if ( !pEnt )
return;
CTFViewModel *pVM = dynamic_cast<CTFViewModel *>( pEnt );
if ( !pVM )
{
m_pPercentInvisible->SetFloatValue( 0.0f );
return;
}
CTFPlayer *pPlayer = ToTFPlayer( pVM->GetOwner() );
if ( !pPlayer )
{
m_pPercentInvisible->SetFloatValue( 0.0f );
return;
}
float flPercentInvisible = pPlayer->GetPercentInvisible();
// remap from 0.22 to 0.5
// but drop to 0.0 if we're not invis at all
float flWeaponInvis = ( flPercentInvisible < 0.01 ) ?
0.0 :
RemapVal( flPercentInvisible, 0.0, 1.0, tf_vm_min_invis.GetFloat(), tf_vm_max_invis.GetFloat() );
m_pPercentInvisible->SetFloatValue( flWeaponInvis );
}
//-----------------------------------------------------------------------------
// Purpose: Player has waved his crosshair over this entity. Display appropriate hints.
//-----------------------------------------------------------------------------
void C_BaseObject::DisplayHintTo( C_BasePlayer *pPlayer )
{
bool bHintPlayed = false;
C_TFPlayer *pTFPlayer = ToTFPlayer(pPlayer);
if ( InSameTeam( pPlayer ) )
{
// We're looking at a friendly object.
if ( HasSapper() )
{
bHintPlayed = pPlayer->HintMessage( HINT_OBJECT_HAS_SAPPER, true, true );
}
if ( pTFPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) )
{
// I'm an engineer.
// If I'm looking at a constructing object, let me know I can help build it (but not
// if I built it myself, since I've already got that hint from the wrench).
if ( !bHintPlayed && IsBuilding() && GetBuilder() != pTFPlayer )
{
bHintPlayed = pPlayer->HintMessage( HINT_ENGINEER_USE_WRENCH_ONOTHER, false, true );
}
// If it's damaged, I can repair it
if ( !bHintPlayed && !IsBuilding() && GetHealth() < GetMaxHealth() )
{
bHintPlayed = pPlayer->HintMessage( HINT_ENGINEER_REPAIR_OBJECT, false, true );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// NOTE: Should this be put into fire gun
//-----------------------------------------------------------------------------
void CTFWeaponBaseGun::DoFireEffects()
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return;
// Muzzle flash on weapon.
bool bMuzzleFlash = true;
// We no longer need this
/*
if ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
{
//CTFWeaponBase *pWeapon = pPlayer->GetActiveTFWeapon();
//if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_MINIGUN )
if (pPlayer->IsActiveTFWeapon(TF_WEAPON_MINIGUN))
{
bMuzzleFlash = false;
}
}*/
if ( bMuzzleFlash )
{
pPlayer->DoMuzzleFlash();
}
}
ActionResult<CTFBot> CTFBotMarkGiants::OnStart(CTFBot *actor, Action<CTFBot> *action)
{
this->m_PathFollower.SetMinLookAheadDistance(actor->GetDesiredPathLookAheadRange());
CTFWeaponBase *weapon = GetMarkForDeathWeapon(actor);
if (weapon == nullptr) {
return ActionResult<CTFBot>::Done("Don't have a mark-for-death weapon.");
}
std::vector<CTFPlayer *> potential_victims;
ForEachPlayer([&](CBasePlayer *player, bool& done){
CTFPlayer *tfplayer = ToTFPlayer(player);
if (tfplayer == nullptr) return;
if (IsPlayerMarkable(actor, tfplayer)) {
potential_victims.push_back(tfplayer);
}
});
if (potential_victims.empty()) {
return ActionResult<CTFBot>::Done("No eligible mark victims.");
}
this->m_hTarget = potential_victims[RandomInt(0, potential_victims.size() - 1)];
actor->PushRequiredWeapon(weapon);
return ActionResult<CTFBot>::Continue();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBuilder::Deploy( void )
{
bool bDeploy = BaseClass::Deploy();
if ( bDeploy )
{
SetCurrentState( BS_PLACING );
StartPlacement();
m_flNextPrimaryAttack = gpGlobals->curtime + 0.35f;
m_flNextSecondaryAttack = gpGlobals->curtime; // asap
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if (!pPlayer)
return false;
pPlayer->SetNextAttack( gpGlobals->curtime );
m_iWorldModelIndex = modelinfo->GetModelIndex( GetWorldModel() );
m_flNextDenySound = 0;
// Set off the hint here, because we don't know until now if our building
// is rotate-able or not.
if ( m_hObjectBeingBuilt && !m_hObjectBeingBuilt->MustBeBuiltOnAttachmentPoint() )
{
// set the alt-fire hint so it gets removed when we holster
m_iAltFireHint = HINT_ALTFIRE_ROTATE_BUILDING;
pPlayer->StartHintTimer( m_iAltFireHint );
}
}
return bDeploy;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChangeClassZone::Touch( CBaseEntity *pOther )
{
if ( !IsDisabled() )
{
CTFPlayer *pPlayer = ToTFPlayer( pOther );
if ( pPlayer )
{
if ( pPlayer->GetNextChangeClassTime() > gpGlobals->curtime )
return;
int iTeam = GetTeamNumber();
if ( iTeam && ( pPlayer->GetTeamNumber() != iTeam ) )
return;
// bring up the player's changeclass menu
CCommand args;
args.Tokenize( "changeclass" );
pPlayer->ClientCommand( args );
pPlayer->SetNextChangeClassTime( gpGlobals->curtime + TF_CHANGECLASS_NEXT_USE_TIME );
CPASAttenuationFilter filter( pOther, TF_CHANGECLASS_SOUND );
EmitSound( filter, pOther->entindex(), TF_CHANGECLASS_SOUND );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Don't render the weapon if its supposed to be lowered and we have
// finished the lowering animation
//-----------------------------------------------------------------------------
int CTFViewModel::DrawModel( int flags )
{
// Check for lowering the weapon
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
Assert( pPlayer );
bool bLowered = pPlayer->IsWeaponLowered();
if ( bLowered && fabs( m_vLoweredWeaponOffset.x - cl_gunlowerangle.GetFloat() ) < 0.1 )
{
// fully lowered, stop drawing
return 1;
}
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE &&
pLocalPlayer->GetObserverTarget() && pLocalPlayer->GetObserverTarget()->IsPlayer() )
{
pPlayer = ToTFPlayer( pLocalPlayer->GetObserverTarget() );
if ( pPlayer != GetOwner() )
return 0;
}
if ( pPlayer->IsAlive() == false )
{
return 0;
}
return BaseClass::DrawModel( flags );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFViewModel::GetSkin()
{
int nSkin = BaseClass::GetSkin();
CTFWeaponBase *pWeapon = ( CTFWeaponBase * )GetOwningWeapon();
if ( !pWeapon )
return nSkin;
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( pPlayer )
{
if ( pWeapon->GetTFWpnData().m_bHasTeamSkins_Viewmodel )
{
switch( pPlayer->GetTeamNumber() )
{
case TF_TEAM_RED:
nSkin = 0;
break;
case TF_TEAM_BLUE:
nSkin = 1;
break;
case TF_TEAM_GREEN:
nSkin = 2;
break;
case TF_TEAM_YELLOW:
nSkin = 3;
break;
}
}
}
return nSkin;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFMinigun::WindDown( void )
{
// Get the player owning the weapon.
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return;
SendWeaponAnim( ACT_MP_ATTACK_STAND_POSTFIRE );
// Set the appropriate firing state.
m_iWeaponState = AC_STATE_IDLE;
pPlayer->m_Shared.RemoveCond( TF_COND_AIMING );
#ifdef CLIENT_DLL
WeaponSoundUpdate();
#else
pPlayer->ClearWeaponFireScene();
#endif
// Time to weapon idle.
m_flTimeWeaponIdle = gpGlobals->curtime + 2.0;
// Update player's speed
pPlayer->TeamFortress_SetSpeed();
#ifdef CLIENT_DLL
m_flBarrelTargetVelocity = 0;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncRespawnFlagZone::Touch( CBaseEntity *pOther )
{
if (!IsDisabled())
{
CTFPlayer *pPlayer = ToTFPlayer(pOther);
if ( pPlayer && pPlayer->HasTheFlag() )
{
CTFItem *pItem = pPlayer->GetItem();
if (pItem)
{
CCaptureFlag *pFlag = dynamic_cast<CCaptureFlag*>(pItem);
pPlayer->DropFlag();
if (pFlag)
{
pFlag->Reset();
pFlag->ResetMessage();
}
}
else
{
pPlayer->DropFlag();
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Detonate active pipebombs
//-----------------------------------------------------------------------------
void CTFPipebombLauncher::SecondaryAttack( void )
{
if ( !CanAttack() )
return;
if ( m_iPipebombCount )
{
// Get a valid player.
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if ( !pPlayer )
return;
//If one or more pipebombs failed to detonate then play a sound.
if ( DetonateRemotePipebombs( false ) == true )
{
if ( m_flLastDenySoundTime <= gpGlobals->curtime )
{
// Deny!
m_flLastDenySoundTime = gpGlobals->curtime + 1;
WeaponSound( SPECIAL2 );
return;
}
}
else
{
// Play a detonate sound.
#ifdef CLIENT_DLL
if ( prediction->IsFirstTimePredicted() )
#endif
WeaponSound( SPECIAL3 );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGrenadeMirvProjectile::Explode( trace_t *pTrace, int bitsDamageType )
{
// Pass through.
BaseClass::Explode( pTrace, bitsDamageType );
// Server specific.
#ifdef GAME_DLL
// Create the bomblets.
for ( int iBomb = 0; iBomb < TF_WEAPON_GRENADE_MIRV_BOMB_COUNT; ++iBomb )
{
Vector vecSrc = pTrace->endpos + Vector( 0, 0, 1.0f );
Vector vecVelocity( random->RandomFloat( -75.0f, 75.0f ) * 3.0f,
random->RandomFloat( -75.0f, 75.0f ) * 3.0f,
random->RandomFloat( 30.0f, 70.0f ) * 5.0f );
Vector vecZero( 0,0,0 );
CTFPlayer *pPlayer = ToTFPlayer( GetThrower() );
float flTime = 2.0f + random->RandomFloat( 0.0f, 1.0f );
CTFGrenadeMirvBomb *pBomb = CTFGrenadeMirvBomb::Create( vecSrc, GetAbsAngles(), vecVelocity, vecZero, pPlayer, flTime );
pBomb->SetDamage( GetDamage() * 0.5f );
pBomb->SetDamageRadius( GetDamageRadius() );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Fall through to Primary Attack
//-----------------------------------------------------------------------------
void CTFMinigun::SecondaryAttack( void )
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
if ( !pPlayer )
return;
SharedAttack();
}
