bool CHudProgressBar::ShouldDraw()
{
C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
if( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
{
C_BaseEntity *pTarget = pPlayer->GetObserverTarget();
if( pTarget && pTarget->IsPlayer() )
{
pPlayer = ToCSPlayer( pTarget );
if( !pPlayer->IsAlive() )
return false;
}
else
return false;
}
if( !pPlayer || pPlayer->m_iProgressBarDuration == 0 || pPlayer->m_lifeState == LIFE_DEAD )
{
return false;
}
return cl_c4progressbar.GetBool();
}
//-----------------------------------------------------------------------------
// Purpose: Draw targeting reticle
//-----------------------------------------------------------------------------
void C_WeaponCombat_ChargeablePlasma::DrawCrosshair( void )
{
BaseClass::DrawCrosshair();
// Find enemy players in front of me
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return;
trace_t tr;
Vector vecStart, vecEnd;
VectorMA( CurrentViewOrigin(), 1500, CurrentViewForward(), vecEnd );
VectorMA( CurrentViewOrigin(), 48, CurrentViewForward(), vecStart );
UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &tr );
if ( tr.DidHitNonWorldEntity() )
{
C_BaseEntity *pEntity = tr.m_pEnt;
if ( pEntity && pEntity->IsPlayer() && !pPlayer->InSameTeam( pEntity ) )
{
// Draw a reticle
vgui::Color clr = gHUD.m_clrYellowish;
clr[3] = 128;
// Calculate circle size
int iRatio = 30;
// Draw the circle
int iDegrees = 0;
Vector vecPoint, vecLastPoint(0,0,0);
vecPoint.z = 0.0f;
for ( int i = 0; i < 360; i++ )
{
float flRadians = DEG2RAD( iDegrees );
iDegrees += (360 / 360);
float ca = cos( flRadians );
float sa = sin( flRadians );
// Rotate it around the circle
vecPoint.x = (int)((ScreenWidth() / 2) + (iRatio * sa));
vecPoint.y = (int)((ScreenHeight() / 2) - (iRatio * ca));
// Draw the point, if it's not on the previous point, to avoid smaller circles being brighter
if ( vecLastPoint != vecPoint )
{
vgui::surface()->DrawSetColor( clr );
vgui::surface()->DrawFilledRect( vecPoint.x, vecPoint.y, vecPoint.x + 1, vecPoint.y + 1 );
}
vecLastPoint = vecPoint;
}
}
}
}
// Actual work code
IterationRetval_t CASW_MarineAndObjectEnumerator::EnumElement( IHandleEntity *pHandleEntity )
{
if ( !m_pLocal )
return ITERATION_STOP;
C_BaseEntity *pEnt = ClientEntityList().GetBaseEntityFromHandle( pHandleEntity->GetRefEHandle() );
if ( pEnt == NULL )
return ITERATION_CONTINUE;
if ( pEnt == m_pLocal )
return ITERATION_CONTINUE;
if ( !pEnt->IsPlayer() &&
!pEnt->IsNPC() )
{
return ITERATION_CONTINUE;
}
if ( pEnt->IsNPC() )
{
C_AI_BaseNPC *pNPC = (C_AI_BaseNPC *)pEnt;
if ( !pNPC->ShouldAvoidObstacle() )
return ITERATION_CONTINUE;
}
// Ignore vehicles, since they have vcollide collisions that's push me away
if ( pEnt->GetCollisionGroup() == COLLISION_GROUP_VEHICLE )
return ITERATION_CONTINUE;
#ifdef TF2_CLIENT_DLL
// If it's solid to player movement, don't steer around it since we'll just bump into it
if ( pEnt->GetCollisionGroup() == TFCOLLISION_GROUP_OBJECT_SOLIDTOPLAYERMOVEMENT )
return ITERATION_CONTINUE;
#endif
C_ASW_Marine *pMarine = m_pLocal->GetMarine();
if (!pMarine)
return ITERATION_CONTINUE;
Vector deltaPos = pEnt->GetAbsOrigin() - pMarine->GetAbsOrigin();
//if ( deltaPos.LengthSqr() > m_flRadiusSquared )
//return ITERATION_CONTINUE;
CHandle< C_BaseEntity > h;
h = pEnt;
m_Objects.AddToTail( h );
return ITERATION_CONTINUE;
}
void CHudProgressBar::Paint()
{
C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
if( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
{
C_BaseEntity *pTarget = pPlayer->GetObserverTarget();
if( pTarget && pTarget->IsPlayer() )
{
pPlayer = ToCSPlayer( pTarget );
if( !pPlayer->IsAlive() )
return;
}
else
return;
}
if ( !pPlayer )
return;
int x, y, wide, tall;
GetBounds( x, y, wide, tall );
tall = 10;
int xOffset=0;
int yOffset=0;
Color clr = m_clrProgress;
clr[3] = 160;
vgui::surface()->DrawSetColor( clr );
vgui::surface()->DrawOutlinedRect( xOffset, yOffset, xOffset+wide, yOffset+tall );
if( pPlayer->m_iProgressBarDuration > 0 )
{
// ProgressBarStartTime is now with respect to m_flSimulationTime rather than local time
float percent = (pPlayer->m_flSimulationTime - pPlayer->m_flProgressBarStartTime) / (float)pPlayer->m_iProgressBarDuration;
percent = clamp( percent, 0, 1 );
clr[3] = 240;
vgui::surface()->DrawSetColor( clr );
vgui::surface()->DrawFilledRect( xOffset+2, yOffset+2, xOffset+(int)(percent*wide)-2, yOffset+tall-2 );
}
}
// Actual work code
IterationRetval_t CPlayerAndObjectEnumerator::EnumElement( IHandleEntity *pHandleEntity )
{
if ( !m_pLocal )
return ITERATION_STOP;
C_BaseEntity *pEnt = ClientEntityList().GetBaseEntityFromHandle( pHandleEntity->GetRefEHandle() );
if ( pEnt == NULL )
return ITERATION_CONTINUE;
if ( pEnt == m_pLocal )
return ITERATION_CONTINUE;
if ( !pEnt->IsPlayer() &&
!pEnt->IsNPC() )
{
return ITERATION_CONTINUE;
}
if ( pEnt->IsNPC() )
{
C_AI_BaseNPC *pNPC = (C_AI_BaseNPC *)pEnt;
if ( !pNPC->ShouldAvoidObstacle() )
return ITERATION_CONTINUE;
}
// Ignore vehicles, since they have vcollide collisions that's push me away
if ( pEnt->GetCollisionGroup() == COLLISION_GROUP_VEHICLE )
return ITERATION_CONTINUE;
Vector deltaPos = pEnt->GetAbsOrigin() - m_pLocal->GetAbsOrigin();
if ( deltaPos.LengthSqr() > m_flRadiusSquared )
return ITERATION_CONTINUE;
CHandle< C_BaseEntity > h;
h = pEnt;
m_Objects.AddToTail( h );
return ITERATION_CONTINUE;
}
virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
{
// Test against the vehicle too?
// FLASHLIGHTFIXME: how do you know that you are actually inside of the vehicle?
C_BaseEntity *pEntity = EntityFromEntityHandle( pServerEntity );
if ( !pEntity )
return true;
if ( ( ToBaseViewModel( pEntity ) != NULL ) ||
pEntity == m_pPlayer ||
pEntity == m_pLowerBody ||
( m_bSkipPlayers && pEntity->IsPlayer() ) ||
pEntity->GetCollisionGroup() == COLLISION_GROUP_DEBRIS ||
pEntity->GetCollisionGroup() == COLLISION_GROUP_INTERACTIVE_DEBRIS )
{
return false;
}
return true;
}
// Actual work code
IterationRetval_t CPlayerAndObjectEnumerator::EnumElement( IHandleEntity *pHandleEntity )
{
if ( !m_pLocal )
return ITERATION_STOP;
C_BaseEntity *pEnt = ClientEntityList().GetBaseEntityFromHandle( pHandleEntity->GetRefEHandle() );
if ( pEnt == NULL )
return ITERATION_CONTINUE;
if ( pEnt == m_pLocal )
return ITERATION_CONTINUE;
if ( !pEnt->IsPlayer() &&
!pEnt->IsBaseObject() )
{
return ITERATION_CONTINUE;
}
// Ignore vehicles, since they have vcollide collisions that's push me away
if ( pEnt->GetCollisionGroup() == COLLISION_GROUP_VEHICLE )
return ITERATION_CONTINUE;
// If it's solid to player movement, don't steer around it since we'll just bump into it
if ( pEnt->GetCollisionGroup() == TFCOLLISION_GROUP_OBJECT_SOLIDTOPLAYERMOVEMENT )
return ITERATION_CONTINUE;
Vector deltaPos = pEnt->GetAbsOrigin() - m_pLocal->GetAbsOrigin();
if ( deltaPos.LengthSqr() > m_flRadiusSquared )
return ITERATION_CONTINUE;
CHandle< C_BaseEntity > h;
h = pEnt;
m_Objects.AddToTail( h );
return ITERATION_CONTINUE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFHudFlagObjectives::OnTick()
{
// iterate through the flags to set their position in our HUD
for ( int i = 0; i < g_Flags.Count(); i++ )
{
CCaptureFlag *pFlag = dynamic_cast< CCaptureFlag* >( ClientEntityList().GetEnt( g_Flags[i] ) );
if ( pFlag )
{
if (!pFlag->IsDisabled())
{
if (m_pRedFlag && pFlag->GetTeamNumber() == TF_TEAM_RED)
{
m_pRedFlag->SetEntity(pFlag);
}
else if (m_pBlueFlag && pFlag->GetTeamNumber() == TF_TEAM_BLUE)
{
m_pBlueFlag->SetEntity(pFlag);
}
else if (m_pGreenFlag && pFlag->GetTeamNumber() == TF_TEAM_GREEN)
{
m_pGreenFlag->SetEntity(pFlag);
}
else if (m_pYellowFlag && pFlag->GetTeamNumber() == TF_TEAM_YELLOW)
{
m_pYellowFlag->SetEntity(pFlag);
}
}
}
else
{
// this isn't a valid index for a flag
g_Flags.Remove( i );
}
}
// are we playing captures for rounds?
if ( tf_flag_caps_per_round.GetInt() > 0 )
{
C_TFTeam *pTeam = GetGlobalTFTeam( TF_TEAM_BLUE );
if ( pTeam )
{
SetDialogVariable( "bluescore", pTeam->GetFlagCaptures() );
}
pTeam = GetGlobalTFTeam( TF_TEAM_RED );
if ( pTeam )
{
SetDialogVariable( "redscore", pTeam->GetFlagCaptures() );
}
SetPlayingToLabelVisible( true );
SetDialogVariable( "rounds", tf_flag_caps_per_round.GetInt() );
}
else // we're just playing straight score
{
C_TFTeam *pTeam = GetGlobalTFTeam( TF_TEAM_BLUE );
if ( pTeam )
{
SetDialogVariable( "bluescore", pTeam->Get_Score() );
}
pTeam = GetGlobalTFTeam( TF_TEAM_RED );
if ( pTeam )
{
SetDialogVariable( "redscore", pTeam->Get_Score() );
}
SetPlayingToLabelVisible( false );
}
// check the local player to see if they're spectating, OBS_MODE_IN_EYE, and the target entity is carrying the flag
bool bSpecCarriedImage = false;
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pPlayer && ( pPlayer->GetObserverMode() == OBS_MODE_IN_EYE ) )
{
// does our target have the flag?
C_BaseEntity *pEnt = pPlayer->GetObserverTarget();
if ( pEnt && pEnt->IsPlayer() )
{
C_TFPlayer *pTarget = static_cast< C_TFPlayer* >( pEnt );
if ( pTarget->HasTheFlag() )
{
bSpecCarriedImage = true;
CCaptureFlag *pPlayerFlag = dynamic_cast<CCaptureFlag*>(pTarget->GetItem());
if (m_pSpecCarriedImage)
{
switch (pPlayerFlag->GetTeamNumber())
{
case TF_TEAM_RED:
m_pSpecCarriedImage->SetImage(("%s_red", STRING(pPlayerFlag->m_szHudIcon)));
break;
case TF_TEAM_BLUE:
m_pSpecCarriedImage->SetImage(("%s_blue", STRING(pPlayerFlag->m_szHudIcon)));
break;
case TF_TEAM_GREEN:
m_pSpecCarriedImage->SetImage(("%s_green", STRING(pPlayerFlag->m_szHudIcon)));
break;
case TF_TEAM_YELLOW:
m_pSpecCarriedImage->SetImage(("%s_yellow", STRING(pPlayerFlag->m_szHudIcon)));
break;
}
}
}
}
}
if ( bSpecCarriedImage )
{
if ( m_pSpecCarriedImage && !m_pSpecCarriedImage->IsVisible() )
{
m_pSpecCarriedImage->SetVisible( true );
}
}
else
{
if ( m_pSpecCarriedImage && m_pSpecCarriedImage->IsVisible() )
{
m_pSpecCarriedImage->SetVisible( false );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFArrowPanel::Paint()
{
if ( !m_hEntity.Get() )
return;
C_BaseEntity *pEnt = m_hEntity.Get();
IMaterial *pMaterial = m_NeutralMaterial;
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
// figure out what material we need to use
if ( pEnt->GetTeamNumber() == TF_TEAM_RED )
{
pMaterial = m_RedMaterial;
if ( pLocalPlayer && ( pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE ) )
{
// is our target a player?
C_BaseEntity *pTargetEnt = pLocalPlayer->GetObserverTarget();
if ( pTargetEnt && pTargetEnt->IsPlayer() )
{
// does our target have the flag and are they carrying the flag we're currently drawing?
C_TFPlayer *pTarget = static_cast< C_TFPlayer* >( pTargetEnt );
if ( pTarget->HasTheFlag() && ( pTarget->GetItem() == pEnt ) )
{
pMaterial = m_RedMaterialNoArrow;
}
}
}
}
else if ( pEnt->GetTeamNumber() == TF_TEAM_BLUE )
{
pMaterial = m_BlueMaterial;
if ( pLocalPlayer && ( pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE ) )
{
// is our target a player?
C_BaseEntity *pTargetEnt = pLocalPlayer->GetObserverTarget();
if ( pTargetEnt && pTargetEnt->IsPlayer() )
{
// does our target have the flag and are they carrying the flag we're currently drawing?
C_TFPlayer *pTarget = static_cast< C_TFPlayer* >( pTargetEnt );
if ( pTarget->HasTheFlag() && ( pTarget->GetItem() == pEnt ) )
{
pMaterial = m_BlueMaterialNoArrow;
}
}
}
}
else if (pEnt->GetTeamNumber() == TF_TEAM_GREEN)
{
pMaterial = m_GreenMaterial;
if (pLocalPlayer && (pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE))
{
// is our target a player?
C_BaseEntity *pTargetEnt = pLocalPlayer->GetObserverTarget();
if (pTargetEnt && pTargetEnt->IsPlayer())
{
// does our target have the flag and are they carrying the flag we're currently drawing?
C_TFPlayer *pTarget = static_cast< C_TFPlayer* >(pTargetEnt);
if (pTarget->HasTheFlag() && (pTarget->GetItem() == pEnt))
{
pMaterial = m_GreenMaterialNoArrow;
}
}
}
}
else if (pEnt->GetTeamNumber() == TF_TEAM_YELLOW)
{
pMaterial = m_YellowMaterial;
if (pLocalPlayer && (pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE))
{
// is our target a player?
C_BaseEntity *pTargetEnt = pLocalPlayer->GetObserverTarget();
if (pTargetEnt && pTargetEnt->IsPlayer())
{
// does our target have the flag and are they carrying the flag we're currently drawing?
C_TFPlayer *pTarget = static_cast< C_TFPlayer* >(pTargetEnt);
if (pTarget->HasTheFlag() && (pTarget->GetItem() == pEnt))
{
pMaterial = m_YellowMaterialNoArrow;
}
}
}
}
int x = 0;
int y = 0;
ipanel()->GetAbsPos( GetVPanel(), x, y );
int nWidth = GetWide();
int nHeight = GetTall();
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PushMatrix();
VMatrix panelRotation;
panelRotation.Identity();
MatrixBuildRotationAboutAxis( panelRotation, Vector( 0, 0, 1 ), GetAngleRotation() );
// MatrixRotate( panelRotation, Vector( 1, 0, 0 ), 5 );
panelRotation.SetTranslation( Vector( x + nWidth/2, y + nHeight/2, 0 ) );
pRenderContext->LoadMatrix( panelRotation );
IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.TexCoord2f( 0, 0, 0 );
meshBuilder.Position3f( -nWidth/2, -nHeight/2, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord2f( 0, 1, 0 );
meshBuilder.Position3f( nWidth/2, -nHeight/2, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord2f( 0, 1, 1 );
meshBuilder.Position3f( nWidth/2, nHeight/2, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord2f( 0, 0, 1 );
meshBuilder.Position3f( -nWidth/2, nHeight/2, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
pRenderContext->PopMatrix();
}
//-----------------------------------------------------------------------------
// common and useful types to query for hierarchically
//-----------------------------------------------------------------------------
bool CClientTools::IsPlayer( EntitySearchResult currentEnt )
{
C_BaseEntity *ent = reinterpret_cast< C_BaseEntity* >( currentEnt );
return ent ? ent->IsPlayer() : false;
}
void CBasePlayerAnimState::Update( float eyeYaw, float eyePitch )
{
VPROF( "CBasePlayerAnimState::Update" );
// Clear animation overlays because we're about to completely reconstruct them.
ClearAnimationLayers();
// Some mods don't want to update the player's animation state if they're dead and ragdolled.
if ( !ShouldUpdateAnimState() )
{
ClearAnimationState();
return;
}
CStudioHdr *pStudioHdr = GetOuter()->GetModelPtr();
// Store these. All the calculations are based on them.
m_flEyeYaw = AngleNormalize( eyeYaw );
m_flEyePitch = AngleNormalize( eyePitch );
// Compute sequences for all the layers.
ComputeSequences( pStudioHdr );
// Compute all the pose params.
ComputePoseParam_BodyPitch( pStudioHdr ); // Look up/down.
ComputePoseParam_BodyYaw(); // Torso rotation.
ComputePoseParam_MoveYaw( pStudioHdr ); // What direction his legs are running in.
ComputePlaybackRate();
#ifdef CLIENT_DLL
if ( cl_showanimstate.GetInt() == m_pOuter->entindex() )
{
DebugShowAnimStateFull( 5 );
}
else if ( cl_showanimstate.GetInt() == -2 )
{
C_BasePlayer *targetPlayer = C_BasePlayer::GetLocalPlayer();
if( targetPlayer && ( targetPlayer->GetObserverMode() == OBS_MODE_IN_EYE || targetPlayer->GetObserverMode() == OBS_MODE_CHASE ) )
{
C_BaseEntity *target = targetPlayer->GetObserverTarget();
if( target && target->IsPlayer() )
{
targetPlayer = ToBasePlayer( target );
}
}
if ( m_pOuter == targetPlayer )
{
DebugShowAnimStateFull( 6 );
}
}
#else
if ( sv_showanimstate.GetInt() == m_pOuter->entindex() )
{
DebugShowAnimState( 20 );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void TFExplosionCallback( const Vector &vecOrigin, const Vector &vecNormal, int iWeaponID, ClientEntityHandle_t hEntity, C_TFPlayer *pPlayer, int iTeam, bool bCrit, int iItemID )
{
// Get the weapon information.
CTFWeaponInfo *pWeaponInfo = NULL;
switch ( iWeaponID )
{
case TF_WEAPON_GRENADE_PIPEBOMB:
case TF_WEAPON_GRENADE_DEMOMAN:
pWeaponInfo = GetTFWeaponInfo( TF_WEAPON_PIPEBOMBLAUNCHER );
break;
default:
pWeaponInfo = GetTFWeaponInfo( iWeaponID );
break;
}
bool bIsPlayer = false;
if ( hEntity.Get() )
{
C_BaseEntity *pEntity = C_BaseEntity::Instance( hEntity );
if ( pEntity && pEntity->IsPlayer() )
{
bIsPlayer = true;
}
}
// Calculate the angles, given the normal.
bool bIsWater = ( UTIL_PointContents( vecOrigin ) & CONTENTS_WATER );
bool bInAir = false;
QAngle angExplosion( 0.0f, 0.0f, 0.0f );
// Cannot use zeros here because we are sending the normal at a smaller bit size.
if ( fabs( vecNormal.x ) < 0.05f && fabs( vecNormal.y ) < 0.05f && fabs( vecNormal.z ) < 0.05f )
{
bInAir = true;
angExplosion.Init();
}
else
{
VectorAngles( vecNormal, angExplosion );
bInAir = false;
}
bool bDeathmatchOverride = ( pPlayer && TFGameRules()->IsDeathmatch() );
// Base explosion effect and sound.
const char *pszEffect = "explosion";
const char *pszSound = "BaseExplosionEffect.Sound";
if ( pWeaponInfo )
{
// Explosions.
if ( bIsWater )
{
if ( bCrit && pWeaponInfo->m_szExplosionWaterEffect_Crit[0] )
{
pszEffect = ConstructTeamParticle( pWeaponInfo->m_szExplosionWaterEffect_Crit, iTeam, bDeathmatchOverride );
}
else if ( pWeaponInfo->m_szExplosionWaterEffect[0] )
{
pszEffect = pWeaponInfo->m_szExplosionWaterEffect;
}
}
else
{
if ( bIsPlayer || bInAir )
{
if ( bCrit && pWeaponInfo->m_szExplosionPlayerEffect_Crit[0] )
{
pszEffect = ConstructTeamParticle( pWeaponInfo->m_szExplosionPlayerEffect_Crit, iTeam, bDeathmatchOverride );
}
else if ( pWeaponInfo->m_szExplosionPlayerEffect[0] )
{
pszEffect = pWeaponInfo->m_szExplosionPlayerEffect;
}
}
else
{
if ( bCrit && pWeaponInfo->m_szExplosionEffect_Crit[0] )
{
pszEffect = ConstructTeamParticle( pWeaponInfo->m_szExplosionEffect_Crit, iTeam, bDeathmatchOverride );
}
else if ( pWeaponInfo->m_szExplosionEffect[0] )
{
pszEffect = pWeaponInfo->m_szExplosionEffect;
}
}
}
// Sound.
if ( pWeaponInfo->m_szExplosionSound[0] != '\0' )
{
pszSound = pWeaponInfo->m_szExplosionSound;
}
}
// Allow schema to override explosion sound.
if ( iItemID >= 0 )
{
CEconItemDefinition *pItemDef = GetItemSchema()->GetItemDefinition( iItemID );
if ( pItemDef && pItemDef->GetVisuals()->aWeaponSounds[SPECIAL1][0] != '\0' )
{
pszSound = pItemDef->GetVisuals()->aWeaponSounds[SPECIAL1];
}
}
CLocalPlayerFilter filter;
C_BaseEntity::EmitSound( filter, SOUND_FROM_WORLD, pszSound, &vecOrigin );
if ( bDeathmatchOverride )
{
DispatchParticleEffect( pszEffect, vecOrigin, angExplosion, pPlayer->m_vecPlayerColor, vec3_origin, true );
}
else
{
DispatchParticleEffect( pszEffect, vecOrigin, angExplosion );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFFreezePanel::FireGameEvent( IGameEvent * event )
{
const char *pEventName = event->GetName();
if ( Q_strcmp( "player_death", pEventName ) == 0 )
{
// see if the local player died
int iPlayerIndexVictim = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && iPlayerIndexVictim == pLocalPlayer->entindex() )
{
// the local player is dead, see if this is a new nemesis or a revenge
if ( event->GetInt( "dominated" ) > 0 )
{
m_iShowNemesisPanel = SHOW_NEW_NEMESIS;
}
else if ( event->GetInt( "revenge" ) > 0 )
{
m_iShowNemesisPanel = SHOW_REVENGE;
}
else
{
m_iShowNemesisPanel = SHOW_NO_NEMESIS;
}
}
}
else if ( Q_strcmp( "hide_freezepanel", pEventName ) == 0 )
{
Hide();
}
else if ( Q_strcmp( "freezecam_started", pEventName ) == 0 )
{
ShowCalloutsIn( 1.0 );
ShowSnapshotPanelIn( 1.25 );
}
else if ( Q_strcmp( "teamplay_win_panel", pEventName ) == 0 )
{
Hide();
}
else if ( Q_strcmp( "show_freezepanel", pEventName ) == 0 )
{
C_TF_PlayerResource *tf_PR = dynamic_cast<C_TF_PlayerResource *>(g_PR);
if ( !tf_PR )
{
m_pNemesisSubPanel->SetDialogVariable( "nemesisname", NULL );
return;
}
Show();
ShowSnapshotPanel( false );
m_bHoldingAfterScreenshot = false;
if ( m_iBasePanelOriginalX > -1 && m_iBasePanelOriginalY > -1 )
{
m_pBasePanel->SetPos( m_iBasePanelOriginalX, m_iBasePanelOriginalY );
}
// Get the entity who killed us
m_iKillerIndex = event->GetInt( "killer" );
C_BaseEntity *pKiller = ClientEntityList().GetBaseEntity( m_iKillerIndex );
int xp,yp;
GetPos( xp, yp );
if ( TFGameRules()->RoundHasBeenWon() )
{
SetPos( xp, m_iYBase - YRES(50) );
}
else
{
SetPos( xp, m_iYBase );
}
if ( pKiller )
{
CTFPlayer *pPlayer = ToTFPlayer ( pKiller );
int iMaxBuffedHealth = 0;
if ( pPlayer )
{
iMaxBuffedHealth = pPlayer->m_Shared.GetMaxBuffedHealth();
}
int iKillerHealth = pKiller->GetHealth();
if ( !pKiller->IsAlive() )
{
iKillerHealth = 0;
}
m_pKillerHealth->SetHealth( iKillerHealth, pKiller->GetMaxHealth(), iMaxBuffedHealth );
if ( pKiller->IsPlayer() )
{
C_TFPlayer *pVictim = C_TFPlayer::GetLocalTFPlayer();
CTFPlayer *pTFKiller = ToTFPlayer( pKiller );
//If this was just a regular kill but this guy is our nemesis then just show it.
if ( pVictim && pTFKiller && pTFKiller->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
{
if ( !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_Nemesis_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_Nemesis" );
}
}
else
{
if ( !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer" );
}
}
m_pBasePanel->SetDialogVariable( "killername", g_PR->GetPlayerName( m_iKillerIndex ) );
if ( m_pAvatar )
{
m_pAvatar->SetPlayer( (C_BasePlayer*)pKiller );
}
}
else if ( pKiller->IsBaseObject() )
{
C_BaseObject *pObj = assert_cast<C_BaseObject *>( pKiller );
C_TFPlayer *pOwner = pObj->GetOwner();
Assert( pOwner && "Why does this object not have an owner?" );
if ( pOwner )
{
m_iKillerIndex = pOwner->entindex();
m_pBasePanel->SetDialogVariable( "killername", g_PR->GetPlayerName( m_iKillerIndex ) );
if ( m_pAvatar )
{
m_pAvatar->SetPlayer( pOwner );
}
pKiller = pOwner;
}
if ( m_pFreezeLabel )
{
if ( pKiller && !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_KillerObject_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_KillerObject" );
}
}
const char *pszStatusName = pObj->GetStatusName();
wchar_t *wszLocalized = g_pVGuiLocalize->Find( pszStatusName );
if ( !wszLocalized )
{
m_pBasePanel->SetDialogVariable( "objectkiller", pszStatusName );
}
else
{
m_pBasePanel->SetDialogVariable( "objectkiller", wszLocalized );
}
}
else if ( m_pFreezeLabel )
{
if ( !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer" );
}
}
}
// see if we should show nemesis panel
const wchar_t *pchNemesisText = NULL;
switch ( m_iShowNemesisPanel )
{
case SHOW_NO_NEMESIS:
{
C_TFPlayer *pVictim = C_TFPlayer::GetLocalTFPlayer();
CTFPlayer *pTFKiller = ToTFPlayer( pKiller );
//If this was just a regular kill but this guy is our nemesis then just show it.
if ( pTFKiller && pTFKiller->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
{
pchNemesisText = g_pVGuiLocalize->Find( "#TF_FreezeNemesis" );
}
}
break;
case SHOW_NEW_NEMESIS:
{
C_TFPlayer *pVictim = C_TFPlayer::GetLocalTFPlayer();
CTFPlayer *pTFKiller = ToTFPlayer( pKiller );
// check to see if killer is still the nemesis of victim; victim may have managed to kill him after victim's
// death by grenade or some such, extracting revenge and clearing nemesis condition
if ( pTFKiller && pTFKiller->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
{
pchNemesisText = g_pVGuiLocalize->Find( "#TF_NewNemesis" );
}
}
break;
case SHOW_REVENGE:
pchNemesisText = g_pVGuiLocalize->Find( "#TF_GotRevenge" );
break;
default:
Assert( false ); // invalid value
break;
}
m_pNemesisSubPanel->SetDialogVariable( "nemesisname", pchNemesisText );
ShowNemesisPanel( NULL != pchNemesisText );
m_iShowNemesisPanel = SHOW_NO_NEMESIS;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleProperty::UpdateControlPoint( ParticleEffectList_t *pEffect, int iPoint, bool bInitializing )
{
ParticleControlPoint_t *pPoint = &pEffect->pControlPoints[iPoint];
if ( pEffect->pParticleEffect->m_pDef->IsScreenSpaceEffect() && iPoint == 0 )
{
pEffect->pParticleEffect->SetControlPointOrientation( pPoint->iControlPoint, Vector(1,0,0), Vector(0,1,0), Vector(0,0,1) );
pEffect->pParticleEffect->SetControlPoint( pPoint->iControlPoint, vec3_origin );
return;
}
if ( !pPoint->hEntity.Get() )
{
if ( pPoint->iAttachType == PATTACH_WORLDORIGIN && bInitializing )
{
pEffect->pParticleEffect->SetControlPointOrientation( pPoint->iControlPoint, Vector(1,0,0), Vector(0,1,0), Vector(0,0,1) );
pEffect->pParticleEffect->SetControlPoint( pPoint->iControlPoint, pPoint->vecOriginOffset );
pEffect->pParticleEffect->SetSortOrigin( pPoint->vecOriginOffset );
}
pEffect->pParticleEffect->SetControlPointEntity( pPoint->iControlPoint, NULL );
return;
}
// Only update non-follow particles when we're initializing,
if ( !bInitializing && (pPoint->iAttachType == PATTACH_ABSORIGIN || pPoint->iAttachType == PATTACH_POINT ) )
return;
if ( pPoint->iAttachType == PATTACH_CUSTOMORIGIN )
return;
Vector vecOrigin, vecForward, vecRight, vecUp;
switch ( pPoint->iAttachType )
{
case PATTACH_POINT:
case PATTACH_POINT_FOLLOW:
{
C_BaseAnimating *pAnimating = pPoint->hEntity->GetBaseAnimating();
bool bValid = false;
Assert( pAnimating );
if ( pAnimating )
{
matrix3x4_t attachmentToWorld;
if ( pAnimating->IsViewModel() )
{
C_BasePlayer *pPlayer = ToBasePlayer( ((C_BaseViewModel *)pAnimating)->GetOwner() );
ACTIVE_SPLITSCREEN_PLAYER_GUARD( C_BasePlayer::GetSplitScreenSlotForPlayer( pPlayer ) );
if ( pAnimating->GetAttachment( pPoint->iAttachmentPoint, attachmentToWorld ) )
{
bValid = true;
MatrixVectors( attachmentToWorld, &vecForward, &vecRight, &vecUp );
MatrixPosition( attachmentToWorld, vecOrigin );
if ( pEffect->pParticleEffect->m_pDef->IsViewModelEffect() )
{
FormatViewModelAttachment( pPlayer, vecOrigin, true );
}
}
}
else
{
// HACK_GETLOCALPLAYER_GUARD( "CParticleProperty::UpdateControlPoint" );
if ( pAnimating->GetAttachment( pPoint->iAttachmentPoint, attachmentToWorld ) )
{
bValid = true;
MatrixVectors( attachmentToWorld, &vecForward, &vecRight, &vecUp );
#ifdef _DEBUG
float flTests[3] = {vecForward.Dot( vecRight ), vecRight.Dot( vecUp ), vecUp.Dot( vecForward )};
static float s_flMaxTest = 0.001f;
Assert( fabs( flTests[0] ) + fabs( flTests[1] ) + fabs( flTests[2] ) < s_flMaxTest );
#endif
MatrixPosition( attachmentToWorld, vecOrigin );
if ( pEffect->pParticleEffect->m_pDef->IsViewModelEffect() )
{
HACK_GETLOCALPLAYER_GUARD( "CParticleProperty::UpdateControlPoint" );
FormatViewModelAttachment( NULL, vecOrigin, true );
}
}
}
}
if ( !bValid )
{
static bool bWarned = false;
if ( !bWarned )
{
bWarned = true;
DevWarning( "Attempted to attach particle effect %s to an unknown attachment on entity %s\n",
pEffect->pParticleEffect->m_pDef->GetName(), pAnimating->GetClassname() );
}
}
if ( !bValid )
{
AssertOnce( 0 );
return;
}
}
break;
case PATTACH_ABSORIGIN:
case PATTACH_ABSORIGIN_FOLLOW:
default:
{
vecOrigin = pPoint->hEntity->GetAbsOrigin() + pPoint->vecOriginOffset;
pPoint->hEntity->GetVectors( &vecForward, &vecRight, &vecUp );
}
break;
case PATTACH_EYES_FOLLOW:
{
C_BaseEntity *pEnt = pPoint->hEntity;
if ( !pEnt->IsPlayer() )
return;
C_BasePlayer *pPlayer = assert_cast< C_BasePlayer* >( pEnt );
bool bValid = false;
Assert( pPlayer );
if ( pPlayer )
{
bValid = true;
vecOrigin = pPlayer->EyePosition() + pPoint->vecOriginOffset;
pPlayer->EyeVectors( &vecForward, &vecRight, &vecUp );
}
if ( !bValid )
{
AssertOnce( 0 );
return;
}
}
break;
case PATTACH_CUSTOMORIGIN_FOLLOW:
{
matrix3x4_t mat;
MatrixMultiply( pPoint->hEntity->RenderableToWorldTransform(), pPoint->matOffset, mat );
MatrixVectors( mat, &vecForward, &vecRight, &vecUp );
vecOrigin = pPoint->hEntity->GetAbsOrigin() + pPoint->vecOriginOffset;
}
break;
}
pEffect->pParticleEffect->SetControlPointOrientation( pPoint->iControlPoint, vecForward, vecRight, vecUp );
pEffect->pParticleEffect->SetControlPointEntity( pPoint->iControlPoint, pPoint->hEntity );
pEffect->pParticleEffect->SetControlPoint( pPoint->iControlPoint, vecOrigin );
pEffect->pParticleEffect->SetSortOrigin( vecOrigin );
}