HL2Overcharged/game/client/cdll_util.cpp

//========= 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");
}