First version of the SOurce SDK 2013

1 files changed, 1321 insertions, 0 deletions

diff --git a/mp/src/game/client/cdll_util.cpp b/mp/src/game/client/cdll_util.cpp
new file mode 100644
index 00000000..0a930647
--- /dev/null
+++ b/mp/src/game/client/cdll_util.cpp
@@ -0,0 +1,1321 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+// $Workfile:     $

+// $NoKeywords: $

+//=============================================================================//

+#include "cbase.h"

+#include <stdarg.h>

+#include "hud.h"

+#include "itextmessage.h"

+#include "materialsystem/imaterial.h"

+#include "materialsystem/itexture.h"

+#include "materialsystem/imaterialsystem.h"

+#include "imovehelper.h"

+#include "checksum_crc.h"

+#include "decals.h"

+#include "iefx.h"

+#include "view_scene.h"

+#include "filesystem.h"

+#include "model_types.h"

+#include "engine/IEngineTrace.h"

+#include "engine/ivmodelinfo.h"

+#include "c_te_effect_dispatch.h"

+#include <vgui_controls/Controls.h>

+#include <vgui/ISurface.h>

+#include <vgui/ILocalize.h>

+#include "view.h"

+#include "ixboxsystem.h"

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include "tier0/memdbgon.h"

+																						

+ConVar localplayer_visionflags( "localplayer_visionflags", "0", FCVAR_DEVELOPMENTONLY );

+																						

+//-----------------------------------------------------------------------------

+// ConVars

+//-----------------------------------------------------------------------------

+#ifdef _DEBUG

+

+ConVar r_FadeProps( "r_FadeProps", "1" );

+

+#endif

+bool g_MakingDevShots = false;

+extern ConVar cl_leveloverview;

+

+//-----------------------------------------------------------------------------

+// Purpose: Performs a var args printf into a static return buffer

+// Input  : *format - 

+//			... - 

+// Output : char

+//-----------------------------------------------------------------------------

+char *VarArgs( const char *format, ... )

+{

+	va_list		argptr;

+	static char		string[1024];

+	

+	va_start (argptr, format);

+	Q_vsnprintf (string, sizeof( string ), format,argptr);

+	va_end (argptr);

+

+	return string;	

+}

+	

+//-----------------------------------------------------------------------------

+// Purpose: Returns true if the entity index corresponds to a player slot 

+// Input  : index - 

+// Output : bool

+//-----------------------------------------------------------------------------

+bool IsPlayerIndex( int index )

+{

+	return ( index >= 1 && index <= gpGlobals->maxClients ) ? true : false;

+}

+

+int GetLocalPlayerIndex( void )

+{

+	C_BasePlayer * player = C_BasePlayer::GetLocalPlayer();

+

+	if ( player )

+		return player->entindex();

+	else

+		return 0;	// game not started yet

+}

+

+int GetLocalPlayerVisionFilterFlags( bool bWeaponsCheck /*= false */ )

+{

+	C_BasePlayer * player = C_BasePlayer::GetLocalPlayer();

+

+	if ( player )

+		return player->GetVisionFilterFlags( bWeaponsCheck );

+	else

+		return 0;

+}

+

+bool IsLocalPlayerUsingVisionFilterFlags( int nFlags, bool bWeaponsCheck /* = false */ )

+{

+	int nLocalPlayerFlags = GetLocalPlayerVisionFilterFlags( bWeaponsCheck );

+

+	if ( !bWeaponsCheck )

+	{

+		// We can only modify the RJ flags with normal checks that won't take the forced kill cam flags that can happen in weapon checks

+		int nRJShaderFlags = nLocalPlayerFlags;

+		if ( nRJShaderFlags != 0 && GameRules() && !GameRules()->AllowMapVisionFilterShaders() )

+		{

+			nRJShaderFlags = 0;

+		}

+

+		if ( nRJShaderFlags != localplayer_visionflags.GetInt() )

+		{

+			localplayer_visionflags.SetValue( nRJShaderFlags );

+		}

+	}

+

+	return ( nLocalPlayerFlags & nFlags ) == nFlags;

+}

+

+bool IsLocalPlayerSpectator( void )

+{

+	C_BasePlayer * player = C_BasePlayer::GetLocalPlayer();

+

+	if ( player )

+		return player->IsObserver();

+	else

+		return false;	// game not started yet

+}

+

+int GetSpectatorMode( void )

+{

+	C_BasePlayer * player = C_BasePlayer::GetLocalPlayer();

+

+	if ( player )

+		return player->GetObserverMode();

+	else

+		return OBS_MODE_NONE;	// game not started yet

+}

+

+int GetSpectatorTarget( void )

+{

+	C_BasePlayer * player = C_BasePlayer::GetLocalPlayer();

+

+	if ( player )

+	{

+		CBaseEntity * target = player->GetObserverTarget();

+

+		if ( target )

+			return target->entindex();

+		else

+			return 0;

+	}

+	else

+	{

+		return  0;	// game not started yet

+	}

+}

+

+int GetLocalPlayerTeam( void ) 

+{ 

+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();

+	

+	if ( pPlayer )

+		return pPlayer->GetTeamNumber(); 

+	else

+		return TEAM_UNASSIGNED;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Convert angles to -180 t 180 range

+// Input  : angles - 

+//-----------------------------------------------------------------------------

+void NormalizeAngles( QAngle& angles )

+{

+	int i;

+	

+	// Normalize angles to -180 to 180 range

+	for ( i = 0; i < 3; i++ )

+	{

+		if ( angles[i] > 180.0 )

+		{

+			angles[i] -= 360.0;

+		}

+		else if ( angles[i] < -180.0 )

+		{

+			angles[i] += 360.0;

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Interpolate Euler angles using quaternions to avoid singularities

+// Input  : start - 

+//			end - 

+//			output - 

+//			frac - 

+//-----------------------------------------------------------------------------

+void InterpolateAngles( const QAngle& start, const QAngle& end, QAngle& output, float frac )

+{

+	Quaternion src, dest;

+

+	// Convert to quaternions

+	AngleQuaternion( start, src );

+	AngleQuaternion( end, dest );

+

+	Quaternion result;

+

+	// Slerp

+	QuaternionSlerp( src, dest, frac, result );

+

+	// Convert to euler

+	QuaternionAngles( result, output );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Simple linear interpolation

+// Input  : frac - 

+//			src - 

+//			dest - 

+//			output - 

+//-----------------------------------------------------------------------------

+void InterpolateVector( float frac, const Vector& src, const Vector& dest, Vector& output )

+{

+	int i;

+

+	for ( i = 0; i < 3; i++ )

+	{

+		output[ i ] = src[ i ] + frac * ( dest[ i ] - src[ i ] );

+	}

+}

+

+client_textmessage_t *TextMessageGet( const char *pName )

+{ 

+	return engine->TextMessageGet( pName );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: ScreenHeight returns the height of the screen, in pixels

+// Output : int

+//-----------------------------------------------------------------------------

+int ScreenHeight( void )

+{

+	int w, h;

+	GetHudSize( w, h );

+	return h;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: ScreenWidth returns the width of the screen, in pixels

+// Output : int

+//-----------------------------------------------------------------------------

+int ScreenWidth( void )

+{

+	int w, h;

+	GetHudSize( w, h );

+	return w;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Return the difference between two angles

+// Input  : destAngle - 

+//			srcAngle - 

+// Output : float

+//-----------------------------------------------------------------------------

+float UTIL_AngleDiff( float destAngle, float srcAngle )

+{

+	float delta;

+

+	delta = destAngle - srcAngle;

+	if ( destAngle > srcAngle )

+	{

+		while ( delta >= 180 )

+			delta -= 360;

+	}

+	else

+	{

+		while ( delta <= -180 )

+			delta += 360;

+	}

+	return delta;

+}

+

+

+float UTIL_WaterLevel( const Vector &position, float minz, float maxz )

+{

+	Vector midUp = position;

+	midUp.z = minz;

+

+	if ( !(UTIL_PointContents(midUp) & MASK_WATER) )

+		return minz;

+

+	midUp.z = maxz;

+	if ( UTIL_PointContents(midUp) & MASK_WATER )

+		return maxz;

+

+	float diff = maxz - minz;

+	while (diff > 1.0)

+	{

+		midUp.z = minz + diff/2.0;

+		if ( UTIL_PointContents(midUp) & MASK_WATER )

+		{

+			minz = midUp.z;

+		}

+		else

+		{

+			maxz = midUp.z;

+		}

+		diff = maxz - minz;

+	}

+

+	return midUp.z;

+}

+

+void UTIL_Bubbles( const Vector& mins, const Vector& maxs, int count )

+{

+	Vector mid =  (mins + maxs) * 0.5;

+

+	float flHeight = UTIL_WaterLevel( mid,  mid.z, mid.z + 1024 );

+	flHeight = flHeight - mins.z;

+

+	CPASFilter filter( mid );

+

+	int bubbles = modelinfo->GetModelIndex( "sprites/bubble.vmt" );

+

+	te->Bubbles( filter, 0.0,

+		&mins, &maxs, flHeight, bubbles, count, 8.0 );

+}

+

+void UTIL_ScreenShake( const Vector &center, float amplitude, float frequency, float duration, float radius, ShakeCommand_t eCommand, bool bAirShake )

+{

+	// Nothing for now

+}

+

+char TEXTURETYPE_Find( trace_t *ptr )

+{

+	surfacedata_t *psurfaceData = physprops->GetSurfaceData( ptr->surface.surfaceProps );

+

+	return psurfaceData->game.material;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Make a tracer effect

+//-----------------------------------------------------------------------------

+void UTIL_Tracer( const Vector &vecStart, const Vector &vecEnd, int iEntIndex, int iAttachment, float flVelocity, bool bWhiz, char *pCustomTracerName )

+{

+	CEffectData data;

+	data.m_vStart = vecStart;

+	data.m_vOrigin = vecEnd;

+	data.m_hEntity = ClientEntityList().EntIndexToHandle( iEntIndex );

+	data.m_flScale = flVelocity;

+

+	// Flags

+	if ( bWhiz )

+	{

+		data.m_fFlags |= TRACER_FLAG_WHIZ;

+	}

+	if ( iAttachment != TRACER_DONT_USE_ATTACHMENT )

+	{

+		data.m_fFlags |= TRACER_FLAG_USEATTACHMENT;

+		// Stomp the start, since it's not going to be used anyway

+		data.m_vStart[0] = iAttachment;

+	}

+

+	// Fire it off

+	if ( pCustomTracerName )

+	{

+		DispatchEffect( pCustomTracerName, data );

+	}

+	else

+	{

+		DispatchEffect( "Tracer", data );

+	}

+}

+

+

+//------------------------------------------------------------------------------

+// Purpose : Creates both an decal and any associated impact effects (such

+//			 as flecks) for the given iDamageType and the trace's end position

+// Input   :

+// Output  :

+//------------------------------------------------------------------------------

+void UTIL_ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )

+{

+	C_BaseEntity *pEntity = pTrace->m_pEnt;

+

+	// Is the entity valid, is the surface sky?

+	if ( !pEntity || (pTrace->surface.flags & SURF_SKY) )

+		return;

+

+	if (pTrace->fraction == 1.0)

+		return;

+

+	// don't decal nodraw surfaces

+	if ( pTrace->surface.flags & SURF_NODRAW )

+		return;

+

+	pEntity->ImpactTrace( pTrace, iDamageType, pCustomImpactName );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+int UTIL_PrecacheDecal( const char *name, bool preload )

+{

+	return effects->Draw_DecalIndexFromName( (char*)name );

+}

+

+extern short g_sModelIndexSmoke;

+

+void UTIL_Smoke( const Vector &origin, const float scale, const float framerate )

+{

+	CPVSFilter filter( origin );

+	te->Smoke( filter, 0.0f, &origin, g_sModelIndexSmoke, scale, framerate );

+}

+

+void UTIL_SetOrigin( C_BaseEntity *entity, const Vector &vecOrigin )

+{

+	entity->SetLocalOrigin( vecOrigin );

+}

+

+//#define PRECACHE_OTHER_ONCE

+// UNDONE: Do we need this to avoid doing too much of this?  Measure startup times and see

+#if PRECACHE_OTHER_ONCE

+

+#include "utlsymbol.h"

+class CPrecacheOtherList : public CAutoServerSystem

+{

+public:

+	virtual void LevelInitPreEntity();

+	virtual void LevelShutdownPostEntity();

+

+	bool AddOrMarkPrecached( const char *pClassname );

+

+private:

+	CUtlSymbolTable		m_list;

+};

+

+void CPrecacheOtherList::LevelInitPreEntity()

+{

+	m_list.RemoveAll();

+}

+

+void CPrecacheOtherList::LevelShutdownPostEntity()

+{

+	m_list.RemoveAll();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: mark or add

+// Input  : *pEntity - 

+// Output : Returns true on success, false on failure.

+//-----------------------------------------------------------------------------

+bool CPrecacheOtherList::AddOrMarkPrecached( const char *pClassname )

+{

+	CUtlSymbol sym = m_list.Find( pClassname );

+	if ( sym.IsValid() )

+		return false;

+

+	m_list.AddString( pClassname );

+	return true;

+}

+

+CPrecacheOtherList g_PrecacheOtherList;

+#endif

+

+void UTIL_PrecacheOther( const char *szClassname )

+{

+#if PRECACHE_OTHER_ONCE

+	// already done this one?, if not, mark as done

+	if ( !g_PrecacheOtherList.AddOrMarkPrecached( szClassname ) )

+		return;

+#endif

+

+	// Client should only do this once entities are coming down from server!!!

+	// Assert( engine->IsConnected() );

+

+	C_BaseEntity	*pEntity = CreateEntityByName( szClassname );

+	if ( !pEntity )

+	{

+		Warning( "NULL Ent in UTIL_PrecacheOther\n" );

+		return;

+	}

+	

+	if (pEntity)

+	{

+		pEntity->Precache( );

+	}

+

+	// Bye bye

+	pEntity->Release();

+}

+

+static csurface_t	g_NullSurface = { "**empty**", 0 };

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void UTIL_SetTrace(trace_t& trace, const Ray_t& ray, C_BaseEntity *ent, float fraction, int hitgroup, unsigned int contents, const Vector& normal, float intercept )

+{

+	trace.startsolid = (fraction == 0.0f);

+	trace.fraction = fraction;

+	VectorCopy( ray.m_Start, trace.startpos );

+	VectorMA( ray.m_Start, fraction, ray.m_Delta, trace.endpos );

+	VectorCopy( normal, trace.plane.normal );

+	trace.plane.dist = intercept;

+	trace.m_pEnt = C_BaseEntity::Instance( ent );

+	trace.hitgroup = hitgroup;

+	trace.surface =	g_NullSurface;

+	trace.contents = contents;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the x & y positions of a world position in screenspace

+//			Returns true if it's onscreen

+//-----------------------------------------------------------------------------

+bool GetVectorInScreenSpace( Vector pos, int& iX, int& iY, Vector *vecOffset )

+{

+	Vector screen;

+

+	// Apply the offset, if one was specified

+	if ( vecOffset != NULL )

+		pos += *vecOffset;

+

+	// Transform to screen space

+	int iFacing = ScreenTransform( pos, screen );

+	iX = 0.5f * ( 1.0f + screen[0] ) * ScreenWidth();

+	iY = 0.5f * ( 1.0f - screen[1] ) * ScreenHeight();

+

+	// Make sure the player's facing it

+	if ( iFacing )

+	{

+		// We're actually facing away from the Target. Stomp the screen position.

+		iX = -640;

+		iY = -640;

+		return false;

+	}

+

+	return true;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the x & y positions of a world position in HUD space

+//			Returns true if it's onscreen

+//-----------------------------------------------------------------------------

+bool GetVectorInHudSpace( Vector pos, int& iX, int& iY, Vector *vecOffset )

+{

+	Vector screen;

+

+	// Apply the offset, if one was specified

+	if ( vecOffset != NULL )

+		pos += *vecOffset;

+

+	// Transform to HUD space

+	int iFacing = HudTransform( pos, screen );

+	iX = 0.5f * ( 1.0f + screen[0] ) * ScreenWidth();

+	iY = 0.5f * ( 1.0f - screen[1] ) * ScreenHeight();

+

+	// Make sure the player's facing it

+	if ( iFacing )

+	{

+		// We're actually facing away from the Target. Stomp the screen position.

+		iX = -640;

+		iY = -640;

+		return false;

+	}

+

+	return true;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the x & y positions of an entity in screenspace

+//			Returns true if it's onscreen

+//-----------------------------------------------------------------------------

+bool GetTargetInScreenSpace( C_BaseEntity *pTargetEntity, int& iX, int& iY, Vector *vecOffset )

+{

+	return GetVectorInScreenSpace( pTargetEntity->WorldSpaceCenter(), iX, iY, vecOffset );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the x & y positions of an entity in Vgui space

+//			Returns true if it's onscreen

+//-----------------------------------------------------------------------------

+bool GetTargetInHudSpace( C_BaseEntity *pTargetEntity, int& iX, int& iY, Vector *vecOffset )

+{

+	return GetVectorInHudSpace( pTargetEntity->WorldSpaceCenter(), iX, iY, vecOffset );

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+// Input  : *player - 

+//			msg_dest - 

+//			*msg_name - 

+//			*param1 - 

+//			*param2 - 

+//			*param3 - 

+//			*param4 - 

+//-----------------------------------------------------------------------------

+void ClientPrint( C_BasePlayer *player, int msg_dest, const char *msg_name, const char *param1 /*= NULL*/, const char *param2 /*= NULL*/, const char *param3 /*= NULL*/, const char *param4 /*= NULL*/ )

+{

+}

+

+//-----------------------------------------------------------------------------

+// class CFlaggedEntitiesEnum

+//-----------------------------------------------------------------------------

+// enumerate entities that match a set of edict flags into a static array

+class CFlaggedEntitiesEnum : public IPartitionEnumerator

+{

+public:

+	CFlaggedEntitiesEnum( C_BaseEntity **pList, int listMax, int flagMask );

+	// This gets called	by the enumeration methods with each element

+	// that passes the test.

+	virtual IterationRetval_t EnumElement( IHandleEntity *pHandleEntity );

+	

+	int GetCount() { return m_count; }

+	bool AddToList( C_BaseEntity *pEntity );

+	

+private:

+	C_BaseEntity		**m_pList;

+	int				m_listMax;

+	int				m_flagMask;

+	int				m_count;

+};

+

+CFlaggedEntitiesEnum::CFlaggedEntitiesEnum( C_BaseEntity **pList, int listMax, int flagMask )

+{

+	m_pList = pList;

+	m_listMax = listMax;

+	m_flagMask = flagMask;

+	m_count = 0;

+}

+

+bool CFlaggedEntitiesEnum::AddToList( C_BaseEntity *pEntity )

+{

+	if ( m_count >= m_listMax )

+		return false;

+	m_pList[m_count] = pEntity;

+	m_count++;

+	return true;

+}

+

+IterationRetval_t CFlaggedEntitiesEnum::EnumElement( IHandleEntity *pHandleEntity )

+{

+	IClientEntity *pClientEntity = cl_entitylist->GetClientEntityFromHandle( pHandleEntity->GetRefEHandle() );

+	C_BaseEntity *pEntity = pClientEntity ? pClientEntity->GetBaseEntity() : NULL;

+	if ( pEntity )

+	{

+		if ( m_flagMask && !(pEntity->GetFlags() & m_flagMask) )	// Does it meet the criteria?

+			return ITERATION_CONTINUE;

+

+		if ( !AddToList( pEntity ) )

+			return ITERATION_STOP;

+	}

+

+	return ITERATION_CONTINUE;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Pass in an array of pointers and an array size, it fills the array and returns the number inserted

+// Input  : **pList - 

+//			listMax - 

+//			&mins - 

+//			&maxs - 

+//			flagMask - 

+// Output : int

+//-----------------------------------------------------------------------------

+int UTIL_EntitiesInBox( C_BaseEntity **pList, int listMax, const Vector &mins, const Vector &maxs, int flagMask, int partitionMask )

+{

+	CFlaggedEntitiesEnum boxEnum( pList, listMax, flagMask );

+	partition->EnumerateElementsInBox( partitionMask, mins, maxs, false, &boxEnum );

+	

+	return boxEnum.GetCount();

+

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Pass in an array of pointers and an array size, it fills the array and returns the number inserted

+// Input  : **pList - 

+//			listMax - 

+//			&center - 

+//			radius - 

+//			flagMask - 

+// Output : int

+//-----------------------------------------------------------------------------

+int UTIL_EntitiesInSphere( C_BaseEntity **pList, int listMax, const Vector &center, float radius, int flagMask, int partitionMask )

+{

+	CFlaggedEntitiesEnum sphereEnum( pList, listMax, flagMask );

+	partition->EnumerateElementsInSphere( partitionMask, center, radius, false, &sphereEnum );

+

+	return sphereEnum.GetCount();

+

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Pass in an array of pointers and an array size, it fills the array and returns the number inserted

+// Input  : **pList - 

+//			listMax - 

+//			&ray - 

+//			flagMask - 

+// Output : int

+//-----------------------------------------------------------------------------

+int UTIL_EntitiesAlongRay( C_BaseEntity **pList, int listMax, const Ray_t &ray, int flagMask, int partitionMask )

+{

+	CFlaggedEntitiesEnum rayEnum( pList, listMax, flagMask );

+	partition->EnumerateElementsAlongRay( partitionMask, ray, false, &rayEnum );

+

+	return rayEnum.GetCount();

+}

+

+CEntitySphereQuery::CEntitySphereQuery( const Vector &center, float radius, int flagMask, int partitionMask )

+{

+	m_listIndex = 0;

+	m_listCount = UTIL_EntitiesInSphere( m_pList, ARRAYSIZE(m_pList), center, radius, flagMask, partitionMask );

+}

+

+CBaseEntity *CEntitySphereQuery::GetCurrentEntity()

+{

+	if ( m_listIndex < m_listCount )

+		return m_pList[m_listIndex];

+	return NULL;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Slightly modified strtok. Does not modify the input string. Does

+//			not skip over more than one separator at a time. This allows parsing

+//			strings where tokens between separators may or may not be present:

+//

+//			Door01,,,0 would be parsed as "Door01"  ""  ""  "0"

+//			Door01,Open,,0 would be parsed as "Door01"  "Open"  ""  "0"

+//

+// Input  : token - Returns with a token, or zero length if the token was missing.

+//			str - String to parse.

+//			sep - Character to use as separator. UNDONE: allow multiple separator chars

+// Output : Returns a pointer to the next token to be parsed.

+//-----------------------------------------------------------------------------

+const char *nexttoken(char *token, const char *str, char sep)

+{

+	if ((str == NULL) || (*str == '\0'))

+	{

+		*token = '\0';

+		return(NULL);

+	}

+

+	//

+	// Copy everything up to the first separator into the return buffer.

+	// Do not include separators in the return buffer.

+	//

+	while ((*str != sep) && (*str != '\0'))

+	{

+		*token++ = *str++;

+	}

+	*token = '\0';

+

+	//

+	// Advance the pointer unless we hit the end of the input string.

+	//

+	if (*str == '\0')

+	{

+		return(str);

+	}

+

+	return(++str);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+// Input  : font - 

+//			*str - 

+// Output : int

+//-----------------------------------------------------------------------------

+int UTIL_ComputeStringWidth( vgui::HFont& font, const char *str )

+{

+	float pixels = 0;

+	const char *p = str;

+	const char *pAfter = p + 1;

+	const char *pBefore = "\0";

+	while ( *p )

+	{

+#if USE_GETKERNEDCHARWIDTH

+		float wide, abcA;

+		vgui::surface()->GetKernedCharWidth( font, *p, *pBefore, *pAfter, wide, abcA );

+		pixels += wide;

+#else

+		pixels += vgui::surface()->GetCharacterWidth( font, *p );

+#endif

+		pBefore = p;

+		p++;

+		if ( *p )

+			pAfter = p + 1; 

+		else

+			pAfter = "\0";

+	}

+	return (int)ceil(pixels);

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+// Input  : font - 

+//			*str - 

+// Output : int

+//-----------------------------------------------------------------------------

+int UTIL_ComputeStringWidth( vgui::HFont& font, const wchar_t *str )

+{

+	float pixels = 0;

+	const wchar_t *p = str;

+	const wchar_t *pAfter = p + 1;

+	const wchar_t *pBefore = L"\0";

+	while ( *p )

+	{

+#if USE_GETKERNEDCHARWIDTH

+		float wide, abcA;

+		vgui::surface()->GetKernedCharWidth( font, *p, *pBefore, *pAfter, wide, abcA );

+		pixels += wide;

+#else

+		pixels += vgui::surface()->GetCharacterWidth( font, *p );

+#endif

+		pBefore = p;

+		p++;

+		if ( *p )

+			pAfter = p + 1; 

+		else

+			pAfter = L"\0";

+	}

+	return (int)ceil(pixels);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Scans player names

+//Passes the player name to be checked in a KeyValues pointer

+//with the keyname "name"

+// - replaces '&' with '&&' so they will draw in the scoreboard

+// - replaces '#' at the start of the name with '*'

+//-----------------------------------------------------------------------------

+

+void UTIL_MakeSafeName( const char *oldName, char *newName, int newNameBufSize )

+{

+	Assert( newNameBufSize >= sizeof(newName[0]) );

+

+	int newpos = 0;

+

+	for( const char *p=oldName; *p != 0 && newpos < newNameBufSize-1; p++ )

+	{

+		//check for a '#' char at the beginning

+		if( p == oldName && *p == '#' )

+		{

+			newName[newpos] = '*';

+			newpos++;

+		}

+		else if( *p == '%' )

+		{

+			// remove % chars

+			newName[newpos] = '*';

+			newpos++;

+		}

+		else if( *p == '&' )

+		{

+			//insert another & after this one

+			if ( newpos+2 < newNameBufSize )

+			{

+				newName[newpos] = '&';

+				newName[newpos+1] = '&';

+				newpos+=2;

+			}

+		}

+		else

+		{

+			newName[newpos] = *p;

+			newpos++;

+		}

+	}

+	newName[newpos] = 0;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Scans player names and replaces characters that vgui won't

+//          display properly

+// Input  : *oldName - player name to be fixed up

+// Output : *char - static buffer with the safe name

+//-----------------------------------------------------------------------------

+

+const char * UTIL_SafeName( const char *oldName )

+{

+	static char safeName[ MAX_PLAYER_NAME_LENGTH * 2 + 1 ];

+	UTIL_MakeSafeName( oldName, safeName, sizeof( safeName ) );

+

+	return safeName;

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Looks up key bindings for commands and replaces them in string.

+//			%<commandname>% will get replaced with its bound control, e.g. %attack2%

+//			Input buffer sizes are in bytes rather than unicode character count

+//			for consistency with other APIs.  If inbufsizebytes is 0 a NULL-terminated

+//			input buffer is assumed, or you can pass the size of the input buffer if

+//			not NULL-terminated.

+//-----------------------------------------------------------------------------

+void UTIL_ReplaceKeyBindings( const wchar_t *inbuf, int inbufsizebytes, OUT_Z_BYTECAP(outbufsizebytes) wchar_t *outbuf, int outbufsizebytes )

+{

+	Assert( outbufsizebytes >= sizeof(outbuf[0]) );

+	// copy to a new buf if there are vars

+	outbuf[0]=0;

+

+	if ( !inbuf || !inbuf[0] )

+		return;

+

+	int pos = 0;

+	const wchar_t *inbufend = NULL;

+	if ( inbufsizebytes > 0 )

+	{

+		inbufend = inbuf + ( inbufsizebytes / 2 );

+	}

+

+	while( inbuf != inbufend && *inbuf != 0 )

+	{

+		// check for variables

+		if ( *inbuf == '%' )

+		{

+			++inbuf;

+

+			const wchar_t *end = wcschr( inbuf, '%' );

+			if ( end && ( end != inbuf ) ) // make sure we handle %% in the string, which should be treated in the output as %

+			{

+				wchar_t token[64];

+				wcsncpy( token, inbuf, end - inbuf );

+				token[end - inbuf] = 0;

+

+				inbuf += end - inbuf;

+

+				// lookup key names

+				char binding[64];

+				g_pVGuiLocalize->ConvertUnicodeToANSI( token, binding, sizeof(binding) );

+

+				const char *key = engine->Key_LookupBinding( *binding == '+' ? binding + 1 : binding );

+				if ( !key )

+				{

+					key = IsX360() ? "" : "< not bound >";

+				}

+

+				//!! change some key names into better names

+				char friendlyName[64];

+				bool bAddBrackets = false;

+				if ( IsX360() )

+				{

+					if ( !key || !key[0] )

+					{

+						Q_snprintf( friendlyName, sizeof(friendlyName), "#GameUI_None" );

+						bAddBrackets = true;

+					}

+					else

+					{

+						Q_snprintf( friendlyName, sizeof(friendlyName), "#GameUI_KeyNames_%s", key );

+					}

+				}

+				else

+				{

+					Q_snprintf( friendlyName, sizeof(friendlyName), "%s", key );

+				}

+				Q_strupr( friendlyName );

+

+				wchar_t *locName = g_pVGuiLocalize->Find( friendlyName );

+				if ( !locName || wcslen(locName) <= 0)

+				{

+					g_pVGuiLocalize->ConvertANSIToUnicode( friendlyName, token, sizeof(token) );

+

+					outbuf[pos] = '\0';

+					wcscat( outbuf, token );

+					pos += wcslen(token);

+				}

+				else

+				{

+					outbuf[pos] = '\0';

+					if ( bAddBrackets )

+					{

+						wcscat( outbuf, L"[" );

+						pos += 1;

+					}

+					wcscat( outbuf, locName );

+					pos += wcslen(locName);

+					if ( bAddBrackets )

+					{

+						wcscat( outbuf, L"]" );

+						pos += 1;

+					}

+				}

+			}

+			else

+			{

+				outbuf[pos] = *inbuf;

+				++pos;

+			}

+		}

+		else

+		{

+			outbuf[pos] = *inbuf;

+			++pos;

+		}

+

+		++inbuf;

+	}

+

+	outbuf[pos] = '\0';

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+// Input  : *filename - 

+//			*pLength - 

+// Output : byte

+//-----------------------------------------------------------------------------

+byte *UTIL_LoadFileForMe( const char *filename, int *pLength )

+{

+	byte *buffer;

+

+	FileHandle_t file;

+	file = filesystem->Open( filename, "rb", "GAME" );

+	if ( FILESYSTEM_INVALID_HANDLE == file )

+	{

+		if ( pLength ) *pLength = 0;

+		return NULL;

+	}

+

+	int size = filesystem->Size( file );

+	buffer = new byte[ size + 1 ];

+	if ( !buffer )

+	{

+		Warning( "UTIL_LoadFileForMe:  Couldn't allocate buffer of size %i for file %s\n", size + 1, filename );

+		filesystem->Close( file );

+		return NULL;

+	}

+	filesystem->Read( buffer, size, file );

+	filesystem->Close( file );

+

+	// Ensure null terminator

+	buffer[ size ] =0;

+

+	if ( pLength )

+	{

+		*pLength = size;

+	}

+

+	return buffer;

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+// Input  : *buffer - 

+//-----------------------------------------------------------------------------

+void UTIL_FreeFile( byte *buffer )

+{

+	delete[] buffer;

+}

+

+

+//-----------------------------------------------------------------------------

+// Compute distance fade

+//-----------------------------------------------------------------------------

+static unsigned char ComputeDistanceFade( C_BaseEntity *pEntity, float flMinDist, float flMaxDist )

+{

+	if ((flMinDist <= 0) && (flMaxDist <= 0))

+		return 255;

+

+	if( flMinDist > flMaxDist )

+	{

+		::V_swap( flMinDist, flMaxDist );

+	}

+

+	// If a negative value is provided for the min fade distance, then base it off the max.

+	if( flMinDist < 0 )

+	{

+		flMinDist = flMaxDist - 400;

+		if( flMinDist < 0 )

+		{

+			flMinDist = 0;

+		}

+	}

+

+	flMinDist *= flMinDist;

+	flMaxDist *= flMaxDist;

+

+	float flCurrentDistanceSq = CurrentViewOrigin().DistToSqr( pEntity->WorldSpaceCenter() );

+	C_BasePlayer *pLocal = C_BasePlayer::GetLocalPlayer();

+	if ( pLocal )

+	{

+		float flDistFactor = pLocal->GetFOVDistanceAdjustFactor();

+		flCurrentDistanceSq *= flDistFactor * flDistFactor;

+	}

+

+	// If I'm inside the minimum range than don't resort to alpha trickery

+	if ( flCurrentDistanceSq <= flMinDist )

+		return 255;

+

+	if ( flCurrentDistanceSq >= flMaxDist )

+		return 0;

+

+	// NOTE: Because of the if-checks above, flMinDist != flMinDist here

+	float flFalloffFactor = 255.0f / (flMaxDist - flMinDist);

+	int nAlpha = flFalloffFactor * (flMaxDist - flCurrentDistanceSq);

+	return clamp( nAlpha, 0, 255 );

+}

+

+

+//-----------------------------------------------------------------------------

+// Compute fade amount

+//-----------------------------------------------------------------------------

+unsigned char UTIL_ComputeEntityFade( C_BaseEntity *pEntity, float flMinDist, float flMaxDist, float flFadeScale )

+{

+	unsigned char nAlpha = 255;

+

+	// If we're taking devshots, don't fade props at all

+	if ( g_MakingDevShots || cl_leveloverview.GetFloat() > 0 )

+		return 255;

+

+#ifdef _DEBUG

+	if ( r_FadeProps.GetBool() )

+#endif

+	{

+		nAlpha = ComputeDistanceFade( pEntity, flMinDist, flMaxDist );

+

+		// NOTE: This computation for the center + radius is invalid!

+		// The center of the sphere is at the center of the OBB, which is not necessarily

+		// at the render origin. But it should be close enough.

+		Vector vecMins, vecMaxs;

+		pEntity->GetRenderBounds( vecMins, vecMaxs );

+		float flRadius = vecMins.DistTo( vecMaxs ) * 0.5f;

+

+		Vector vecAbsCenter;

+		if ( modelinfo->GetModelType( pEntity->GetModel() ) == mod_brush )

+		{

+			Vector vecRenderMins, vecRenderMaxs;

+			pEntity->GetRenderBoundsWorldspace( vecRenderMins, vecRenderMaxs );

+			VectorAdd( vecRenderMins, vecRenderMaxs, vecAbsCenter );

+			vecAbsCenter *= 0.5f;

+		}

+		else

+		{

+			vecAbsCenter = pEntity->GetRenderOrigin();

+		}

+

+		unsigned char nGlobalAlpha = IsXbox() ? 255 : modelinfo->ComputeLevelScreenFade( vecAbsCenter, flRadius, flFadeScale );

+		unsigned char nDistAlpha;

+

+		if ( !engine->IsLevelMainMenuBackground() )

+		{

+			nDistAlpha = modelinfo->ComputeViewScreenFade( vecAbsCenter, flRadius, flFadeScale );

+		}

+		else

+		{

+			nDistAlpha = 255;

+		}

+

+		if ( nDistAlpha < nGlobalAlpha )

+		{

+			nGlobalAlpha = nDistAlpha;

+		}

+

+		if ( nGlobalAlpha < nAlpha )

+		{

+			nAlpha = nGlobalAlpha;

+		}

+	}

+

+	return nAlpha;

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Given a vector, clamps the scalar axes to MAX_COORD_FLOAT ranges from worldsize.h

+// Input  : *pVecPos - 

+//-----------------------------------------------------------------------------

+void UTIL_BoundToWorldSize( Vector *pVecPos )

+{

+	Assert( pVecPos );

+	for ( int i = 0; i < 3; ++i )

+	{

+		(*pVecPos)[ i ] = clamp( (*pVecPos)[ i ], MIN_COORD_FLOAT, MAX_COORD_FLOAT );

+	}

+}

+

+#ifdef _X360

+#define MAP_KEY_FILE_DIR	"cfg"

+#else

+#define MAP_KEY_FILE_DIR	"media"

+#endif

+

+//-----------------------------------------------------------------------------

+// Purpose: Returns the filename to count map loads in

+//-----------------------------------------------------------------------------

+bool UTIL_GetMapLoadCountFileName( const char *pszFilePrependName, char *pszBuffer, int iBuflen )

+{

+	if ( IsX360() )

+	{

+#ifdef _X360

+		if ( XBX_GetStorageDeviceId() == XBX_INVALID_STORAGE_ID || XBX_GetStorageDeviceId() == XBX_STORAGE_DECLINED )

+			return false;

+#endif

+	}

+

+	if ( IsX360() )

+	{

+		Q_snprintf( pszBuffer, iBuflen, "%s:/%s", MAP_KEY_FILE_DIR, pszFilePrependName );

+	}

+	else

+	{

+		Q_snprintf( pszBuffer, iBuflen, "%s/%s", MAP_KEY_FILE_DIR, pszFilePrependName );

+	}

+

+	return true;

+}

+

+#ifdef TF_CLIENT_DLL

+#define MAP_KEY_FILE "viewed.res"

+#else

+#define MAP_KEY_FILE "mapkeys.res"

+#endif	

+

+void UTIL_IncrementMapKey( const char *pszCustomKey )

+{

+	if ( !pszCustomKey )

+		return;

+

+	char szFilename[ _MAX_PATH ];

+	if ( !UTIL_GetMapLoadCountFileName( MAP_KEY_FILE, szFilename, _MAX_PATH ) )

+		return;

+

+	int iCount = 1;

+

+	KeyValues *kvMapLoadFile = new KeyValues( MAP_KEY_FILE );

+	if ( kvMapLoadFile )

+	{

+		kvMapLoadFile->LoadFromFile( g_pFullFileSystem, szFilename, "MOD" );

+

+		char mapname[MAX_MAP_NAME];

+		Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname) );

+		Q_strlower( mapname );

+

+		// Increment existing, or add a new one

+		KeyValues *pMapKey = kvMapLoadFile->FindKey( mapname );

+		if ( pMapKey )

+		{

+			iCount = pMapKey->GetInt( pszCustomKey, 0 ) + 1;

+			pMapKey->SetInt( pszCustomKey, iCount );

+		}

+		else 

+		{

+			KeyValues *pNewKey = new KeyValues( mapname );

+			if ( pNewKey )

+			{

+				pNewKey->SetString( pszCustomKey, "1" );

+				kvMapLoadFile->AddSubKey( pNewKey );

+			}

+		}

+

+		// Write it out

+

+		// force create this directory incase it doesn't exist

+		filesystem->CreateDirHierarchy( MAP_KEY_FILE_DIR, "MOD");

+

+		CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );

+		kvMapLoadFile->RecursiveSaveToFile( buf, 0 );

+		g_pFullFileSystem->WriteFile( szFilename, "MOD", buf );

+

+		kvMapLoadFile->deleteThis();

+	}

+

+	if ( IsX360() )

+	{

+#ifdef _X360

+		xboxsystem->FinishContainerWrites();

+#endif

+	}

+}

+

+int UTIL_GetMapKeyCount( const char *pszCustomKey )

+{

+	if ( !pszCustomKey )

+		return 0;

+

+	char szFilename[ _MAX_PATH ];

+	if ( !UTIL_GetMapLoadCountFileName( MAP_KEY_FILE, szFilename, _MAX_PATH ) )

+		return 0;

+

+	int iCount = 0;

+

+	KeyValues *kvMapLoadFile = new KeyValues( MAP_KEY_FILE );

+	if ( kvMapLoadFile )

+	{

+		// create an empty file if none exists

+		if ( !g_pFullFileSystem->FileExists( szFilename, "MOD" ) )

+		{

+			// force create this directory incase it doesn't exist

+			filesystem->CreateDirHierarchy( MAP_KEY_FILE_DIR, "MOD");

+

+			CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );

+			g_pFullFileSystem->WriteFile( szFilename, "MOD", buf );

+		}

+

+		kvMapLoadFile->LoadFromFile( g_pFullFileSystem, szFilename, "MOD" );

+

+		char mapname[MAX_MAP_NAME];

+		Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname) );

+		Q_strlower( mapname );

+

+		KeyValues *pMapKey = kvMapLoadFile->FindKey( mapname );

+		if ( pMapKey )

+		{

+			iCount = pMapKey->GetInt( pszCustomKey );

+		}

+

+		kvMapLoadFile->deleteThis();

+	}

+

+	return iCount;

+}

+

+bool UTIL_HasLoadedAnyMap()

+{

+	char szFilename[ _MAX_PATH ];

+	if ( !UTIL_GetMapLoadCountFileName( MAP_KEY_FILE, szFilename, _MAX_PATH ) )

+		return false;

+

+	return g_pFullFileSystem->FileExists( szFilename, "MOD" );

+}