630 lines
19 KiB
C++
630 lines
19 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "c_func_passtime_goal.h"
|
|
#include "c_tf_passtime_logic.h"
|
|
#include "tf_hud_passtime_reticle.h"
|
|
#include "passtime_convars.h"
|
|
#include "tf_weapon_passtime_gun.h"
|
|
#include "c_tf_player.h"
|
|
#include "view.h"
|
|
#include "c_tf_playerresource.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
// The team colors from g_PR are wrong and I couldn't fix that fast enough.
|
|
// These colors were sampled from HUD art.
|
|
static Color GetTeamColor( int iTeam )
|
|
{
|
|
switch( iTeam )
|
|
{
|
|
case TF_TEAM_RED: return Color(0xFF, 0x51, 0x51);
|
|
case TF_TEAM_BLUE: return Color(0xA5, 0xDE, 0xFF);
|
|
default: return Color(0xF5, 0xE7, 0xDE);
|
|
};
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// C_PasstimeReticle
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
C_PasstimeReticle::~C_PasstimeReticle()
|
|
{
|
|
for( int i = 0; i < m_pSprites.Count(); ++i )
|
|
{
|
|
clienteffects->RemoveEffect( m_pSprites[i] );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::OnClientThink()
|
|
{
|
|
if ( !Update() )
|
|
{
|
|
SetAllAlphas( 0 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::AddSprite( CFXQuad *pQuad )
|
|
{
|
|
Assert( pQuad );
|
|
m_pSprites.AddToTail( pQuad );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::SetAllOrigins( const Vector &vec )
|
|
{
|
|
for ( int i = 0; i < m_pSprites.Count(); ++i )
|
|
{
|
|
m_pSprites[i]->m_FXData.SetOrigin( vec );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::SetAllNormals( const Vector &vec )
|
|
{
|
|
for ( int i = 0; i < m_pSprites.Count(); ++i )
|
|
{
|
|
m_pSprites[i]->m_FXData.SetNormal( vec );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::SetAllAlphas( byte iA )
|
|
{
|
|
auto flA = iA / 255.0f;
|
|
for ( int i = 0; i < m_pSprites.Count(); ++i )
|
|
{
|
|
m_pSprites[i]->m_FXData.SetAlpha( flA, flA );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::SetAllScales( float flScale )
|
|
{
|
|
for ( int i = 0; i < m_pSprites.Count(); ++i )
|
|
{
|
|
m_pSprites[i]->m_FXData.SetScale( flScale, flScale );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::SetOrigin( int i, const Vector &vec )
|
|
{
|
|
m_pSprites[i]->m_FXData.SetOrigin( vec );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::SetNormal( int i, const Vector &normal )
|
|
{
|
|
m_pSprites[i]->m_FXData.SetNormal( normal );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::SetAlpha( int i, byte iA )
|
|
{
|
|
auto flA = iA / 255.0f;
|
|
m_pSprites[i]->m_FXData.SetAlpha( flA, flA );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::SetRgba( int i, byte iR, byte iG, byte iB, byte iA )
|
|
{
|
|
m_pSprites[i]->m_FXData.SetColor( iR / 255.0f, iG / 255.0f, iB / 255.0f );
|
|
auto flA = iA / 255.0;
|
|
m_pSprites[i]->m_FXData.SetAlpha( flA, flA );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_PasstimeReticle::SetScale( int i, float flScale )
|
|
{
|
|
m_pSprites[i]->m_FXData.SetScale( flScale, flScale );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// C_PasstimeBallReticle
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static const float k_flBallReticleSize = 64;
|
|
C_PasstimeBallReticle::C_PasstimeBallReticle()
|
|
{
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_ball_reticle_piece_1", k_flBallReticleSize, 360 ) ); // the O
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_ball_reticle_piece_2", k_flBallReticleSize, 360 ) ); // the ><
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool C_PasstimeBallReticle::Update()
|
|
{
|
|
if ( !g_pPasstimeLogic || !g_pPasstimeLogic->GetBall() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto *pBall = g_pPasstimeLogic->GetBall();
|
|
auto *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
C_BaseEntity *pTarget = 0;
|
|
auto bHomingActive = false;
|
|
auto bHaveTarget = g_pPasstimeLogic->GetBallReticleTarget( &pTarget, &bHomingActive );
|
|
if ( !pBall || !pLocalPlayer || !bHaveTarget )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto vecTargetPos = pTarget->WorldSpaceCenter();
|
|
SetAllOrigins( vecTargetPos );
|
|
SetAllNormals( -MainViewForward() );
|
|
|
|
auto teamColor = GetTeamColor( pTarget->GetTeamNumber() );
|
|
auto iAlpha = ( bHomingActive || pLocalPlayer->m_Shared.IsTargetedForPasstimePass() )
|
|
? (int)( (fmodf( gpGlobals->curtime * 3.0f, 1.0f )) * 255 )
|
|
: 180;
|
|
|
|
SetRgba( 0, teamColor.r(), teamColor.g(), teamColor.b(), iAlpha );
|
|
SetRgba( 1, teamColor.r(), teamColor.g(), teamColor.b(), iAlpha );
|
|
|
|
auto flDist = (vecTargetPos - MainViewOrigin()).Length();
|
|
auto flScale = RemapValClamped( flDist, 768.0f, 4096.0f, 1.0f, 3.0f );
|
|
flScale *= k_flBallReticleSize;
|
|
if ( bHomingActive || pLocalPlayer->m_Shared.IsTargetedForPasstimePass() )
|
|
{
|
|
flScale *= 2;
|
|
}
|
|
SetScale( 0, flScale );
|
|
SetScale( 1, flScale );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// C_PasstimeGoalReticle
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
C_PasstimeGoalReticle::C_PasstimeGoalReticle( C_FuncPasstimeGoal *pGoal )
|
|
{
|
|
Assert( pGoal );
|
|
m_hGoal.Set( pGoal );
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_ball_reticle_piece_1", 256, 50 ) );
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_ball_reticle_piece_2", 128, 0 ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool C_PasstimeGoalReticle::Update()
|
|
{
|
|
if ( !g_pPasstimeLogic || !g_pPasstimeLogic->GetBall() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// don't show if ball isn't being carried by local player
|
|
auto *pEnt = g_pPasstimeLogic->GetBall()->GetCarrier();
|
|
if ( !pEnt || (pEnt != C_BasePlayer::GetLocalPlayer()) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto *pGoal = m_hGoal.Get();
|
|
if ( !g_pPasstimeLogic || !g_pPasstimeLogic->GetBall() || IsLocalPlayerSpectator()
|
|
|| !pGoal || pGoal->BGoalTriggerDisabled() || (pGoal->GetTeamNumber() != pEnt->GetTeamNumber()) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto teamColor = GetTeamColor( pEnt->GetTeamNumber() );
|
|
|
|
auto vec = pGoal->WorldSpaceCenter();
|
|
auto facingFrac = MainViewForward().Dot( (vec - MainViewOrigin()).Normalized() );
|
|
if ( facingFrac < 0.6 )
|
|
{
|
|
return false;
|
|
}
|
|
facingFrac = RemapValClamped( facingFrac, 0.8f, 1.0f, 1.0f, 0.3f );
|
|
|
|
// ring
|
|
SetOrigin( 0, vec );
|
|
auto flPulseSpeed = 10.0f;
|
|
auto flPulseFrac = Clamp( FastCos( gpGlobals->curtime * flPulseSpeed ), 0.0f, 1.0f );
|
|
SetRgba( 0, teamColor.r(), teamColor.g(), teamColor.b(), flPulseFrac * (120 * facingFrac) );
|
|
|
|
// arrow
|
|
float tmp;
|
|
flPulseFrac = 1.0f - modff( gpGlobals->curtime, &tmp );
|
|
SetOrigin( 1, vec + Vector(0, 0, flPulseFrac * 64) );
|
|
SetAllNormals( -MainViewForward() );
|
|
SetRgba( 1, teamColor.r(), teamColor.g(), teamColor.b(), flPulseFrac * (255 * facingFrac) );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// C_PasstimePassReticle
|
|
//-----------------------------------------------------------------------------
|
|
|
|
const float kPassReticleScale = 64;
|
|
//-----------------------------------------------------------------------------
|
|
C_PasstimePassReticle::C_PasstimePassReticle()
|
|
{
|
|
m_flTargetScore = FLT_MAX;
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_ball_reticle_passlock", kPassReticleScale, 100 ) ); // the *
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_ball_reticle_piece_1", kPassReticleScale, 0 ) ); // the O
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_ball_reticle_piece_2", kPassReticleScale, 0 ) ); // the ><
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool C_PasstimePassReticle::Update()
|
|
{
|
|
if ( !g_pPasstimeLogic || !g_pPasstimeLogic->GetBall() || IsLocalPlayerSpectator() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto *pBallCarrier = g_pPasstimeLogic->GetBall()->GetCarrier();
|
|
if ( !pBallCarrier )
|
|
{
|
|
return false;
|
|
}
|
|
if ( (pBallCarrier != C_BasePlayer::GetLocalPlayer()) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
SetAllNormals( -MainViewForward() );
|
|
|
|
// the player's actual pass target always takes precedence, but if it's
|
|
// not set, try to find a candidate and display a hint for that
|
|
auto *pPassTarget = pBallCarrier->m_Shared.GetPasstimePassTarget();
|
|
if ( pPassTarget )
|
|
{
|
|
m_hTarget = pPassTarget;
|
|
auto vecTargetPos = pPassTarget->WorldSpaceCenter();
|
|
SetAllOrigins( vecTargetPos );
|
|
|
|
auto teamColor = GetTeamColor( pBallCarrier->GetTeamNumber() );
|
|
auto neutralColor = GetTeamColor( TEAM_UNASSIGNED );
|
|
auto iAlpha = (int)( (fmodf( gpGlobals->curtime * 3.0f, 1.0f )) * 255 );
|
|
SetRgba( 0, teamColor.r(), teamColor.g(), teamColor.b(), iAlpha );
|
|
SetRgba( 1, neutralColor.r(), neutralColor.g(), neutralColor.b(), 255 );
|
|
SetRgba( 2, teamColor.r(), teamColor.g(), teamColor.b(), iAlpha );
|
|
|
|
auto flDist = (vecTargetPos - MainViewOrigin()).Length();
|
|
auto flScale = RemapValClamped( flDist, 768.0f, 8192.0f, 1.0f, 8.0f );
|
|
SetAllScales( flScale * kPassReticleScale * 2 );
|
|
}
|
|
else
|
|
{
|
|
FindPassHintTarget( pBallCarrier );
|
|
if ( !m_hTarget )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto flPulseSpeed = 20;
|
|
auto flPulseFrac = Clamp( FastCos( gpGlobals->curtime * flPulseSpeed ), 0.3f, 1.0f );
|
|
auto iAlpha = 200 * flPulseFrac * Clamp( m_flTargetScore + 0.5f, 0.0f, 1.0f ); // higher flScore is better
|
|
|
|
auto teamColor = GetTeamColor( TEAM_UNASSIGNED );
|
|
auto neutralColor = GetTeamColor( TEAM_UNASSIGNED );
|
|
SetRgba( 0, teamColor.r(), teamColor.g(), teamColor.b(), iAlpha );
|
|
SetRgba( 1, neutralColor.r(), neutralColor.g(), neutralColor.b(), 80 );
|
|
SetRgba( 2, teamColor.r(), teamColor.g(), teamColor.b(), iAlpha );
|
|
|
|
auto vecTargetPos = m_hTarget->WorldSpaceCenter();
|
|
SetAllOrigins( vecTargetPos );
|
|
|
|
auto flDist = (vecTargetPos - MainViewOrigin()).Length();
|
|
auto flScale = RemapValClamped( flDist, 768.0f, 8192.0f, 1.0f, 8.0f );
|
|
SetAllScales( flScale * kPassReticleScale );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
extern int HudTransform( const Vector &point, Vector &screen );
|
|
void C_PasstimePassReticle::FindPassHintTarget( C_TFPlayer *pLocalPlayer )
|
|
{
|
|
m_hTarget = 0;
|
|
m_flTargetScore = -FLT_MAX;
|
|
|
|
auto flFovDeg = 70;
|
|
auto flDotFov = cosf( DEG2RAD( flFovDeg / 2.0f ) );
|
|
auto vecViewPos = MainViewOrigin();
|
|
auto vecViewFwd = MainViewForward();
|
|
|
|
auto flMaxPassDist = g_pPasstimeLogic->GetMaxPassRange() - 400; // arbitrary, based on TF_MAX_SPEED
|
|
|
|
// for each player in front of the local player,
|
|
for( int i = 1; i <= MAX_PLAYERS; i++ )
|
|
{
|
|
auto *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
|
|
if ( !C_PasstimeGun::BValidPassTarget( pLocalPlayer, pPlayer ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
auto vecTargetPos = pPlayer->EyePosition();
|
|
auto vecToTarget = vecTargetPos - vecViewPos;
|
|
if ( vecToTarget.NormalizeInPlace() > flMaxPassDist )
|
|
{
|
|
// the server may disagree on this, so the client is less permissive
|
|
// when it guesses in order to prevent false positives
|
|
continue; // too far away, probably
|
|
}
|
|
|
|
auto fDotTarget = vecToTarget.Dot( vecViewFwd );
|
|
if ( fDotTarget <= flDotFov )
|
|
{
|
|
continue; // not in front
|
|
}
|
|
|
|
// determine player's distance from center of screen
|
|
Vector vecScreenPos;
|
|
auto bBehindViewplane = HudTransform( vecTargetPos, vecScreenPos );
|
|
if ( bBehindViewplane )
|
|
{
|
|
continue; // paranoia
|
|
}
|
|
auto flScore = 0.5f - vecScreenPos.Length2D();
|
|
if ( flScore <= m_flTargetScore )
|
|
{
|
|
continue; // someone else already found that's closer
|
|
}
|
|
|
|
// trace to see if they are visible
|
|
// this is the same trace the gun does
|
|
trace_t tr;
|
|
CTraceFilterSimple tracefilter( pLocalPlayer, COLLISION_GROUP_PROJECTILE );
|
|
UTIL_TraceLine( vecViewPos, vecTargetPos, MASK_PLAYERSOLID, &tracefilter, &tr );
|
|
if ( tr.m_pEnt != pPlayer )
|
|
{
|
|
continue; // not visible
|
|
}
|
|
|
|
m_flTargetScore = flScore;
|
|
m_hTarget = pPlayer;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// C_PasstimeBounceReticle
|
|
//-----------------------------------------------------------------------------
|
|
C_PasstimeBounceReticle::C_PasstimeBounceReticle()
|
|
{
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_ball_reticle_passlock", 160, 0 ) ); // the *
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_ball_reticle_piece_1", 80, 200 ) ); // the O
|
|
}
|
|
|
|
void C_PasstimeBounceReticle::Show( const Vector &vec, const Vector &normal )
|
|
{
|
|
SetOrigin( 0, vec );
|
|
SetOrigin( 1, vec );//+ (normal * 16) );
|
|
SetNormal( 0, normal );
|
|
SetNormal( 1, -MainViewForward() );
|
|
SetRgba( 0, 255, 255, 0, 200 );
|
|
SetRgba( 1, 255, 255, 0, 200 );
|
|
}
|
|
|
|
void C_PasstimeBounceReticle::Hide()
|
|
{
|
|
SetAllAlphas( 0 );
|
|
}
|
|
|
|
bool C_PasstimeBounceReticle::Update()
|
|
{
|
|
return !IsLocalPlayerSpectator();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// C_PasstimePlayerReticle
|
|
//-----------------------------------------------------------------------------
|
|
C_PasstimePlayerReticle::C_PasstimePlayerReticle( C_TFPlayer *pPlayer )
|
|
{
|
|
m_hPlayer.Set( pPlayer );
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_teamicon_red", 128, 0 ) );
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_teamicon_blue", 128, 0 ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool C_PasstimePlayerReticle::Update()
|
|
{
|
|
if ( !g_pPasstimeLogic )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
auto *pPlayer = m_hPlayer.Get();
|
|
if ( !pLocalPlayer || pLocalPlayer->IsPlayerDead()
|
|
|| !pPlayer || pPlayer->IsPlayerDead() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( pPlayer->m_Shared.GetPercentInvisible() > 0 )
|
|
{
|
|
// dont' show because player is invisible, friend or foe
|
|
return false;
|
|
}
|
|
|
|
auto iFriendsDetail = tf_passtime_player_reticles_friends.GetInt();
|
|
auto iEnemiesDetail = tf_passtime_player_reticles_enemies.GetInt();
|
|
|
|
auto bIsDisguisedEnemy = pPlayer->m_Shared.InCond( TF_COND_DISGUISED )
|
|
&& ( pPlayer->m_Shared.GetDisguiseTeam() == pLocalPlayer->GetTeamNumber() )
|
|
&& !pPlayer->m_Shared.IsFullyInvisible();
|
|
|
|
auto bIsFriend = pLocalPlayer->InSameTeam( pPlayer ) || bIsDisguisedEnemy;
|
|
|
|
if ( (bIsFriend && (iFriendsDetail <= 0))
|
|
|| (!bIsFriend && (iEnemiesDetail <= 0)) )
|
|
{
|
|
// don't show because disabled
|
|
return false;
|
|
}
|
|
|
|
if ( !pLocalPlayer->m_Shared.HasPasstimeBall()
|
|
&& ((bIsFriend && (iFriendsDetail == 1))
|
|
|| (!bIsFriend && (iEnemiesDetail == 1))))
|
|
{
|
|
// don't show because not visible unless have ball
|
|
return false;
|
|
}
|
|
|
|
if ( pPlayer->IsDormant() )
|
|
{
|
|
// don't show because not getting updated from server for some reason
|
|
// probably not in PVS
|
|
return false;
|
|
}
|
|
|
|
auto nTeamNumber = pPlayer->GetTeamNumber();
|
|
if ( !pLocalPlayer->InSameTeam( pPlayer ) && bIsFriend ) // they're not on my team but they're showing as a friend, they must be a spy so use my team color
|
|
{
|
|
nTeamNumber = pLocalPlayer->GetTeamNumber();
|
|
}
|
|
|
|
int iShowSprite, iHideSprite;
|
|
if ( nTeamNumber == TF_TEAM_RED )
|
|
{
|
|
iShowSprite = 0;
|
|
iHideSprite = 1;
|
|
}
|
|
else if ( nTeamNumber == TF_TEAM_BLUE )
|
|
{
|
|
iShowSprite = 1;
|
|
iHideSprite = 0;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto vecTarget = pPlayer->EyePosition();
|
|
int iX, iY;
|
|
auto bOnScreen = GetVectorInHudSpace( vecTarget, iX, iY );
|
|
if ( !bOnScreen )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
trace_t tr;
|
|
CTraceFilterIgnorePlayers tracefilter( pLocalPlayer, COLLISION_GROUP_PROJECTILE );
|
|
UTIL_TraceLine( MainViewOrigin(), vecTarget, MASK_PLAYERSOLID, &tracefilter, &tr );
|
|
if ( tr.fraction == 1 )
|
|
{
|
|
// made it all the way, the guy is visible so hide the icon
|
|
return false;
|
|
}
|
|
|
|
auto flDist = (vecTarget - MainViewOrigin()).Length();
|
|
auto flScale = RemapValClamped( flDist, 1024.0f, 4096.0f, 80, 128 );
|
|
|
|
SetAlpha( iHideSprite, 0 );
|
|
SetAlpha( iShowSprite, 100 );
|
|
SetAllScales( flScale );
|
|
SetAllOrigins( vecTarget );
|
|
SetAllNormals( -MainViewForward() );
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// C_PasstimeAskForBallReticle
|
|
//-----------------------------------------------------------------------------
|
|
C_PasstimeAskForBallReticle::C_PasstimeAskForBallReticle( C_TFPlayer *pPlayer )
|
|
{
|
|
m_hPlayer.Set( pPlayer );
|
|
AddSprite( CreateReticleSprite( "passtime/hud/passtime_pass_to_me_prompt", 128, 0 ) );
|
|
SetRgba( 0, 255, 255, 255, 200 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool C_PasstimeAskForBallReticle::Update()
|
|
{
|
|
if ( !g_pPasstimeLogic )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
auto *pPlayer = m_hPlayer.Get();
|
|
|
|
if ( !pLocalPlayer || !pPlayer )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto bLocalPlayerObserver = pLocalPlayer->IsObserver();
|
|
if ( !bLocalPlayerObserver && pLocalPlayer->IsPlayerDead() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( (pPlayer->m_Shared.AskForBallTime() < gpGlobals->curtime) || pPlayer->IsPlayerDead() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( !bLocalPlayerObserver && !pLocalPlayer->m_Shared.HasPasstimeBall() && !pPlayer->InSameTeam( pLocalPlayer ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto vecTarget = pPlayer->EyePosition();
|
|
vecTarget.z += 16;
|
|
int iX, iY;
|
|
auto bOnScreen = GetVectorInHudSpace( vecTarget, iX, iY );
|
|
if ( !bOnScreen )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto flDist = (vecTarget - MainViewOrigin()).Length();
|
|
auto flScale = RemapValClamped( flDist, 1024.0f, 4096.0f, 40, 200 );
|
|
SetAllScales( flScale );
|
|
SetAllOrigins( vecTarget );
|
|
SetAllNormals( -MainViewForward() );
|
|
SetRgba( 0, 255, 255, 255, (((int)(gpGlobals->curtime * 10)) & 1 ? 200 : 0) );
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Functions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
CFXQuad *CreateReticleSprite( const char *pModelName, float flScale, float flSpinSpeed )
|
|
{
|
|
FXQuadData_t q;
|
|
memset(&q, 0, sizeof(q));
|
|
q.m_Color.Init(1,1,1);
|
|
q.m_flDeltaYaw = flSpinSpeed;
|
|
q.m_flDieTime = FLT_MAX;
|
|
q.m_flEndAlpha = 1;
|
|
q.m_flEndScale = flScale;
|
|
q.m_flLifeTime = 0;
|
|
q.m_flScaleBias = 0;
|
|
q.m_flStartAlpha = 1;
|
|
q.m_flStartScale = flScale;
|
|
q.m_flYaw = 180;
|
|
q.SetMaterial( pModelName );
|
|
q.m_uiFlags = 0;
|
|
q.m_vecNormal.Init(1,0,0);
|
|
q.m_vecOrigin.Init(0,0,0);
|
|
CFXQuad *pQuad = new CFXQuad(q);
|
|
clienteffects->AddEffect( pQuad );
|
|
return pQuad;
|
|
}
|