1340 lines
30 KiB
C++
1340 lines
30 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: MapOverview.cpp: implementation of the CMapOverview class.
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "mapoverview.h"
|
|
#include <vgui/ISurface.h>
|
|
#include <vgui/ILocalize.h>
|
|
#include <filesystem.h>
|
|
#include <KeyValues.h>
|
|
#include <convar.h>
|
|
#include "mathlib/mathlib.h"
|
|
#include <game/client/iviewport.h>
|
|
#include <igameresources.h>
|
|
#include "gamevars_shared.h"
|
|
#include "spectatorgui.h"
|
|
#include "c_playerresource.h"
|
|
#include "view.h"
|
|
|
|
#include "clientmode.h"
|
|
#include <vgui_controls/AnimationController.h>
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
ConVar overview_health( "overview_health", "1", FCVAR_ARCHIVE | FCVAR_CLIENTCMD_CAN_EXECUTE, "Show player's health in map overview.\n" );
|
|
ConVar overview_names ( "overview_names", "1", FCVAR_ARCHIVE | FCVAR_CLIENTCMD_CAN_EXECUTE, "Show player's names in map overview.\n" );
|
|
ConVar overview_tracks( "overview_tracks", "1", FCVAR_ARCHIVE | FCVAR_CLIENTCMD_CAN_EXECUTE, "Show player's tracks in map overview.\n" );
|
|
ConVar overview_locked( "overview_locked", "1", FCVAR_ARCHIVE | FCVAR_CLIENTCMD_CAN_EXECUTE, "Locks map angle, doesn't follow view angle.\n" );
|
|
ConVar overview_alpha( "overview_alpha", "1.0", FCVAR_ARCHIVE | FCVAR_CLIENTCMD_CAN_EXECUTE, "Overview map translucency.\n" );
|
|
|
|
IMapOverviewPanel *g_pMapOverview = NULL; // we assume only one overview is created
|
|
|
|
static int AdjustValue( int curValue, int targetValue, int amount )
|
|
{
|
|
if ( curValue > targetValue )
|
|
{
|
|
curValue -= amount;
|
|
|
|
if ( curValue < targetValue )
|
|
curValue = targetValue;
|
|
}
|
|
else if ( curValue < targetValue )
|
|
{
|
|
curValue += amount;
|
|
|
|
if ( curValue > targetValue )
|
|
curValue = targetValue;
|
|
}
|
|
|
|
return curValue;
|
|
}
|
|
|
|
CON_COMMAND( overview_zoom, "Sets overview map zoom: <zoom> [<time>] [rel]" )
|
|
{
|
|
if ( !g_pMapOverview || args.ArgC() < 2 )
|
|
return;
|
|
|
|
float zoom = Q_atof( args[ 1 ] );
|
|
|
|
float time = 0;
|
|
|
|
if ( args.ArgC() >= 3 )
|
|
time = Q_atof( args[ 2 ] );
|
|
|
|
if ( args.ArgC() == 4 )
|
|
zoom *= g_pMapOverview->GetZoom();
|
|
|
|
// We are going to store their zoom pick as the resultant overview size that it sees. This way, the value will remain
|
|
// correct even on a different map that has a different intrinsic zoom.
|
|
float desiredViewSize = 0.0f;
|
|
desiredViewSize = (zoom * OVERVIEW_MAP_SIZE * g_pMapOverview->GetFullZoom()) / g_pMapOverview->GetMapScale();
|
|
g_pMapOverview->SetPlayerPreferredViewSize( desiredViewSize );
|
|
|
|
if( !g_pMapOverview->AllowConCommandsWhileAlive() )
|
|
{
|
|
C_BasePlayer *localPlayer = CBasePlayer::GetLocalPlayer();
|
|
if( localPlayer && CBasePlayer::GetLocalPlayer()->IsAlive() )
|
|
return;// Not allowed to execute commands while alive
|
|
else if( localPlayer && localPlayer->GetObserverMode() == OBS_MODE_DEATHCAM )
|
|
return;// In the death cam spiral counts as alive
|
|
}
|
|
|
|
g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( g_pMapOverview->GetAsPanel(), "zoom", zoom, 0.0, time, vgui::AnimationController::INTERPOLATOR_LINEAR );
|
|
}
|
|
|
|
CON_COMMAND( overview_mode, "Sets overview map mode off,small,large: <0|1|2>" )
|
|
{
|
|
if ( !g_pMapOverview )
|
|
return;
|
|
|
|
int mode;
|
|
|
|
if ( args.ArgC() < 2 )
|
|
{
|
|
// toggle modes
|
|
mode = g_pMapOverview->GetMode() + 1;
|
|
|
|
if ( mode > CMapOverview::MAP_MODE_FULL )
|
|
mode = CMapOverview::MAP_MODE_OFF;
|
|
}
|
|
else
|
|
{
|
|
// set specific mode
|
|
mode = Q_atoi( args[ 1 ] );
|
|
}
|
|
|
|
if( mode != CMapOverview::MAP_MODE_RADAR )
|
|
g_pMapOverview->SetPlayerPreferredMode( mode );
|
|
|
|
if( !g_pMapOverview->AllowConCommandsWhileAlive() )
|
|
{
|
|
C_BasePlayer *localPlayer = CBasePlayer::GetLocalPlayer();
|
|
if( localPlayer && CBasePlayer::GetLocalPlayer()->IsAlive() )
|
|
return;// Not allowed to execute commands while alive
|
|
else if( localPlayer && localPlayer->GetObserverMode() == OBS_MODE_DEATHCAM )
|
|
return;// In the death cam spiral counts as alive
|
|
}
|
|
|
|
g_pMapOverview->SetMode( mode );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
using namespace vgui;
|
|
|
|
CMapOverview::CMapOverview( const char *pElementName ) : BaseClass( NULL, pElementName ), CHudElement( pElementName )
|
|
{
|
|
SetParent( g_pClientMode->GetViewport()->GetVPanel() );
|
|
|
|
SetBounds( 0,0, 256, 256 );
|
|
SetBgColor( Color( 0,0,0,100 ) );
|
|
SetPaintBackgroundEnabled( true );
|
|
ShowPanel( false );
|
|
|
|
// Make sure we actually have the font...
|
|
vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
|
|
|
|
m_hIconFont = pScheme->GetFont( "DefaultSmall" );
|
|
|
|
m_nMapTextureID = -1;
|
|
m_MapKeyValues = NULL;
|
|
|
|
m_MapOrigin = Vector( 0, 0, 0 );
|
|
m_fMapScale = 1.0f;
|
|
m_bFollowAngle = false;
|
|
SetMode( MAP_MODE_OFF );
|
|
|
|
m_fZoom = 3.0f;
|
|
m_MapCenter = Vector2D( 512, 512 );
|
|
m_ViewOrigin = Vector2D( 512, 512 );
|
|
m_fViewAngle = 0;
|
|
m_fTrailUpdateInterval = 1.0f;
|
|
|
|
m_bShowNames = true;
|
|
m_bShowHealth = true;
|
|
m_bShowTrails = true;
|
|
|
|
m_flChangeSpeed = 1000;
|
|
m_flIconSize = 64.0f;
|
|
|
|
m_ObjectCounterID = 1;
|
|
|
|
Reset();
|
|
|
|
Q_memset( m_Players, 0, sizeof(m_Players) );
|
|
|
|
InitTeamColorsAndIcons();
|
|
|
|
g_pMapOverview = this; // for cvars access etc
|
|
}
|
|
|
|
void CMapOverview::Init( void )
|
|
{
|
|
// register for events as client listener
|
|
ListenForGameEvent( "game_newmap" );
|
|
ListenForGameEvent( "round_start" );
|
|
ListenForGameEvent( "player_connect_client" );
|
|
ListenForGameEvent( "player_info" );
|
|
ListenForGameEvent( "player_team" );
|
|
ListenForGameEvent( "player_spawn" );
|
|
ListenForGameEvent( "player_death" );
|
|
ListenForGameEvent( "player_disconnect" );
|
|
}
|
|
|
|
void CMapOverview::InitTeamColorsAndIcons()
|
|
{
|
|
Q_memset( m_TeamIcons, 0, sizeof(m_TeamIcons) );
|
|
Q_memset( m_TeamColors, 0, sizeof(m_TeamColors) );
|
|
Q_memset( m_ObjectIcons, 0, sizeof(m_ObjectIcons) );
|
|
|
|
m_TextureIDs.RemoveAll();
|
|
}
|
|
|
|
int CMapOverview::AddIconTexture(const char *filename)
|
|
{
|
|
int index = m_TextureIDs.Find( filename );
|
|
|
|
if ( m_TextureIDs.IsValidIndex( index ) )
|
|
{
|
|
// already known, return texture ID
|
|
return m_TextureIDs.Element(index);
|
|
}
|
|
|
|
index = surface()->CreateNewTextureID();
|
|
surface()->DrawSetTextureFile( index , filename, true, false);
|
|
|
|
m_TextureIDs.Insert( filename, index );
|
|
|
|
return index;
|
|
}
|
|
|
|
void CMapOverview::ApplySchemeSettings(vgui::IScheme *scheme)
|
|
{
|
|
BaseClass::ApplySchemeSettings( scheme );
|
|
|
|
SetBgColor( Color( 0,0,0,100 ) );
|
|
SetPaintBackgroundEnabled( true );
|
|
}
|
|
|
|
CMapOverview::~CMapOverview()
|
|
{
|
|
if ( m_MapKeyValues )
|
|
m_MapKeyValues->deleteThis();
|
|
|
|
g_pMapOverview = NULL;
|
|
|
|
//TODO release Textures ? clear lists
|
|
}
|
|
|
|
void CMapOverview::UpdatePlayers()
|
|
{
|
|
if ( !g_PR )
|
|
return;
|
|
|
|
// first disable all players health
|
|
for ( int i=0; i<MAX_PLAYERS; i++ )
|
|
{
|
|
m_Players[i].health = 0;
|
|
m_Players[i].team = TEAM_SPECTATOR;
|
|
}
|
|
|
|
for ( int i = 1; i<= gpGlobals->maxClients; i++)
|
|
{
|
|
// update from global player resources
|
|
if ( g_PR && g_PR->IsConnected(i) )
|
|
{
|
|
MapPlayer_t *player = &m_Players[i-1];
|
|
|
|
player->health = g_PR->GetHealth( i );
|
|
|
|
if ( !g_PR->IsAlive( i ) )
|
|
{
|
|
player->health = 0;
|
|
}
|
|
|
|
if ( player->team != g_PR->GetTeam( i ) )
|
|
{
|
|
player->team = g_PR->GetTeam( i );
|
|
player->icon = m_TeamIcons[ GetIconNumberFromTeamNumber(player->team) ];
|
|
player->color = m_TeamColors[ GetIconNumberFromTeamNumber(player->team) ];
|
|
}
|
|
}
|
|
|
|
C_BasePlayer *pPlayer = UTIL_PlayerByIndex( i );
|
|
|
|
if ( !pPlayer )
|
|
continue;
|
|
|
|
// don't update if player is dormant
|
|
if ( pPlayer->IsDormant() )
|
|
continue;
|
|
|
|
// update position of active players in our PVS
|
|
Vector position = pPlayer->EyePosition();
|
|
QAngle angles = pPlayer->EyeAngles();
|
|
|
|
SetPlayerPositions( i-1, position, angles );
|
|
}
|
|
}
|
|
|
|
void CMapOverview::UpdatePlayerTrails()
|
|
{
|
|
if ( m_fNextTrailUpdate > m_fWorldTime )
|
|
return;
|
|
|
|
m_fNextTrailUpdate = m_fWorldTime + 1.0f; // update once a second
|
|
|
|
for (int i=0; i<MAX_PLAYERS; i++)
|
|
{
|
|
MapPlayer_t *p = &m_Players[i];
|
|
|
|
// no trails for spectators or dead players
|
|
if ( (p->team <= TEAM_SPECTATOR) || (p->health <= 0) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// move old trail points
|
|
for ( int j=MAX_TRAIL_LENGTH-1; j>0; j--)
|
|
{
|
|
p->trail[j]=p->trail[j-1];
|
|
}
|
|
|
|
p->trail[0] = WorldToMap ( p->position );
|
|
}
|
|
}
|
|
|
|
void CMapOverview::UpdateFollowEntity()
|
|
{
|
|
if ( m_nFollowEntity != 0 )
|
|
{
|
|
C_BaseEntity *ent = ClientEntityList().GetEnt( m_nFollowEntity );
|
|
|
|
if ( ent )
|
|
{
|
|
Vector position = MainViewOrigin(); // Use MainViewOrigin so SourceTV works in 3rd person
|
|
QAngle angle = ent->EyeAngles();
|
|
|
|
if ( m_nFollowEntity <= MAX_PLAYERS )
|
|
{
|
|
SetPlayerPositions( m_nFollowEntity-1, position, angle );
|
|
}
|
|
|
|
SetCenter( WorldToMap(position) );
|
|
SetAngle( angle[YAW] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetCenter( Vector2D(OVERVIEW_MAP_SIZE/2,OVERVIEW_MAP_SIZE/2) );
|
|
SetAngle( 0 );
|
|
}
|
|
}
|
|
|
|
void CMapOverview::Paint()
|
|
{
|
|
UpdateSizeAndPosition();
|
|
|
|
UpdateFollowEntity();
|
|
|
|
UpdateObjects();
|
|
|
|
UpdatePlayers();
|
|
|
|
UpdatePlayerTrails();
|
|
|
|
DrawMapTexture();
|
|
|
|
DrawMapPlayerTrails();
|
|
|
|
DrawObjects();
|
|
|
|
DrawMapPlayers();
|
|
|
|
DrawCamera();
|
|
|
|
BaseClass::Paint();
|
|
}
|
|
|
|
bool CMapOverview::CanPlayerBeSeen(MapPlayer_t *player)
|
|
{
|
|
C_BasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
|
|
|
|
if ( !localPlayer || !player )
|
|
return false;
|
|
|
|
// don't draw ourself
|
|
if ( localPlayer->GetUserID() == (player->userid) )
|
|
return false;
|
|
|
|
// Invalid guy.
|
|
if( player->position == Vector(0,0,0) )
|
|
return false;
|
|
|
|
// if local player is on spectator team, he can see everyone
|
|
if ( localPlayer->GetTeamNumber() <= TEAM_SPECTATOR )
|
|
return true;
|
|
|
|
// we never track unassigned or real spectators
|
|
if ( player->team <= TEAM_SPECTATOR )
|
|
return false;
|
|
|
|
// if observer is an active player, check mp_forcecamera:
|
|
|
|
if ( mp_forcecamera.GetInt() == OBS_ALLOW_NONE )
|
|
return false;
|
|
|
|
if ( mp_forcecamera.GetInt() == OBS_ALLOW_TEAM )
|
|
{
|
|
// true if both players are on the same team
|
|
return (localPlayer->GetTeamNumber() == player->team );
|
|
}
|
|
|
|
// by default we can see all players
|
|
return true;
|
|
}
|
|
|
|
/// allows mods to restrict health
|
|
/// Note: index is 0-based
|
|
bool CMapOverview::CanPlayerHealthBeSeen(MapPlayer_t *player)
|
|
{
|
|
C_BasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
|
|
|
|
if ( !localPlayer )
|
|
return false;
|
|
|
|
// real spectators can see everything
|
|
if ( localPlayer->GetTeamNumber() <= TEAM_SPECTATOR )
|
|
return true;
|
|
|
|
if ( mp_forcecamera.GetInt() != OBS_ALLOW_ALL )
|
|
{
|
|
// if forcecamera is on, only show health for teammates
|
|
return ( localPlayer->GetTeamNumber() == player->team );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// usually name rule is same as health rule
|
|
bool CMapOverview::CanPlayerNameBeSeen(MapPlayer_t *player)
|
|
{
|
|
return CanPlayerHealthBeSeen( player );
|
|
}
|
|
|
|
void CMapOverview::SetPlayerPositions(int index, const Vector &position, const QAngle &angle)
|
|
{
|
|
MapPlayer_t *p = &m_Players[index];
|
|
|
|
p->angle = angle;
|
|
p->position = position;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: shows/hides the buy menu
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverview::ShowPanel(bool bShow)
|
|
{
|
|
SetVisible( bShow );
|
|
}
|
|
|
|
void CMapOverview::OnThink( void )
|
|
{
|
|
if ( NeedsUpdate() )
|
|
{
|
|
Update();
|
|
m_fNextUpdateTime = gpGlobals->curtime + 0.2f; // update 5 times a second
|
|
}
|
|
}
|
|
|
|
bool CMapOverview::NeedsUpdate( void )
|
|
{
|
|
return m_fNextUpdateTime < gpGlobals->curtime;
|
|
}
|
|
|
|
void CMapOverview::Update( void )
|
|
{
|
|
// update settings
|
|
m_bShowNames = overview_names.GetBool() && ( GetMode() != MAP_MODE_RADAR );
|
|
m_bShowHealth = overview_health.GetBool() && ( GetMode() != MAP_MODE_RADAR );
|
|
m_bFollowAngle = ( GetMode() != MAP_MODE_RADAR && !overview_locked.GetBool() ) || ( GetMode() == MAP_MODE_RADAR && !IsRadarLocked() );
|
|
m_fTrailUpdateInterval = overview_tracks.GetInt() && ( GetMode() != MAP_MODE_RADAR );
|
|
|
|
m_fWorldTime = gpGlobals->curtime;
|
|
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
int specmode = GetSpectatorMode();
|
|
|
|
if ( specmode == OBS_MODE_IN_EYE || specmode == OBS_MODE_CHASE )
|
|
{
|
|
// follow target
|
|
SetFollowEntity( GetSpectatorTarget() );
|
|
}
|
|
else
|
|
{
|
|
// follow ourself otherwise
|
|
SetFollowEntity( pPlayer->entindex() );
|
|
}
|
|
}
|
|
|
|
void CMapOverview::Reset( void )
|
|
{
|
|
m_fNextUpdateTime = 0;
|
|
}
|
|
|
|
void CMapOverview::SetData(KeyValues *data)
|
|
{
|
|
m_fZoom = data->GetFloat( "zoom", m_fZoom );
|
|
m_nFollowEntity = data->GetInt( "entity", m_nFollowEntity );
|
|
}
|
|
|
|
|
|
CMapOverview::MapPlayer_t* CMapOverview::GetPlayerByUserID( int userID )
|
|
{
|
|
for (int i=0; i<MAX_PLAYERS; i++)
|
|
{
|
|
MapPlayer_t *player = &m_Players[i];
|
|
|
|
if ( player->userid == userID )
|
|
return player;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool CMapOverview::IsInPanel(Vector2D &pos)
|
|
{
|
|
int x,y,w,t;
|
|
|
|
GetBounds( x,y,w,t );
|
|
|
|
return ( pos.x >= 0 && pos.x < w && pos.y >= 0 && pos.y < t );
|
|
}
|
|
|
|
void CMapOverview::DrawMapTexture()
|
|
{
|
|
// now draw a box around the outside of this panel
|
|
int x0, y0, x1, y1;
|
|
int wide, tall;
|
|
|
|
GetSize(wide, tall);
|
|
x0 = 0; y0 = 0; x1 = wide - 2; y1 = tall - 2 ;
|
|
|
|
if ( m_nMapTextureID < 0 )
|
|
return;
|
|
|
|
Vertex_t points[4] =
|
|
{
|
|
Vertex_t( MapToPanel ( Vector2D(0,0) ), Vector2D(0,0) ),
|
|
Vertex_t( MapToPanel ( Vector2D(OVERVIEW_MAP_SIZE-1,0) ), Vector2D(1,0) ),
|
|
Vertex_t( MapToPanel ( Vector2D(OVERVIEW_MAP_SIZE-1,OVERVIEW_MAP_SIZE-1) ), Vector2D(1,1) ),
|
|
Vertex_t( MapToPanel ( Vector2D(0,OVERVIEW_MAP_SIZE-1) ), Vector2D(0,1) )
|
|
};
|
|
|
|
int alpha = 255.0f * overview_alpha.GetFloat(); clamp( alpha, 1, 255 );
|
|
|
|
surface()->DrawSetColor( 255,255,255, alpha );
|
|
surface()->DrawSetTexture( m_nMapTextureID );
|
|
surface()->DrawTexturedPolygon( 4, points );
|
|
}
|
|
|
|
void CMapOverview::DrawMapPlayerTrails()
|
|
{
|
|
if ( m_fTrailUpdateInterval <= 0 )
|
|
return; // turned off
|
|
|
|
for (int i=0; i<MAX_PLAYERS; i++)
|
|
{
|
|
MapPlayer_t *player = &m_Players[i];
|
|
|
|
if ( !CanPlayerBeSeen(player) )
|
|
continue;
|
|
|
|
player->trail[0] = WorldToMap ( player->position );
|
|
|
|
for ( int iTrail=0; iTrail<(MAX_TRAIL_LENGTH-1); iTrail++)
|
|
{
|
|
if ( player->trail[iTrail +1].x == 0 && player->trail[iTrail +1].y == 0 )
|
|
break;
|
|
|
|
Vector2D pos1 = MapToPanel( player->trail[iTrail] );
|
|
Vector2D pos2 = MapToPanel( player->trail[iTrail +1] );
|
|
|
|
int intensity = 255 - float(255.0f * iTrail ) / MAX_TRAIL_LENGTH;
|
|
|
|
Vector2D dist = pos1 - pos2;
|
|
|
|
// don't draw too long lines, player probably teleported
|
|
if ( dist.LengthSqr() < (128*128) )
|
|
{
|
|
surface()->DrawSetColor( player->color[0], player->color[1], player->color[2], intensity );
|
|
surface()->DrawLine( pos1.x, pos1.y, pos2.x, pos2.y );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CMapOverview::DrawObjects( )
|
|
{
|
|
surface()->DrawSetTextFont( m_hIconFont );
|
|
|
|
for (int i=0; i<m_Objects.Count(); i++)
|
|
{
|
|
MapObject_t *obj = &m_Objects[i];
|
|
|
|
const char *text = NULL;
|
|
|
|
if ( Q_strlen(obj->name) > 0 )
|
|
text = obj->name;
|
|
|
|
float flAngle = obj->angle[YAW];
|
|
|
|
if ( obj->flags & MAP_OBJECT_ALIGN_TO_MAP && m_bRotateMap )
|
|
{
|
|
if ( m_bRotateMap )
|
|
flAngle = 90;
|
|
else
|
|
flAngle = 0;
|
|
}
|
|
|
|
MapObject_t tempObj = *obj;
|
|
tempObj.angle[YAW] = flAngle;
|
|
tempObj.text = text;
|
|
tempObj.statusColor = obj->color;
|
|
|
|
// draw icon
|
|
if ( !DrawIcon( &tempObj ) )
|
|
continue;
|
|
}
|
|
}
|
|
|
|
bool CMapOverview::DrawIcon( MapObject_t *obj )
|
|
{
|
|
int textureID = obj->icon;
|
|
Vector pos = obj->position;
|
|
float scale = obj->size;
|
|
float angle = obj->angle[YAW];
|
|
const char *text = obj->text;
|
|
Color *textColor = &obj->color;
|
|
float status = obj->status;
|
|
Color *statusColor = &obj->statusColor;
|
|
|
|
Vector offset; offset.z = 0;
|
|
|
|
Vector2D pospanel = WorldToMap( pos );
|
|
pospanel = MapToPanel( pospanel );
|
|
|
|
if ( !IsInPanel( pospanel ) )
|
|
return false; // player is not within overview panel
|
|
|
|
offset.x = -scale; offset.y = scale;
|
|
VectorYawRotate( offset, angle, offset );
|
|
Vector2D pos1 = WorldToMap( pos + offset );
|
|
|
|
offset.x = scale; offset.y = scale;
|
|
VectorYawRotate( offset, angle, offset );
|
|
Vector2D pos2 = WorldToMap( pos + offset );
|
|
|
|
offset.x = scale; offset.y = -scale;
|
|
VectorYawRotate( offset, angle, offset );
|
|
Vector2D pos3 = WorldToMap( pos + offset );
|
|
|
|
offset.x = -scale; offset.y = -scale;
|
|
VectorYawRotate( offset, angle, offset );
|
|
Vector2D pos4 = WorldToMap( pos + offset );
|
|
|
|
Vertex_t points[4] =
|
|
{
|
|
Vertex_t( MapToPanel ( pos1 ), Vector2D(0,0) ),
|
|
Vertex_t( MapToPanel ( pos2 ), Vector2D(1,0) ),
|
|
Vertex_t( MapToPanel ( pos3 ), Vector2D(1,1) ),
|
|
Vertex_t( MapToPanel ( pos4 ), Vector2D(0,1) )
|
|
};
|
|
|
|
surface()->DrawSetColor( 255, 255, 255, 255 );
|
|
surface()->DrawSetTexture( textureID );
|
|
surface()->DrawTexturedPolygon( 4, points );
|
|
|
|
int d = GetPixelOffset( scale);
|
|
|
|
pospanel.y += d + 4;
|
|
|
|
if ( status >=0.0f && status <= 1.0f && statusColor )
|
|
{
|
|
// health bar is 50x3 pixels
|
|
surface()->DrawSetColor( 0,0,0,255 );
|
|
surface()->DrawFilledRect( pospanel.x-d, pospanel.y-1, pospanel.x+d, pospanel.y+1 );
|
|
|
|
int length = (float)(d*2)*status;
|
|
surface()->DrawSetColor( statusColor->r(), statusColor->g(), statusColor->b(), 255 );
|
|
surface()->DrawFilledRect( pospanel.x-d, pospanel.y-1, pospanel.x-d+length, pospanel.y+1 );
|
|
|
|
pospanel.y += 3;
|
|
}
|
|
|
|
if ( text && textColor )
|
|
{
|
|
wchar_t iconText[ MAX_PLAYER_NAME_LENGTH*2 ];
|
|
|
|
g_pVGuiLocalize->ConvertANSIToUnicode( text, iconText, sizeof( iconText ) );
|
|
|
|
int wide, tall;
|
|
surface()->GetTextSize( m_hIconFont, iconText, wide, tall );
|
|
|
|
int x = pospanel.x-(wide/2);
|
|
int y = pospanel.y;
|
|
|
|
// draw black shadow text
|
|
surface()->DrawSetTextColor( 0, 0, 0, 255 );
|
|
surface()->DrawSetTextPos( x+1, y );
|
|
surface()->DrawPrintText( iconText, wcslen(iconText) );
|
|
|
|
// draw name in color
|
|
surface()->DrawSetTextColor( textColor->r(), textColor->g(), textColor->b(), 255 );
|
|
surface()->DrawSetTextPos( x, y );
|
|
surface()->DrawPrintText( iconText, wcslen(iconText) );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int CMapOverview::GetPixelOffset( float height )
|
|
{
|
|
Vector2D pos2 = WorldToMap( Vector( height,0,0) );
|
|
pos2 = MapToPanel( pos2 );
|
|
|
|
Vector2D pos3 = WorldToMap( Vector(0,0,0) );
|
|
pos3 = MapToPanel( pos3 );
|
|
|
|
int a = pos2.y-pos3.y;
|
|
int b = pos2.x-pos3.x;
|
|
|
|
return (int)sqrt((float)(a*a+b*b)); // number of panel pixels for "scale" units in world
|
|
}
|
|
|
|
void CMapOverview::DrawMapPlayers()
|
|
{
|
|
surface()->DrawSetTextFont( m_hIconFont );
|
|
|
|
Color colorGreen( 0, 255, 0, 255 ); // health bar color
|
|
|
|
for (int i=0; i<MAX_PLAYERS; i++)
|
|
{
|
|
MapPlayer_t *player = &m_Players[i];
|
|
|
|
if ( !CanPlayerBeSeen( player ) )
|
|
continue;
|
|
|
|
// don't draw dead players / spectators
|
|
if ( player->health <= 0 )
|
|
continue;
|
|
|
|
float status = -1;
|
|
const char *name = NULL;
|
|
|
|
if ( m_bShowNames && CanPlayerNameBeSeen( player ) )
|
|
name = player->name;
|
|
|
|
if ( m_bShowHealth && CanPlayerHealthBeSeen( player ) )
|
|
status = player->health/100.0f;
|
|
|
|
// convert from PlayerObject_t
|
|
MapObject_t tempObj;
|
|
memset( &tempObj, 0, sizeof(MapObject_t) );
|
|
tempObj.icon = player->icon;
|
|
tempObj.position = player->position;
|
|
tempObj.size = m_flIconSize;
|
|
tempObj.angle = player->angle;
|
|
tempObj.text = name;
|
|
tempObj.color = player->color;
|
|
tempObj.status = status;
|
|
tempObj.statusColor = colorGreen;
|
|
|
|
DrawIcon( &tempObj );
|
|
}
|
|
}
|
|
|
|
Vector2D CMapOverview::WorldToMap( const Vector &worldpos )
|
|
{
|
|
Vector2D offset( worldpos.x - m_MapOrigin.x, worldpos.y - m_MapOrigin.y);
|
|
|
|
offset.x /= m_fMapScale;
|
|
offset.y /= -m_fMapScale;
|
|
|
|
return offset;
|
|
}
|
|
|
|
float CMapOverview::GetViewAngle( void )
|
|
{
|
|
float viewAngle = m_fViewAngle - 90.0f;
|
|
|
|
if ( !m_bFollowAngle )
|
|
{
|
|
// We don't use fViewAngle. We just show straight at all times.
|
|
if ( m_bRotateMap )
|
|
viewAngle = 90.0f;
|
|
else
|
|
viewAngle = 0.0f;
|
|
}
|
|
|
|
return viewAngle;
|
|
}
|
|
|
|
Vector2D CMapOverview::MapToPanel( const Vector2D &mappos )
|
|
{
|
|
int pwidth, pheight;
|
|
Vector2D panelpos;
|
|
float viewAngle = GetViewAngle();
|
|
|
|
GetSize(pwidth, pheight);
|
|
|
|
Vector offset;
|
|
offset.x = mappos.x - m_MapCenter.x;
|
|
offset.y = mappos.y - m_MapCenter.y;
|
|
offset.z = 0;
|
|
|
|
VectorYawRotate( offset, viewAngle, offset );
|
|
|
|
// find the actual zoom from the animationvar m_fZoom and the map zoom scale
|
|
float fScale = (m_fZoom * m_fFullZoom) / OVERVIEW_MAP_SIZE;
|
|
|
|
offset.x *= fScale;
|
|
offset.y *= fScale;
|
|
|
|
panelpos.x = (pwidth * 0.5f) + (pheight * offset.x);
|
|
panelpos.y = (pheight * 0.5f) + (pheight * offset.y);
|
|
|
|
return panelpos;
|
|
}
|
|
|
|
void CMapOverview::SetTime( float time )
|
|
{
|
|
m_fWorldTime = time;
|
|
}
|
|
|
|
void CMapOverview::SetMap(const char * levelname)
|
|
{
|
|
// Reset players and objects, even if the map is the same as the previous one
|
|
m_Objects.RemoveAll();
|
|
|
|
m_fNextTrailUpdate = 0;// Set to 0 for immediate update. Our WorldTime var hasn't been updated to 0 for the new map yet
|
|
m_fWorldTime = 0;// In release, we occasionally race and get this bug again if we gt a paint before an update. Reset this before the old value gets in to the timer.
|
|
// Please note, UpdatePlayerTrails comes from PAINT, not UPDATE.
|
|
|
|
InitTeamColorsAndIcons();
|
|
|
|
// load new KeyValues
|
|
if ( m_MapKeyValues && Q_strcmp( levelname, m_MapKeyValues->GetName() ) == 0 )
|
|
{
|
|
return; // map didn't change
|
|
}
|
|
|
|
if ( m_MapKeyValues )
|
|
m_MapKeyValues->deleteThis();
|
|
|
|
m_MapKeyValues = new KeyValues( levelname );
|
|
|
|
char tempfile[MAX_PATH];
|
|
Q_snprintf( tempfile, sizeof( tempfile ), "resource/overviews/%s.txt", levelname );
|
|
|
|
if ( !m_MapKeyValues->LoadFromFile( g_pFullFileSystem, tempfile, "GAME" ) )
|
|
{
|
|
DevMsg( 1, "Error! CMapOverview::SetMap: couldn't load file %s.\n", tempfile );
|
|
m_nMapTextureID = -1;
|
|
m_MapOrigin.x = 0;
|
|
m_MapOrigin.y = 0;
|
|
m_fMapScale = 1;
|
|
m_bRotateMap = false;
|
|
m_fFullZoom = 1;
|
|
return;
|
|
}
|
|
|
|
// TODO release old texture ?
|
|
|
|
m_nMapTextureID = surface()->CreateNewTextureID();
|
|
|
|
//if we have not uploaded yet, lets go ahead and do so
|
|
surface()->DrawSetTextureFile( m_nMapTextureID, m_MapKeyValues->GetString("material"), true, false);
|
|
|
|
int wide, tall;
|
|
|
|
surface()->DrawGetTextureSize( m_nMapTextureID, wide, tall );
|
|
|
|
if ( wide != tall )
|
|
{
|
|
DevMsg( 1, "Error! CMapOverview::SetMap: map image must be a square.\n" );
|
|
m_nMapTextureID = -1;
|
|
return;
|
|
}
|
|
|
|
m_MapOrigin.x = m_MapKeyValues->GetInt("pos_x");
|
|
m_MapOrigin.y = m_MapKeyValues->GetInt("pos_y");
|
|
m_fMapScale = m_MapKeyValues->GetFloat("scale", 1.0f);
|
|
m_bRotateMap = m_MapKeyValues->GetInt("rotate")!=0;
|
|
m_fFullZoom = m_MapKeyValues->GetFloat("zoom", 1.0f );
|
|
}
|
|
|
|
void CMapOverview::ResetRound()
|
|
{
|
|
for (int i=0; i<MAX_PLAYERS; i++)
|
|
{
|
|
MapPlayer_t *p = &m_Players[i];
|
|
|
|
if ( p->team > TEAM_SPECTATOR )
|
|
{
|
|
p->health = 100;
|
|
}
|
|
|
|
Q_memset( p->trail, 0, sizeof(p->trail) );
|
|
|
|
p->position = Vector( 0, 0, 0 );
|
|
}
|
|
|
|
m_Objects.RemoveAll();
|
|
}
|
|
|
|
void CMapOverview::OnMousePressed( MouseCode code )
|
|
{
|
|
|
|
}
|
|
|
|
void CMapOverview::DrawCamera()
|
|
{
|
|
// draw a red center point
|
|
surface()->DrawSetColor( 255,0,0,255 );
|
|
Vector2D center = MapToPanel( m_ViewOrigin );
|
|
surface()->DrawFilledRect( center.x-2, center.y-2, center.x+2, center.y+2);
|
|
}
|
|
|
|
void CMapOverview::FireGameEvent( IGameEvent *event )
|
|
{
|
|
const char * type = event->GetName();
|
|
|
|
if ( Q_strcmp(type, "game_newmap") == 0 )
|
|
{
|
|
SetMap( event->GetString("mapname") );
|
|
ResetRound();
|
|
}
|
|
|
|
else if ( Q_strcmp(type, "round_start") == 0 )
|
|
{
|
|
ResetRound();
|
|
}
|
|
|
|
else if ( Q_strcmp(type,"player_connect_client") == 0 )
|
|
{
|
|
int index = event->GetInt("index"); // = entity index - 1
|
|
|
|
if ( index < 0 || index >= MAX_PLAYERS )
|
|
return;
|
|
|
|
MapPlayer_t *player = &m_Players[index];
|
|
|
|
player->index = index;
|
|
player->userid = event->GetInt("userid");
|
|
Q_strncpy( player->name, event->GetString("name","unknown"), sizeof(player->name) );
|
|
|
|
// Reset settings
|
|
Q_memset( player->trail, 0, sizeof(player->trail) );
|
|
player->team = TEAM_UNASSIGNED;
|
|
player->health = 0;
|
|
}
|
|
|
|
else if ( Q_strcmp(type,"player_info") == 0 )
|
|
{
|
|
int index = event->GetInt("index"); // = entity index - 1
|
|
|
|
if ( index < 0 || index >= MAX_PLAYERS )
|
|
return;
|
|
|
|
MapPlayer_t *player = &m_Players[index];
|
|
|
|
player->index = index;
|
|
player->userid = event->GetInt("userid");
|
|
Q_strncpy( player->name, event->GetString("name","unknown"), sizeof(player->name) );
|
|
}
|
|
|
|
else if ( Q_strcmp(type,"player_team") == 0 )
|
|
{
|
|
MapPlayer_t *player = GetPlayerByUserID( event->GetInt("userid") );
|
|
|
|
if ( !player )
|
|
return;
|
|
|
|
player->team = event->GetInt("team");
|
|
player->icon = m_TeamIcons[ GetIconNumberFromTeamNumber(player->team) ];
|
|
player->color = m_TeamColors[ GetIconNumberFromTeamNumber(player->team) ];
|
|
}
|
|
|
|
else if ( Q_strcmp(type,"player_death") == 0 )
|
|
{
|
|
MapPlayer_t *player = GetPlayerByUserID( event->GetInt("userid") );
|
|
|
|
if ( !player )
|
|
return;
|
|
|
|
player->health = 0;
|
|
Q_memset( player->trail, 0, sizeof(player->trail) ); // clear trails
|
|
}
|
|
|
|
else if ( Q_strcmp(type,"player_spawn") == 0 )
|
|
{
|
|
MapPlayer_t *player = GetPlayerByUserID( event->GetInt("userid") );
|
|
|
|
if ( !player )
|
|
return;
|
|
|
|
player->health = 100;
|
|
Q_memset( player->trail, 0, sizeof(player->trail) ); // clear trails
|
|
}
|
|
|
|
else if ( Q_strcmp(type,"player_disconnect") == 0 )
|
|
{
|
|
MapPlayer_t *player = GetPlayerByUserID( event->GetInt("userid") );
|
|
|
|
if ( !player )
|
|
return;
|
|
|
|
Q_memset( player, 0, sizeof(MapPlayer_t) ); // clear player field
|
|
}
|
|
}
|
|
|
|
void CMapOverview::SetMode(int mode)
|
|
{
|
|
m_flChangeSpeed = 0; // change size instantly
|
|
|
|
if ( mode == MAP_MODE_OFF )
|
|
{
|
|
ShowPanel( false );
|
|
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "MapOff" );
|
|
}
|
|
else if ( mode == MAP_MODE_INSET )
|
|
{
|
|
if( m_nMapTextureID == -1 )
|
|
{
|
|
SetMode( MAP_MODE_OFF );
|
|
return;
|
|
}
|
|
|
|
if ( m_nMode != MAP_MODE_OFF )
|
|
m_flChangeSpeed = 1000; // zoom effect
|
|
|
|
C_BasePlayer *pPlayer = CBasePlayer::GetLocalPlayer();
|
|
|
|
if ( pPlayer )
|
|
SetFollowEntity( pPlayer->entindex() );
|
|
|
|
ShowPanel( true );
|
|
|
|
if ( mode != m_nMode && RunHudAnimations() )
|
|
{
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "MapZoomToSmall" );
|
|
}
|
|
}
|
|
else if ( mode == MAP_MODE_FULL )
|
|
{
|
|
if( m_nMapTextureID == -1 )
|
|
{
|
|
SetMode( MAP_MODE_OFF );
|
|
return;
|
|
}
|
|
|
|
if ( m_nMode != MAP_MODE_OFF )
|
|
m_flChangeSpeed = 1000; // zoom effect
|
|
|
|
SetFollowEntity( 0 );
|
|
|
|
ShowPanel( true );
|
|
|
|
if ( mode != m_nMode && RunHudAnimations() )
|
|
{
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "MapZoomToLarge" );
|
|
}
|
|
}
|
|
|
|
// finally set mode
|
|
m_nMode = mode;
|
|
|
|
UpdateSizeAndPosition();
|
|
}
|
|
|
|
bool CMapOverview::ShouldDraw( void )
|
|
{
|
|
return ( m_nMode != MAP_MODE_OFF ) && CHudElement::ShouldDraw();
|
|
}
|
|
|
|
void CMapOverview::UpdateSizeAndPosition()
|
|
{
|
|
if ( g_pSpectatorGUI && g_pSpectatorGUI->IsVisible() )
|
|
{
|
|
int iScreenWide, iScreenTall;
|
|
GetHudSize( iScreenWide, iScreenTall );
|
|
|
|
int iTopBarHeight = g_pSpectatorGUI->GetTopBarHeight();
|
|
int iBottomBarHeight = g_pSpectatorGUI->GetBottomBarHeight();
|
|
|
|
iScreenTall -= ( iTopBarHeight + iBottomBarHeight );
|
|
|
|
int x,y,w,h;
|
|
GetBounds( x,y,w,h );
|
|
|
|
if ( y < iTopBarHeight )
|
|
y = iTopBarHeight;
|
|
|
|
SetBounds( x,y,w,MIN(h,iScreenTall) );
|
|
}
|
|
}
|
|
|
|
void CMapOverview::SetCenter(const Vector2D &mappos)
|
|
{
|
|
int width, height;
|
|
|
|
GetSize( width, height);
|
|
|
|
m_ViewOrigin = mappos;
|
|
m_MapCenter = mappos;
|
|
|
|
float fTwiceZoom = m_fZoom * m_fFullZoom * 2;
|
|
|
|
width = height = OVERVIEW_MAP_SIZE / (fTwiceZoom);
|
|
|
|
if( GetMode() != MAP_MODE_RADAR )
|
|
{
|
|
if ( m_MapCenter.x < width )
|
|
m_MapCenter.x = width;
|
|
|
|
if ( m_MapCenter.x > (OVERVIEW_MAP_SIZE-width) )
|
|
m_MapCenter.x = (OVERVIEW_MAP_SIZE-width);
|
|
|
|
if ( m_MapCenter.y < height )
|
|
m_MapCenter.y = height;
|
|
|
|
if ( m_MapCenter.y > (OVERVIEW_MAP_SIZE-height) )
|
|
m_MapCenter.y = (OVERVIEW_MAP_SIZE-height);
|
|
|
|
//center if in full map mode
|
|
if ( m_fZoom <= 1.0 )
|
|
{
|
|
m_MapCenter.x = OVERVIEW_MAP_SIZE/2;
|
|
m_MapCenter.y = OVERVIEW_MAP_SIZE/2;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void CMapOverview::SetFollowAngle(bool state)
|
|
{
|
|
m_bFollowAngle = state;
|
|
}
|
|
|
|
void CMapOverview::SetFollowEntity(int entindex)
|
|
{
|
|
m_nFollowEntity = entindex;
|
|
}
|
|
|
|
float CMapOverview::GetZoom( void )
|
|
{
|
|
return m_fZoom;
|
|
}
|
|
|
|
int CMapOverview::GetMode( void )
|
|
{
|
|
return m_nMode;
|
|
}
|
|
|
|
void CMapOverview::SetAngle(float angle)
|
|
{
|
|
m_fViewAngle = angle;
|
|
}
|
|
|
|
void CMapOverview::ShowPlayerNames(bool state)
|
|
{
|
|
m_bShowNames = state;
|
|
}
|
|
|
|
|
|
void CMapOverview::ShowPlayerHealth(bool state)
|
|
{
|
|
m_bShowHealth = state;
|
|
}
|
|
|
|
void CMapOverview::ShowPlayerTracks(float seconds)
|
|
{
|
|
m_fTrailUpdateInterval = seconds;
|
|
}
|
|
|
|
bool CMapOverview::SetTeamColor(int team, Color color)
|
|
{
|
|
if ( team < 0 || team>= MAX_TEAMS )
|
|
return false;
|
|
|
|
m_TeamColors[team] = color;
|
|
|
|
return true;
|
|
}
|
|
|
|
CMapOverview::MapObject_t* CMapOverview::FindObjectByID(int objectID)
|
|
{
|
|
for ( int i = 0; i < m_Objects.Count(); i++ )
|
|
{
|
|
if ( m_Objects[i].objectID == objectID )
|
|
return &m_Objects[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int CMapOverview::AddObject( const char *icon, int entity, float timeToLive )
|
|
{
|
|
MapObject_t obj; Q_memset( &obj, 0, sizeof(obj) );
|
|
|
|
obj.objectID = m_ObjectCounterID++;
|
|
obj.index = entity;
|
|
obj.icon = AddIconTexture( icon );
|
|
obj.size = m_flIconSize;
|
|
obj.status = -1;
|
|
|
|
if ( timeToLive > 0 )
|
|
obj.endtime = gpGlobals->curtime + timeToLive;
|
|
else
|
|
obj.endtime = -1;
|
|
|
|
m_Objects.AddToTail( obj );
|
|
|
|
return obj.objectID;
|
|
}
|
|
|
|
void CMapOverview::SetObjectText( int objectID, const char *text, Color color )
|
|
{
|
|
MapObject_t* obj = FindObjectByID( objectID );
|
|
|
|
if ( !obj )
|
|
return;
|
|
|
|
if ( text )
|
|
{
|
|
Q_strncpy( obj->name, text, sizeof(obj->name) );
|
|
}
|
|
else
|
|
{
|
|
Q_memset( obj->name, 0, sizeof(obj->name) );
|
|
}
|
|
|
|
obj->color = color;
|
|
}
|
|
|
|
void CMapOverview::SetObjectStatus( int objectID, float status, Color color )
|
|
{
|
|
MapObject_t* obj = FindObjectByID( objectID );
|
|
|
|
if ( !obj )
|
|
return;
|
|
|
|
obj->status = status;
|
|
obj->statusColor = color;
|
|
}
|
|
|
|
void CMapOverview::SetObjectIcon( int objectID, const char *icon, float size )
|
|
{
|
|
MapObject_t* obj = FindObjectByID( objectID );
|
|
|
|
if ( !obj )
|
|
return;
|
|
|
|
obj->icon = AddIconTexture( icon );
|
|
obj->size = size;
|
|
}
|
|
|
|
void CMapOverview::SetObjectPosition( int objectID, const Vector &position, const QAngle &angle )
|
|
{
|
|
MapObject_t* obj = FindObjectByID( objectID );
|
|
|
|
if ( !obj )
|
|
return;
|
|
|
|
obj->angle = angle;
|
|
obj->position = position;
|
|
}
|
|
|
|
void CMapOverview::AddObjectFlags( int objectID, int flags )
|
|
{
|
|
MapObject_t* obj = FindObjectByID( objectID );
|
|
|
|
if ( !obj )
|
|
return;
|
|
|
|
obj->flags |= flags;
|
|
}
|
|
|
|
void CMapOverview::SetObjectFlags( int objectID, int flags )
|
|
{
|
|
MapObject_t* obj = FindObjectByID( objectID );
|
|
|
|
if ( !obj )
|
|
return;
|
|
|
|
obj->flags = flags;
|
|
}
|
|
|
|
void CMapOverview::RemoveObjectByIndex( int index )
|
|
{
|
|
for ( int i = 0; i < m_Objects.Count(); i++ )
|
|
{
|
|
if ( m_Objects[i].index == index )
|
|
{
|
|
m_Objects.Remove( i );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CMapOverview::RemoveObject( int objectID )
|
|
{
|
|
for ( int i = 0; i < m_Objects.Count(); i++ )
|
|
{
|
|
if ( m_Objects[i].objectID == objectID )
|
|
{
|
|
m_Objects.Remove( i );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CMapOverview::UpdateObjects()
|
|
{
|
|
for ( int i = 0; i < m_Objects.Count(); i++ )
|
|
{
|
|
MapObject_t *obj = &m_Objects[i];
|
|
|
|
if ( obj->endtime > 0 && obj->endtime < gpGlobals->curtime )
|
|
{
|
|
m_Objects.Remove( i );
|
|
i--;
|
|
continue;
|
|
}
|
|
|
|
if ( obj->index <= 0 )
|
|
continue;
|
|
|
|
C_BaseEntity *entity = ClientEntityList().GetEnt( obj->index );
|
|
|
|
if ( !entity )
|
|
continue;
|
|
|
|
obj->position = entity->GetAbsOrigin();
|
|
obj->angle = entity->GetAbsAngles();
|
|
}
|
|
} |