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(); }