ns/releases/3.03/source/mod/AvHHudRender.cpp

//======== (C) Copyright 2001 Charles G. Cleveland All rights reserved. =========
//
// The copyright to the contents herein is the property of Charles G. Cleveland.
// The contents may be used and/or copied only with the written permission of
// Charles G. Cleveland, or in accordance with the terms and conditions stipulated in
// the agreement/contract under which the contents have been supplied.
//
// Purpose: All graphical HUD operations
//
// $Workfile: AvHHudRender.cpp $
// $Date: 2002/10/24 21:31:13 $
//
//-------------------------------------------------------------------------------
// $Log: AvHHudRender.cpp,v $
// Revision 1.25  2002/10/24 21:31:13  Flayra
// - Removed some parts of energy drawing (unneeded clutter)
// - New marine HUD artwork (mainhud.spr)
// - Reworked upgrade drawing to only draw one of a type of upgrade (this was the last thing for v1.0, so it's a bit yucky)
//
// Revision 1.24  2002/10/18 22:20:14  Flayra
// - Fixed alien mass crash when a player left the server
//
// Revision 1.23  2002/10/16 00:59:33  Flayra
// - Added titles for umbra and primal scream
// - Don't draw building circles for entities on the other team (not even for commander)
// - Tried drawing building circles for ghost buildings, but it was confusing
//
// Revision 1.22  2002/10/03 18:56:10  Flayra
// - Moved alien energy to fuser3
// - Changed limits for energy and resources
// - Draw order icons centered around order position
// - Don't draw health rings for opposing teams
//
// Revision 1.21  2002/09/25 20:48:37  Flayra
// - Allow more UI to draw when gestating
// - Only draw text for blip closest to reticle
// - Don't draw stuff when dead
// - Changed order blinking
//
// Revision 1.20  2002/09/23 22:19:58  Flayra
// - Added "paralyzed" indicator
// - HUD element repositioning and refactoring
// - Added alien build circles
// - Added visible motion-tracking sprite to marine HUD
// - Removed special siege sprite
//
// Revision 1.19  2002/09/09 19:57:33  Flayra
// - Fixed black edges in D3D
// - Added blinking "webbed" indicator
// - Refactored UI constants
// - Fixed help icons
// - Added hive info indicator
// - Draw more info as spectator
//
// Revision 1.18  2002/08/31 18:01:01  Flayra
// - Work at VALVe
//
// Revision 1.17  2002/08/16 02:38:44  Flayra
// - Draw "webbed" message
// - Draw health for buildings and players
// - Removed old overwatch code
//
// Revision 1.16  2002/08/09 01:03:36  Flayra
// - Started refactoring for moving variable sprite hole drawing into TriAPI
//
// Revision 1.15  2002/08/02 21:56:54  Flayra
// - Added reticle help, new tooltip system and much nicer order drawing!  Also changed jetpack label to use font, and refactored some sprite names.
//
// Revision 1.14  2002/07/26 23:05:06  Flayra
// - Generate numerical feedback for damage events
//
// Revision 1.13  2002/07/23 17:09:41  Flayra
// - Add ability to centered, translated strings, visually-smooth energy level, new hive sight info, draw parasited message, draw marine upgrades, new method of drawing alien upgrades (overlapping and offset)
//
// Revision 1.12  2002/07/10 14:42:26  Flayra
// - Removed cl_particleinfo drawing differences
//
// Revision 1.11  2002/07/08 17:07:56  Flayra
// - Started to add display of marine upgrade sprite, fixed bug where building indicators aren't displayed after a map change, info_location drawing changes, primal scream color tweak, removed old hive drawing code
//
// Revision 1.10  2002/07/01 21:36:23  Flayra
// - Added primal scream effect, added building ranges for ghost buildings, removed outdated code, removed mapping build sprite, call vidinit() on hive sight sprites
//
// Revision 1.9  2002/06/25 18:03:09  Flayra
// - Added info_locations, removed old weapon help system, added smooth resource swelling, lots of alien UI usability changes, fixed problem with ghost building
//
// Revision 1.8  2002/06/10 19:57:01  Flayra
// - Allow drawing just a portion of a texture when scaling it, draw team hierarchy for soldiers
//
// Revision 1.7  2002/06/03 16:49:20  Flayra
// - Help sprites moved into one animated sprite
//
// Revision 1.6  2002/05/28 17:49:06  Flayra
// - Hive sight sprite changes
//
// Revision 1.5  2002/05/23 02:33:42  Flayra
// - Post-crash checkin.  Restored @Backup from around 4/16.  Contains changes for last four weeks of development.
//
//===============================================================================
#include "mod/AvHHud.h"
#include "cl_dll/hud.h"
#include "cl_dll/cl_util.h"
#include "mod/AvHConstants.h"
#include "mod/AvHClientVariables.h"
#include "mod/AvHSpecials.h"
#include "common/cl_entity.h"
#include "mod/AvHTitles.h"
#include "pm_shared/pm_debug.h"
#include "util/MathUtil.h"
#include "common/r_efx.h"
#include "cl_dll/eventscripts.h"
#include "mod/AvHSprites.h"
#include "ui/UIUtil.h"
#include "types.h"
#include <signal.h>
#include "common/com_model.h"
#include "cl_dll/studio_util.h"
#include "cl_dll/r_studioint.h"
#include "mod/AvHMiniMap.h"
#include "mod/AvHActionButtons.h"
#include "util/STLUtil.h"
#include "mod/AvHSharedUtil.h"
#include "common/event_api.h"
#include "mod/AvHScriptManager.h"
#include "particles/p_vector.h"
#include "particles/papi.h"
#include "mod/AvHParticleSystemManager.h"
#include "mod/AvHTeamHierarchy.h"
#include "mod/AvHClientUtil.h"
#include "mod/AvHTooltip.h"
#include "cl_dll/demo.h"
#include "common/demo_api.h"
#include "mod/AvHHudConstants.h"
#include "mod/AvHPlayerUpgrade.h"
#include "mod/AvHCommanderModeHandler.h"
#include "common/ref_params.h"
#include "mod/AvHTechImpulsePanel.h"
#include "mod/AvHServerVariables.h"
#include "mod/AvHSpriteAPI.h"
#include "mod/AvHParticleEditorHandler.h"

void IN_GetMousePos( int *mx, int *my );

// Externs
extern int					g_iVisibleMouse;
extern playermove_t*		pmove;
extern engine_studio_api_t	IEngineStudio;
extern "C" Vector			gPredictedPlayerOrigin;
extern vec3_t				v_origin;
extern vec3_t				v_angles;

//extern vec3_t gPlayerOrigin;
//extern vec3_t gPlayerAngles;
extern ref_params_s* pDemoRefParams;
extern vec3_t gPlaybackViewOrigin;
extern AvHCommanderModeHandler	gCommanderHandler;
extern AvHParticleEditorHandler	gParticleEditorHandler;
float kD3DErrorValue = 0.01f;


vec3_t GetViewOrigin()
{
	vec3_t theOrigin = v_origin;

	//cl_entity_t* theViewEntity = gEngfuncs.GetLocalPlayer();//gEngfuncs.GetViewModel();
	//if(theViewEntity && /*pDemoRefParams &&*/ gEngfuncs.pDemoAPI->IsPlayingback())
	//{
	//	//theOrigin = pDemoRefParams->vieworg;
	//	theOrigin = theViewEntity->origin;
	//}

	if(gEngfuncs.pDemoAPI->IsPlayingback())
	{
		theOrigin = gPlaybackViewOrigin;
	}

	return theOrigin;
	//	return v_origin;
}

void BuildLerpedPoint(float inXPercentage, float inYPercentage, const Vector& inUpperLeft, const Vector& inUpperRight, const Vector& inLowerLeft, Vector& outPoint)
{
	ASSERT(inXPercentage >= 0.0f);
	ASSERT(inXPercentage <= 1.0f);
	ASSERT(inYPercentage >= 0.0f);
	ASSERT(inYPercentage <= 1.0f);
	
	Vector theUpperLeftToUpperRight;
	VectorSubtract(inUpperRight, inUpperLeft, theUpperLeftToUpperRight);
	
	Vector theUpperLeftToLowerLeft;
	VectorSubtract(inLowerLeft, inUpperLeft, theUpperLeftToLowerLeft);
	
	Vector theXComp;
	VectorScale(theUpperLeftToUpperRight, inXPercentage, theXComp);
	
	Vector theYComp;
	VectorScale(theUpperLeftToLowerLeft, inYPercentage, theYComp);
	
	outPoint = inUpperLeft + theXComp + theYComp;
	
	//float theXPercentage = (outPoint.x - inUpperLeft.x)/(theXComp.x + theYComp.x);
	//float theYPercentage = (outPoint.y - inUpperLeft.y)/(theXComp.y + theYComp.y);
}

void CalculatePlaneInfo(const Vector& inUpperLeft, const Vector& inUpperRight, const Vector& inLowerLeft, float& outD, Vector& outPlaneNormal)
{
	// Cross two vectors for plane normal
	Vector theUpperRightToUpperLeft;
	VectorSubtract(inUpperLeft, inUpperRight, theUpperRightToUpperLeft);
	theUpperRightToUpperLeft = theUpperRightToUpperLeft.Normalize();
	
	Vector theUpperLeftToLowerLeft;
	VectorSubtract(inLowerLeft, inUpperLeft, theUpperLeftToLowerLeft);
	theUpperLeftToLowerLeft = theUpperLeftToLowerLeft.Normalize();

	// Calculate plane normal
	CrossProduct(theUpperRightToUpperLeft, theUpperLeftToLowerLeft, outPlaneNormal);
	
	// Plug in one of the points for D (Ax + By + Cz = -D)
	outD = -(outPlaneNormal.x*inUpperLeft.x + outPlaneNormal.y*inUpperLeft.y + outPlaneNormal.z*inUpperLeft.z);
}

void CalculatePointOnPlane(int inXPos, int inYPos, const Vector& inOrigin, const Vector& inPlaneNormal, float inPlaneD, Vector& outPoint)
{
	Vector theRay;
	CreatePickingRay(inXPos, inYPos, theRay);
	
	// Solve for parametric t
	float thePlaneA = inPlaneNormal.x;
	float thePlaneB = inPlaneNormal.y;
	float thePlaneC = inPlaneNormal.z;
	
	float theT = -(thePlaneA*inOrigin.x + thePlaneB*inOrigin.y + thePlaneC*inOrigin.z + inPlaneD)/(thePlaneA*theRay.x + thePlaneB*theRay.y + thePlaneC*theRay.z);
	
	// Now we have t, solve for the endpoint
	outPoint.x = inOrigin.x + theT*theRay.x;
	outPoint.y = inOrigin.y + theT*theRay.y;
	outPoint.z = inOrigin.z + theT*theRay.z;
}

void ProjectPointFromViewOrigin(int inDistanceToProject, int inScreenX, int inScreenY, Vector& outResult)
{
	Vector theRay;
	CreatePickingRay(inScreenX, inScreenY, theRay);
	
	// project default distance along picking ray
	VectorMA(GetViewOrigin(), inDistanceToProject, theRay, outResult);
}

void AvHHud::DrawTranslatedString(int inX, int inY, const char* inStringToTranslate, bool inCentered, bool inIgnoreUpgrades, bool inTrimExtraInfo)
{
	// Translate
	string theTranslatedText;
	LocalizeString(inStringToTranslate, theTranslatedText);
	if(theTranslatedText[0] == '#')
	{
		theTranslatedText = theTranslatedText.substr(1, theTranslatedText.size());
	}

	if(inTrimExtraInfo)
	{
		AvHCUTrimExtraneousLocationText(theTranslatedText);
	}

	// Draw it
	if(theTranslatedText != "")
	{
		int theR, theG, theB;
		this->GetPrimaryHudColor(theR, theG, theB, inIgnoreUpgrades, false);

		char theCharBuffer[512];
		sprintf(theCharBuffer, "%s", theTranslatedText.c_str());

		if(inCentered)
		{
			this->DrawHudStringCentered(inX, inY, ScreenWidth(), theCharBuffer, theR, theG, theB);
		}
		else
		{
			this->DrawHudString(inX, inY, ScreenWidth(), theCharBuffer, theR, theG, theB);
		}
	}
}

bool gWarpHUDSprites = false;
float gWarpXAmount = 0.0f;
float gWarpYAmount = 0.0f;
float gWarpXSpeed = 0.0f;
float gWarpYSpeed = 0.0f;

void SetWarpHUDSprites(bool inMode, float inWarpXAmount = 0.0f, float inWarpYAmount = 0.0f, float inWarpXSpeed = 0.0f, float inWarpYSpeed = 0.0f)
{
	gWarpHUDSprites = inMode;
	gWarpXAmount = inWarpXAmount;
	gWarpYAmount = inWarpYAmount;
	gWarpXSpeed = inWarpXSpeed;
	gWarpYSpeed = inWarpYSpeed;
}

void DrawScaledHUDSprite(int inSpriteHandle, int inMode, int inRowsInSprite = 1, int inX = 0, int inY = 0, int inWidth = ScreenWidth(), int inHeight = ScreenHeight(), int inForceSpriteFrame = -1, float inStartU = 0.0f, float inStartV = 0.0f, float inEndU = 1.0f, float inEndV = 1.0f, float inRotateUVRadians = 0.0f, bool inUVWrapsOverFrames = false)
{
	// Count number of frames
	int theNumFrames = SPR_Frames(inSpriteHandle);
	
	//int theSpriteWidth = SPR_Width(inSpriteHandle, 0);
	//int theSpriteHeight = SPR_Height(inSpriteHandle, 0);
	//float theAspectRatio = theSpriteWidth/theSpriteHeight;
	
	// ASSERT that the the number of rows makes sense for the number of frames 
	ASSERT(theNumFrames > 0);
	float theFloatNumCols = (float)theNumFrames/inRowsInSprite;
	int theNumCols = (int)theFloatNumCols;
	ASSERT(theNumCols == theFloatNumCols);

	//int theNumRows = theNumFrames/theNumCols;
	int theNumRows = inRowsInSprite;

	// Allow scaling of one frame, without tiling
	if(inForceSpriteFrame != -1)
	{
		theNumRows = theNumCols = 1;
	}

	// Make sure coords are bounded to allowable ranges
	
	inStartU = min(max(inStartU, kD3DErrorValue), 1.0f - kD3DErrorValue);
	inStartV = min(max(inStartV, kD3DErrorValue), 1.0f - kD3DErrorValue);
	inEndU = min(max(inEndU, kD3DErrorValue), 1.0f - kD3DErrorValue);
	inEndV = min(max(inEndV, kD3DErrorValue), 1.0f - kD3DErrorValue);

	if(inRotateUVRadians != 0.0f)
	{
		// Rotate all the UV coords
		vec3_t theAngles(0.0f, 0.0f, inRotateUVRadians);
		float theMatrix[3][4];
		AngleMatrix(theAngles, theMatrix);

		float theRotatedValues[3];

		float theStartValues[3] = {inStartU, inStartV, 0.0f};
		VectorRotate(theStartValues, theMatrix, theRotatedValues);
		inStartU = theRotatedValues[0];
		inStartV = theRotatedValues[1];

		float theEndValues[3] = {inEndU, inEndV, 0.0f};
		VectorRotate(theEndValues, theMatrix, theRotatedValues);
		inEndU = theRotatedValues[0];
		inEndV = theRotatedValues[1];
	}
	
	// Calculate width and height of each quad
	int theQuadScreenWidth = inWidth/theNumCols;
	int theQuadScreenHeight = inHeight/theNumRows;
	
	//Vector thePickRay;
	//int theHalfWidth = ScreenWidth/2;
	//int theHalfHeight = ScreenHeight/2;
	//CreatePickingRay(theHalfWidth, theHalfHeight, thePickRay);
	
	//char gDebugMessage[256];
	//sprintf(gDebugMessage, "(%d, %d): %f, %f, %f", theHalfWidth, theHalfHeight, thePickRay.x, thePickRay.y, thePickRay.z);
	//CenterPrint(gDebugMessage);
	
	//float theRenderOrigin[3];
	//pVector theUp;
	//pVector theRight;
	//pVector theNormal;
	//IEngineStudio.GetViewInfo(theRenderOrigin, (float*)&theUp, (float*)&theRight, (float*)&theNormal);

	//Demo_WriteVector(TYPE_VIEWANGLES, v_angles);
	//Demo_WriteVector(TYPE_VIEWORIGIN, v_origin);
	
	vec3_t theRenderOrigin;
	VectorCopy(GetViewOrigin(), theRenderOrigin);

	vec3_t theForward, theRight, theUp;
	AngleVectors(v_angles, theForward, theRight, theUp);
	
	Vector theRenderOriginVector;
	theRenderOriginVector.x = theRenderOrigin[0];
	theRenderOriginVector.y = theRenderOrigin[1];
	theRenderOriginVector.z = theRenderOrigin[2];

	// This is the smallest value that displays and it still clips with the view model a little
	const int kDistanceToProject = 10;
	
	// create picking ray for upper left of quad
	Vector theUpperLeftRay;
	//CreatePickingRay(inX, inY, theUpperLeftRay);
	CreatePickingRay(0, 0, theUpperLeftRay);
	
	// create picking ray for lower left of quad
	Vector theLowerLeftRay;
	//CreatePickingRay(inX, inY+inHeight, theLowerLeftRay);
	CreatePickingRay(0, ScreenHeight(), theLowerLeftRay);
	
	// create picking ray for upper right of quad
	Vector theUpperRightRay;
	//CreatePickingRay(inX+inWidth, inY, theUpperRightRay);
	CreatePickingRay(ScreenWidth(), 0, theUpperRightRay);
	
	// project default distance along picking ray
	Vector theUpperLeftWorldPos;
	VectorMA(theRenderOrigin, kDistanceToProject, theUpperLeftRay, theUpperLeftWorldPos);
	
	Vector theUpperRightWorldPos;
	VectorMA(theRenderOrigin, kDistanceToProject, theUpperRightRay, theUpperRightWorldPos);

	Vector theLowerLeftWorldPos;
	VectorMA(theRenderOrigin, kDistanceToProject, theLowerLeftRay, theLowerLeftWorldPos);

	// Create formula for plane
	float thePlaneD;
	Vector thePlaneNormal;
	CalculatePlaneInfo(theUpperLeftWorldPos, theUpperRightWorldPos, theLowerLeftWorldPos, thePlaneD, thePlaneNormal);
	
	// loop through screen height
	int theCurrentFrame = 0;
	
	// Allow drawing of just one frame
	if(inForceSpriteFrame != -1)
	{
		theCurrentFrame = inForceSpriteFrame;
	}

	for(int i = 0; i < theNumRows; i++)
	{
		// loop through screen width
		for(int j = 0; j < theNumCols; j++)
		{
			// draw quad
			gEngfuncs.pTriAPI->RenderMode(inMode);
			gEngfuncs.pTriAPI->CullFace(TRI_NONE);
			//gEngfuncs.pTriAPI->Brightness(1);
			
			if(gEngfuncs.pTriAPI->SpriteTexture((struct model_s*)gEngfuncs.GetSpritePointer(inSpriteHandle), theCurrentFrame))
			{
				gEngfuncs.pTriAPI->Begin( TRI_TRIANGLE_STRIP );
				//gEngfuncs.pTriAPI->Color4f(1.0f, 1.0f, 1.0f, 1.0f);

				bool theIsFirstRow = (i == 0);
				bool theIsFirstCol = (j == 0);
				bool theIsLastRow = (i == (theNumRows-1));
				bool theIsLastCol = (j == (theNumCols-1));

				float theStartU = inStartU;
				float theStartV = inStartV;
				float theEndU = inEndU;
				float theEndV = inEndV;

				if(inUVWrapsOverFrames)
				{
					if((theNumCols > 1) && !theIsFirstCol)
					{
						theStartU = 0.0f;
					}
					if((theNumRows > 1) && !theIsFirstRow)
					{
						theStartV = 0.0f;
					}
					if((theNumCols > 1) && !theIsLastCol)
					{
						theEndU = 1.0f;
					}
					if((theNumRows > 1) && !theIsLastRow)
					{
						theEndV = 1.0f;
					}
				}

				// Optionally warp XY coords using current time
				int theWarpXStartAmount = 0;
				int theWarpYStartAmount = 0;
				int theWarpXEndAmount = 0;
				int theWarpYEndAmount = 0;

				if(gWarpHUDSprites)
				{
					float theCurrentTime = gHUD.GetTimeOfLastUpdate();
					float theNormXAmount = theCurrentTime*gWarpXSpeed - (int)(theCurrentTime*gWarpXSpeed); // Get fractional part of second
					float theNormYAmount = theCurrentTime*gWarpYSpeed - (int)(theCurrentTime*gWarpYSpeed);
					float theSinusoidalNormXAmount = cos(theNormXAmount*2.0f*M_PI);
					float theSinusoidalNormYAmount = sin(theNormYAmount*2.0f*M_PI);
					float theXAmount = theSinusoidalNormXAmount*gWarpXAmount;// - gWarpUAmount/2.0f;
					float theYAmount = theSinusoidalNormYAmount*gWarpYAmount;// - gWarpVAmount/2.0f;

					if(!theIsFirstCol)
					{
						theWarpXStartAmount = theXAmount*ScreenWidth();
					}
					if(!theIsLastCol)
					{
						theWarpXEndAmount = theXAmount*ScreenWidth();
					}
					if(!theIsFirstRow)
					{
						theWarpYStartAmount = theYAmount*ScreenHeight();
					}
					if(!theIsLastRow)
					{
						theWarpYEndAmount = theYAmount*ScreenHeight();
					}
				}
	
				// Compensate for gamma
				float theGammaSlope = gHUD.GetGammaSlope();
				float theColorComponent = 1.0f/theGammaSlope;
				gEngfuncs.pTriAPI->Color4f(theColorComponent, theColorComponent, theColorComponent, 1.0f);
				
				Vector thePoint;
	
				//float theMinXPercentage = (float)j/theNumCols;
				//float theMaxXPercentage = (float)(j+1)/theNumCols;
	
				//float theMinYPercentage = (float)i/theNumRows;
				//float theMaxYPercentage = (float)(i+1)/theNumRows;
	
				int theMinXPos = inX + ((float)j/theNumCols)*inWidth + theWarpXStartAmount;
				int theMinYPos = inY + ((float)i/theNumRows)*inHeight + theWarpYStartAmount;
	
				int theMaxXPos = inX + ((float)(j+1)/theNumCols)*inWidth + theWarpXEndAmount;
				int theMaxYPos = inY + ((float)(i+1)/theNumRows)*inHeight + theWarpYEndAmount;
				
				// Lower left
				Vector thePointOne;
				//BuildLerpedPoint(theMinXPercentage, theMaxYPercentage, theUpperLeftWorldPos, theUpperRightWorldPos, theLowerLeftWorldPos, thePointOne);
				CalculatePointOnPlane(theMinXPos, theMaxYPos, theRenderOriginVector, thePlaneNormal, thePlaneD, thePointOne);
				float theU = theStartU;
				float theV = theEndV;
				gEngfuncs.pTriAPI->TexCoord2f(theU, theV);// 0,1
				gEngfuncs.pTriAPI->Vertex3fv((float*)&thePointOne);
				
				// Upper left
				Vector thePointTwo;
				//BuildLerpedPoint(theMinXPercentage, theMinYPercentage, theUpperLeftWorldPos, theUpperRightWorldPos, theLowerLeftWorldPos, thePointTwo);
				CalculatePointOnPlane(theMinXPos, theMinYPos, theRenderOriginVector, thePlaneNormal, thePlaneD, thePointTwo);
				theU = theStartU;
				theV = theStartV;
				//gEngfuncs.pTriAPI->TexCoord2f(inStartU, inStartV); // 0,0
				gEngfuncs.pTriAPI->TexCoord2f(theU, theV);// 0,1
				gEngfuncs.pTriAPI->Vertex3fv((float*)&thePointTwo);
				
				// Lower right
				Vector thePointFour;
				//BuildLerpedPoint(theMaxXPercentage, theMaxYPercentage, theUpperLeftWorldPos, theUpperRightWorldPos, theLowerLeftWorldPos, thePointFour);
				CalculatePointOnPlane(theMaxXPos, theMaxYPos, theRenderOriginVector, thePlaneNormal, thePlaneD, thePointFour);
				theU = theEndU;
				theV = theEndV;
				//gEngfuncs.pTriAPI->TexCoord2f(inEndU, inEndV);// 1,1
				gEngfuncs.pTriAPI->TexCoord2f(theU, theV);// 0,1
				gEngfuncs.pTriAPI->Vertex3fv((float*)&thePointFour);

				// Upper right
				Vector thePointThree;
				//BuildLerpedPoint(theMaxXPercentage, theMinYPercentage, theUpperLeftWorldPos, theUpperRightWorldPos, theLowerLeftWorldPos, thePointThree);
				CalculatePointOnPlane(theMaxXPos, theMinYPos, theRenderOriginVector, thePlaneNormal, thePlaneD, thePointThree);
				theU = theEndU;
				theV = theStartV;
				//gEngfuncs.pTriAPI->TexCoord2f(inEndU, inStartV); // 1,0
				gEngfuncs.pTriAPI->TexCoord2f(theU, theV);// 0,1
				gEngfuncs.pTriAPI->Vertex3fv((float*)&thePointThree);
	
				gEngfuncs.pTriAPI->End();
			}
	
			// Increment frame
			theCurrentFrame++;
			
			// Allow drawing of just one frame
			if(inForceSpriteFrame != -1)
			{
				theCurrentFrame = inForceSpriteFrame;
			}
			
			// increment current x and y
			//theCurrentScreenX += theQuadScreenWidth;
		}
		//theCurrentScreenX = 0;
		//theCurrentScreenY += theQuadScreenHeight;
	}
}

void DrawVariableScaledHUDSprite(float inFactor, int inSpriteHandle, int inMode, int inX, int inY, int inWidth, int inHeight)
{
	// Draw as two scaled sprites, one for the level and one for the "empty" level
	// Assumes that sprite has two frames, with the empty level being frame 0 and the full frame being frame 1
	int theWidth = inWidth;
	float theStartU = 0.0f;
	float theEndU = 1.0f;

	int theHeight = inFactor*inHeight;
	float theStartV = 1.0f - inFactor;
	float theEndV = 1.0f;
	int theX = inX;
	int theY = inY + inHeight - theHeight;
	DrawScaledHUDSprite(inSpriteHandle, inMode, 1, theX, theY, theWidth, theHeight, 1, theStartU, theStartV, theEndU, theEndV);

	// Draw background
	theHeight = (1.0f - inFactor)*inHeight;
	theY = inY;
	theStartV = 0.0f;
	theEndV = 1.0f - inFactor;
	DrawScaledHUDSprite(inSpriteHandle, inMode, 1, theX, theY, theWidth, theHeight, 0, theStartU, theStartV, theEndU, theEndV);
}

void DrawSpriteOnGroundAtPoint(vec3_t inOrigin, int inRadius, HSPRITE inSprite, int inRenderMode = kRenderNormal, int inFrame = 0, float inAlpha = 1.0f)
{
	if(gEngfuncs.pTriAPI->SpriteTexture((struct model_s *)gEngfuncs.GetSpritePointer(inSprite), inFrame))
	{
		gEngfuncs.pTriAPI->CullFace(TRI_NONE);
		
		gEngfuncs.pTriAPI->RenderMode(inRenderMode);
		
		//gEngfuncs.pTriAPI->RenderMode( kRenderTransTexture );
		//gEngfuncs.pTriAPI->Color4f(inR, inG, inB, inA);
		
		gEngfuncs.pTriAPI->Begin(TRI_TRIANGLE_STRIP);
		
		// Draw one quad
		vec3_t thePoint = inOrigin;
		
		float theGammaSlope = gHUD.GetGammaSlope();
		ASSERT(theGammaSlope > 0.0f);
		float theColorComponent = 1.0f/theGammaSlope;
		
		gEngfuncs.pTriAPI->Color4f(theColorComponent, theColorComponent, theColorComponent, inAlpha);
		gEngfuncs.pTriAPI->Brightness(1.6f);
		
		thePoint[0] = inOrigin[0] - inRadius;
		thePoint[1] = inOrigin[1] - inRadius;
		gEngfuncs.pTriAPI->TexCoord2f(0, 0);
		gEngfuncs.pTriAPI->Vertex3f(thePoint[0], thePoint[1], thePoint[2]);
		
		thePoint[0] = inOrigin[0] - inRadius;
		thePoint[1] = inOrigin[1] + inRadius;
		gEngfuncs.pTriAPI->TexCoord2f(0, 1);
		gEngfuncs.pTriAPI->Vertex3f(thePoint[0], thePoint[1], thePoint[2]);

		thePoint[0] = inOrigin[0] + inRadius;
		thePoint[1] = inOrigin[1] - inRadius;
		gEngfuncs.pTriAPI->TexCoord2f(1, 0);
		gEngfuncs.pTriAPI->Vertex3f(thePoint[0], thePoint[1], thePoint[2]);
		
		thePoint[0] = inOrigin[0] + inRadius;
		thePoint[1] = inOrigin[1] + inRadius;
		gEngfuncs.pTriAPI->TexCoord2f(1, 1);
		gEngfuncs.pTriAPI->Vertex3f(thePoint[0], thePoint[1], thePoint[2]);
		
		gEngfuncs.pTriAPI->End();
		gEngfuncs.pTriAPI->RenderMode( kRenderNormal );
	}
}

void AvHHud::DrawPlayerNames()
{
	bool inReadyRoom = false;//(this->GetPlayMode() == PLAYMODE_READYROOM);
	bool inTopDownMode = this->GetInTopDownMode();

	if(inTopDownMode || inReadyRoom /*&& !gEngfuncs.pDemoAPI->IsPlayingback()*/)
	{
		cl_entity_s* theLocalPlayer = gEngfuncs.GetLocalPlayer();
		if(theLocalPlayer)
		{
			int theLocalPlayerIndex = theLocalPlayer->index;

			// Loop through all players
			for(int i = 1; i <= kMaxPlayers; i++)
			{
				if((i != theLocalPlayerIndex) && AvHCUGetIsEntityInPVSAndVisible(i))
				{
					cl_entity_s* theCurrentPlayer = gEngfuncs.GetEntityByIndex(i);
					bool theDrawEntity = (inReadyRoom || (theCurrentPlayer && theCurrentPlayer->player && (AvHTeamNumber(theCurrentPlayer->curstate.team) == this->GetHUDTeam()) && (i != theLocalPlayerIndex)) );
					if(theDrawEntity)
					{
						string theEntityName;
						bool theIsEnemy;
						if(this->GetEntityInfoString(i, theEntityName, theIsEnemy))
						{
							vec3_t theEntityOrigin;
							VectorCopy(theCurrentPlayer->curstate.origin, theEntityOrigin);
							theEntityOrigin.z += AvHCUGetIconHeightForPlayer((AvHUser3)theCurrentPlayer->curstate.iuser3);
						
							// If they are on screen
							Vector theScreenPos;
							if(AvHCUWorldToScreen(theEntityOrigin, (float*)&theScreenPos))
							{
								// Set color
								int theR, theG, theB;
								this->GetPrimaryHudColor(theR, theG, theB, true, false);
						
								// If selected, draw in different color
								if(inTopDownMode)
								{
									bool theIsSelected = (std::find(this->mSelected.begin(), this->mSelected.end(), i) != this->mSelected.end());
									if(theIsSelected)
									{
										// Selected color
										UnpackRGB(theR, theG, theB, RGB_MARINE_SELECTED);
									
										if(GetHasUpgrade(theCurrentPlayer->curstate.iuser4, MASK_PARASITED))
										{
											string thePrePendString;
											LocalizeString(kParasited, thePrePendString);
											theEntityName = string(theEntityName + " (" + thePrePendString + ")");
									
											// Set color to parasited color
											UnpackRGB(theR, theG, theB, RGB_MARINE_PARASITED);
										}
									}
								}
						
								// Set text color draw in different color
								this->mTopDownPlayerNameMessage.SetRGB(theR, theG, theB);
								this->mTopDownPlayerNameMessage.SetIgnoreFadeForLifetime(true);
						
								// Set the message info and draw it
								this->mTopDownPlayerNameMessage.SetText(theEntityName);
						
								// Set position
								Vector theNormPos;
								float theNormX = theScreenPos.x/ScreenWidth();
								
								int theBoxHeight = this->mTopDownPlayerNameMessage.GetScreenHeight();
								float theNormY = (theScreenPos.y - theBoxHeight)/ScreenHeight();
						
								if((inTopDownMode && !this->GetIsRegionBlockedByUI(theNormX, theNormY)) || inReadyRoom)
								{
									this->mTopDownPlayerNameMessage.SetNormalizedScreenX(theNormX);
									this->mTopDownPlayerNameMessage.SetNormalizedScreenY(theNormY);
									this->mTopDownPlayerNameMessage.SetCentered(true);
									this->mTopDownPlayerNameMessage.SetNormalizedMaxWidth(kReticleMaxWidth);
									this->mTopDownPlayerNameMessage.Draw();
								}
							}
						}
					}
				}
			}
		}
	}
}

//bool AvHHud::ChopStringOfMaxScreenWidth(int inMaxScreenWidth, string& ioBaseString, string& outChoppedString)
//{
//	// Loop backwards through the string, until we get a string that fits in this screen width
//	int theCurrentLength = ioBaseString.length();
//	int theMaxLength = ioBaseString.length();
//	bool theSuccess = false;
//
//	while(!theSuccess)
//	{
//		string theCurrentString = ioBaseString.substr(0, theCurrentLength);
//		int theCurrentStringScreenWidth = this->GetHudStringWidth(theCurrentString.c_str());
//		if(theCurrentStringScreenWidth <= inMaxScreenWidth)
//		{
//			// Look for a word to break the line
//			while((theCurrentLength > 0) && !theSuccess)
//			{
//				char theCurrentChar = ioBaseString[theCurrentLength-1];
//				if((theCurrentChar == ' ') || (theCurrentLength == theMaxLength))
//				{
//					outChoppedString = ioBaseString.substr(0, theCurrentLength);
//					ioBaseString = ioBaseString.substr(theCurrentLength, ioBaseString.length() - theCurrentLength);
//					theSuccess = true;
//					break;
//				}
//				else
//				{
//					theCurrentLength--;
//				}
//			}
//		}
//		else
//		{
//			theCurrentLength--;
//		}
//	}
//
//	return theSuccess;
//}

void AvHHud::DrawReticleInfo()
{
	this->mReticleMessage.Draw();
	
	//	if(this->mReticleInfoText != "")
	//	{
	//		const float kMaxWidth = .3f;
	//		int kMaxScreenWidth = kMaxWidth*ScreenWidth;
	//
	//		StringList theStringList;
	//		string theHelpString = this->mReticleInfoText;
	//
	//		do
	//		{
	//			string theNewString;
	//			if(ChopStringOfMaxScreenWidth(kMaxScreenWidth, theHelpString, theNewString))
	//			{
	//				theStringList.push_back(theNewString);
	//			}
	//			else
	//			{
	//				theHelpString = "";
	//			}
	//		} 
	//		while(theHelpString != "");
	//		
	//		// For each line, if the line contains any special markers, move them to their own lines
	//		
	//		// Compute max width of all the strings, add some extra for a frame
	//		int theBoxWidth = 0;
	//		StringList::iterator theStringListIter;
	//		for(theStringListIter = theStringList.begin(); theStringListIter != theStringList.end(); theStringListIter++)
	//		{
	//			int theCurrentScreenWidth = this->GetHudStringWidth(theStringListIter->c_str());
	//			theBoxWidth = max(theBoxWidth, theCurrentScreenWidth);
	//		}
	//		int theLineHSpacing = .01f*ScreenWidth;
	//		theBoxWidth += 2*theLineHSpacing;
	//
	//		// Compute max height needed to contain all the strings, add some extra for a frame
	//		int theLineVSpacing = .01f*ScreenHeight();
	//		int theLineHeight = this->GetHudStringHeight();
	//		int theBoxHeight = 2*theLineVSpacing + (theStringList.size()*theLineHeight);
	//
	//		int theFillStartX = this->mReticleInfoScreenX;
	//		int theFillStartY = this->mReticleInfoScreenY;
	//
	//		theFillStartX -= theBoxWidth/2;	
	//		theFillStartY -= theBoxHeight/2;
	//
	//		// Draw nice border and shaded background
	//		const float kReticleInfoMaxAlpha = 25;
	//		float theNormalizedAlpha = this->mReticleInfoColorA/255;
	//		int theAlphaComponent = theNormalizedAlpha*kReticleInfoMaxAlpha;
	//
	//		FillRGBA(theFillStartX, theFillStartY, theBoxWidth, theBoxHeight, this->mReticleInfoColorR, this->mReticleInfoColorG, this->mReticleInfoColorB, theAlphaComponent);
	//		vguiSimpleBox(theFillStartX, theFillStartY, theFillStartX + theBoxWidth, theFillStartY + theBoxHeight, this->mReticleInfoColorR, this->mReticleInfoColorG, this->mReticleInfoColorB, theAlphaComponent);
	//
	//		// Now draw each line, non-centered, left-aligned
	//		int theLineNumber = 0;
	//		for(theStringListIter = theStringList.begin(); theStringListIter != theStringList.end(); theStringListIter++)
	//		{
	//			int theR = this->mReticleInfoColorR;
	//			int theG = this->mReticleInfoColorG;
	//			int theB = this->mReticleInfoColorB;
	//
	//			// If the line starts with a marker, draw it in a special color
	//			//string theDamageMarker(kDamageMarker);
	//			//if(theStringListIter->substr(0, theDamageMarker.length()) == theDamageMarker)
	//			//{
	//			//	// Draw string in yellow
	//			//	theR = theG = 255;
	//			//	theB = 25;
	//			//}
	//
	//			int theBaseY = theFillStartY + theLineVSpacing + theLineNumber*theLineHeight;
	//			
	//			// Draw message (DrawHudStringCentered only centers in x)
	//			this->DrawHudString(theFillStartX + theLineHSpacing, theBaseY /*- theLineHeight/2*/, ScreenWidth, theStringListIter->c_str(), theR*theNormalizedAlpha, theG*theNormalizedAlpha, theB*theNormalizedAlpha);
	//
	//			theLineNumber++;
	//		}
	//	}
}

void AvHHud::DrawToolTips()
{
	if(!gEngfuncs.pDemoAPI->IsPlayingback())
	{
		this->mHelpMessage.Draw();
		
		// Draw each one
		for(AvHTooltipListType::iterator theIter = this->mTooltips.begin(); theIter != this->mTooltips.end(); theIter++)
		{
			int theR, theG, theB;
			this->GetPrimaryHudColor(theR, theG, theB, true, false);
			theIter->SetRGB(theR, theG, theB);
			theIter->Draw();
		}
	}
}

void AvHHud::DrawWorldSprite(int inSpriteHandle, int inRenderMode, vec3_t inWorldPosition, int inFrame, float inWorldSize)
{
	vec3_t theUpperLeft;
	vec3_t theLowerRight;

	vec3_t theForward, theRight, theUp;
	AngleVectors(v_angles, theForward, theRight, theUp);

	vec3_t theToUpperLeft;
	VectorAdd(-theRight, theUp, theToUpperLeft);
	VectorNormalize(theToUpperLeft);

	VectorMA(inWorldPosition, inWorldSize, theToUpperLeft, theUpperLeft);

	vec3_t theToLowerRight;
	VectorAdd(theRight, -theUp, theToLowerRight);
	VectorNormalize(theToLowerRight);

	VectorMA(inWorldPosition, inWorldSize, theToLowerRight, theLowerRight);

	vec3_t theScreenUpperLeft;
	vec3_t theScreenLowerRight;

	// World to screen returns true if the world pos is behind the viewer
	if(!gEngfuncs.pTriAPI->WorldToScreen((float*)theUpperLeft, (float*)theScreenUpperLeft))
	{
		if(!gEngfuncs.pTriAPI->WorldToScreen((float*)theLowerRight, (float*)theScreenLowerRight))
		{
			// If the sprite is behind you, push it to the bottom or top of the screen
//			cl_entity_t* theLocalPlayer = gEngfuncs.GetLocalPlayer();
//			ASSERT(theLocalPlayer);
//			
//			vec3_t theDirectionToOrder;
//			VectorSubtract(inWorldPosition, theLocalPlayer->origin, theDirectionToOrder);
			
			//		float theDotProduct = DotProduct(theDirectionToOrder, theLocalPlayer->angles);
			//		if(theDotProduct < 0)
			//		{
			//			if(theWorldPos.z < theLocalPlayer->origin.z)
			//			{
			//				theY = theScreenHeight - theSpriteHeight - theScreenBorder;
			//			}
			//			else
			//			{
			//				theY = theScreenBorder;
			//			}
			
			//			vec3_t theCrossProduct;
			//			theCrossProduct = CrossProduct(theLocalPlayer->angles, theDirectionToOrder);
			//
			//			// It's to our right
			//			if(theCrossProduct.z > 0)
			//			{
			//				theX = theScreenWidth - theSpriteWidth - theScreenBorder;
			//			}
			//			else
			//			{
			//				theX = theScreenBorder;
			//			}
			//		}
			
//			float theDistanceToLocation = (float)VectorDistance(inWorldPosition, theLocalPlayer->origin);
//			const theMaxDistance = 1500;
//			float theEffectiveDistance = min(theDistanceToLocation, theMaxDistance);
//			const int theMinColorComponent = 100;
//			int theColorComponent = max(theMinColorComponent, 255 - ((theEffectiveDistance/theMaxDistance)*255));
			
			//SPR_Set(inSpriteHandle, theColorComponent, theColorComponent, theColorComponent);
			////SPR_DrawHoles((int)0, theX, theY, NULL);
			//if(inRenderMode == kRenderNormal)
			//{
			//	SPR_Draw(inFrame, theX, theY, NULL);
			//}
			//else if(inRenderMode == kRenderTransAdd)
			//{
			//	SPR_DrawAdditive(inFrame, theX, theY, NULL);
			//}

			float theScreenX = XPROJECT(theScreenUpperLeft.x);
			float theScreenY = YPROJECT(theScreenUpperLeft.y);
			float theWidth = XPROJECT(theScreenLowerRight.x) - theScreenX;
			float theHeight = YPROJECT(theScreenLowerRight.y) - theScreenY;

            //DrawScaledHUDSprite(inSpriteHandle, inRenderMode, 1, theScreenX, theScreenY, theWidth, theHeight, inFrame);
            
            AvHSpriteSetColor(1, 1, 1);
            AvHSpriteSetRenderMode(inRenderMode);
            AvHSpriteDraw(inSpriteHandle, inFrame, theScreenX, theScreenY, theScreenX + theWidth, theScreenY + theHeight, 0, 0, 1, 1);
            

            
		}
	}
}

void AvHHud::DrawOrderIcon(const AvHOrder& inOrder)
{
	if(this->mOrderSprite)
	{
		int theNumFrames = SPR_Frames(this->mOrderSprite);
		int theCurrentFrame = this->GetFrameForOrderType(inOrder.GetOrderType());
		
		if((theCurrentFrame >= 0) && (theCurrentFrame < theNumFrames))
		{
			vec3_t theWorldPos;
			inOrder.GetLocation(theWorldPos);
			if ( inOrder.GetOrderType() == ORDERTYPET_ATTACK  ) {
				theWorldPos[2]+=kAttackOrderZOffset;
			}

			// Draw icon above pos, text below
			theWorldPos.z += BALANCE_FVAR(kOrderIconDrawSize);
			
			this->DrawWorldSprite(this->mOrderSprite, kRenderTransAdd, theWorldPos, theCurrentFrame, BALANCE_FVAR(kOrderIconDrawSize));
			
			// If the order is our own order, draw the order indicator around it
			if((this->GetHUDPlayMode() == PLAYMODE_PLAYING) && this->GetIsMarine() && !this->GetInTopDownMode())
			{
				this->DrawWorldSprite(this->mMarineOrderIndicator, kRenderTransAdd, theWorldPos, 0, BALANCE_FVAR(kOrderIconDrawSize));
				//DrawScaledHUDSprite(theSpriteHandle, kRenderNormal, 1, thePosX, thePosY, theWidth, theHeight, theFrame, theStartU, theStartV, theEndU, theEndV);
				
			}
		}
		else
		{
			int a = 0;
		}
	}
}

void AvHHud::DrawOrderText(const AvHOrder& inOrder)
{
	int theIndex = (int)(inOrder.GetOrderType());

	// Now draw text describing the waypoint
	string theTitle;
	sprintf(theTitle, "Order%d", theIndex);
	
	string theLocalizedTitle(" ");
	LocalizeString(theTitle.c_str(), theLocalizedTitle);

	if((theIndex == ORDERTYPET_BUILD) || (theIndex == ORDERTYPET_GUARD) || (theIndex == ORDERTYPET_GET))
	{
		AvHUser3 theUser3 = inOrder.GetTargetUser3Type();
		string theUser3Name;
		if(this->GetTranslatedUser3Name(theUser3, theUser3Name))
		{
			// "Get %s" -> "Get heavy machine gun"
			// "Guard %s -> "Guard soldier"
			// "Build %s" -> "Build sentry turret"
			string theTitleWithTarget;
			sprintf(theTitleWithTarget, theLocalizedTitle.c_str(), theUser3Name.c_str());
			theLocalizedTitle = theTitleWithTarget;
		}
	}

	vec3_t theOrderLocation;
	inOrder.GetLocation(theOrderLocation);
	
	// Because the commander may not have information about the players heading to this waypoint (outside of his PVS), we
	// can't draw a range for the commander
	string theRangeDisplayString;
	if(!this->GetInTopDownMode())
	{
		float theDistanceToWaypoint = VectorDistance(gPredictedPlayerOrigin, theOrderLocation);
		int theVisibleDistance = max(1, (int)theDistanceToWaypoint/100);
		
		string theVisibleUnits;
		if(LocalizeString("Range", theVisibleUnits))
		{
			sprintf(theRangeDisplayString, theVisibleUnits.c_str(), theVisibleDistance);
		}
	}
	
	string theLocationOfOrder;
	theLocationOfOrder = this->GetNameOfLocation(theOrderLocation);

	// It's OK if this fails, as only official maps will have these translated
	string theTranslatedLocation = theLocationOfOrder;
	LocalizeString(theLocationOfOrder.c_str(), theTranslatedLocation);
	
	Vector theScreenPos;
	if(AvHCUWorldToScreen((float*)theOrderLocation, (float*)&theScreenPos))
	{
		float theNormX = theScreenPos.x/ScreenWidth();
		float theNormY = theScreenPos.y/ScreenHeight();

		if(!this->GetIsRegionBlockedByUI(theNormX, theNormY))
		{
			int theR, theG, theB;
			this->GetPrimaryHudColor(theR, theG, theB, false, false);
			
			string theFirstLine = theLocalizedTitle;
			if(theRangeDisplayString != "")
			{
				theFirstLine += string(" : ") + theRangeDisplayString;
			}
			
			// Draw order (icon above world position, text below it)
			int theBaseX = theScreenPos.x;
			int theBaseY = theScreenPos.y;
			int theStringHeight = this->GetHudStringHeight();
			this->DrawHudStringCentered(theBaseX, theBaseY + theStringHeight, ScreenWidth(), theFirstLine.c_str(), theR, theG, theB);
			
			// Draw location below it
			this->DrawHudStringCentered(theBaseX, theBaseY + 2*theStringHeight, ScreenWidth(), theTranslatedLocation.c_str(), theR, theG, theB);
		}
		else
		{
			int a = 0;
		}
	}
}

void AvHHud::DrawOrders()
{
	if(1/*!this->mIsRenderingSelectionView*/)
	{
		// Draw them blinking for soldiers, but always for commanders
		float theFractionalLastUpdate = this->mTimeOfLastUpdate - (int)this->mTimeOfLastUpdate;
		if((theFractionalLastUpdate > .25f) || (this->GetHUDUser3() == AVH_USER3_COMMANDER_PLAYER))
		{
			OrderListType theOrders = this->GetOrderList();
			
			EntityListType theDrawPlayerList = this->GetDrawPlayerOrders();
			
			// Run through the order list type
			for(OrderListType::iterator theIter = theOrders.begin(); theIter != theOrders.end(); theIter++)
			{
				// For each one, if the order is for a player in the theDrawPlayerList, draw it
				vec3_t theOrderLocation;
				theIter->GetLocation(theOrderLocation);
				
				if(theIter->GetOrderTargetType() == ORDERTARGETTYPE_TARGET)
				{
					int theTargetIndex = theIter->GetTargetIndex();
					cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(theTargetIndex);
					if(theEntity)
					{
						//voogru: dont follow if they are cloaked, leave the waypoint active so they have a clue where they may be at, the wp should snap back to the baddy
						//once they are spotted again.

						if(theEntity->curstate.rendermode != kRenderTransTexture && theEntity->curstate.renderamt > 128)
							VectorCopy(theEntity->origin, theOrderLocation);
					}
				}
			
				// Draw the order if the order is for any plays that are in our draw player list
				bool theDrawWaypoint = false;
				EntityInfo theReceiverPlayer = theIter->GetReceiver();
				EntityListType::iterator theSearchIter = std::find(theDrawPlayerList.begin(), theDrawPlayerList.end(), theReceiverPlayer);
				if(theSearchIter != theDrawPlayerList.end() && *theSearchIter == theReceiverPlayer)
				{
					//gEngfuncs.pEfxAPI->R_ParticleLine((float*)theEntity->origin, (float*)theOrderLocation, 0, 255, 0, .05f);
					theDrawWaypoint = true;
				}
				if(theDrawWaypoint)
				{
					this->DrawOrderIcon(*theIter);
					this->DrawOrderText(*theIter);
				}
			}
		}
	}
}

int AvHHud::GetHelpIconFrameFromUser3(AvHUser3 inUser3)
{
	int theFrame = -1;

	switch(inUser3)
	{
	case AVH_USER3_WELD:
		theFrame = 0;
		break;
	case AVH_USER3_MARINEITEM:
		theFrame = 1;
		break;
	case AVH_USER3_HIVE:
		theFrame = 2;
		break;
	//case AVH_USER3_USEABLE:
	//	theFrame = 3;
	//	break;
	case AVH_USER3_COMMANDER_STATION:
		theFrame = 4;
		break;
	//case AVH_USER3_BREAKABLE:
	//	theFrame = 5;
	//	break;
	}

	return theFrame;
}

HSPRITE	AvHHud::GetHelpSprite() const
{
	return this->mHelpSprite;
}

void AvHHud::DrawHelpIcons()
{
	// Lookup table

	// Only draw if enabled
	//if(gEngfuncs.pfnGetCvarFloat(kvAutoHelp))
	//{
		// Iterate through help icons, drawing each one if we have an sprite for it
		for(HelpIconListType::iterator theIter = this->mHelpIcons.begin(); theIter != this->mHelpIcons.end(); theIter++)
		{
			int theUser3 = theIter->second;
			int theFrame = GetHelpIconFrameFromUser3(AvHUser3(theUser3));
						
			// Lookup sprite to see if it's loaded
//			if(this->mHelpSprites[theUser3] == 0)
//			{
//				string theIconName = string(kHelpIconPrefix) + MakeStringFromInt(theUser3) + ".spr";
//				this->mHelpSprites[theUser3] = Safe_SPR_Load(theIconName.c_str());
//			}
//			
//			int theSpriteHandle = this->mHelpSprites[theUser3];
//			if(theSpriteHandle > 0)
//			{
//				// Draw icon at entity center
//				this->DrawWorldSprite(theSpriteHandle, kRenderTransAdd, theIter->first, 0);
//			}

			if((theFrame >= 0) && this->mHelpSprite)
			{
				this->DrawWorldSprite(this->mHelpSprite, kRenderTransAdd, theIter->first, theFrame, kHelpIconDrawSize);
			}
		}
	//}
}

// inDrawMode determines if we're drawing text or sprites
void AvHHud::DrawHUDStructureNotification()
{
	const float	kHUDStructureNotificationStartX = .02f;
	const float	kHUDStructureNotificationStartY = .11f;
	const float	kHUDStructureNotificationIconWidth = .03f;
	const float	kHUDStructureNotificationIconHeight = kHUDStructureNotificationIconWidth*1.333f;
	const float	kHUDStructureNotificationIconHorizontalSpacing = .01f;
	const float	kHUDStructureNotificationIconVerticalSpacing = kHUDStructureNotificationIconHorizontalSpacing*1.333f;
	const float	kHUDStructureNotificationMaxTextWidth = .2f;

	// Draw them all in order
	if(this->GetIsAlive() && CVAR_GET_FLOAT(kvBuildMessages))
	{
		// Get starting coords
		float theCurrentX = kHUDStructureNotificationStartX;
		float theCurrentY = kHUDStructureNotificationStartY;

		
		for(StructureHUDNotificationListType::iterator theIter = this->mStructureNotificationList.begin(); theIter != this->mStructureNotificationList.end(); theIter++)
		{
			// Draw icon
			AvHMessageID theIconTech = theIter->mStructureID;
			int theFrame = 0;
			this->DrawTechTreeSprite(theIconTech, theCurrentX*ScreenWidth(), theCurrentY*ScreenHeight(), kHUDStructureNotificationIconWidth*ScreenWidth(), kHUDStructureNotificationIconHeight*ScreenHeight(), theFrame);

			string theLocationName = this->GetNameOfLocation(theIter->mLocation);
			if(theLocationName != "")
			{
				int theStartX = (theCurrentX + kHUDStructureNotificationIconWidth + kHUDStructureNotificationIconHorizontalSpacing)*ScreenWidth();
				this->DrawTranslatedString(theStartX, theCurrentY*ScreenHeight(), theLocationName.c_str(), false, true);
			}
            
			// Increment coords
			theCurrentY += (kHUDStructureNotificationIconHeight + kHUDStructureNotificationIconVerticalSpacing);
		}
		
	}
}

void AvHHud::DrawInfoLocationText()
{
	string theTimeLeftText;

	// Get drawing color and position
	int theR, theG, theB;
	this->GetPrimaryHudColor(theR, theG, theB, false, false);
			
	// Get position of health and draw to the right of it (must be left-justified)
	int theX = 0;
	int theY = 0;
	if(this->GetInTopDownMode())
	{
		const float kLeftInset = .4f;
		theX = mViewport[0] + kLeftInset*ScreenWidth();
		theY = mViewport[1] + mViewport[3] - (1-.78f)*ScreenHeight();
	}
	// Draw info location text the same for aliens and marines
	else if(this->GetHUDUser3() != AVH_USER3_ALIEN_EMBRYO)
	{
		const float kLeftInset = .08f;
		theX = mViewport[0] + kLeftInset*ScreenWidth();
		theY = mViewport[1] + mViewport[3] - (1-.88f)*ScreenHeight();
	}
	int theLeftEdge = theX;
	
	// Draw location text, translation if possible
	string theLocalizedLocationText;
	if(this->mLocationText != "")
	{
		LocalizeString(this->mLocationText.c_str(), theLocalizedLocationText);
		if(theLocalizedLocationText[0] == '#')
		{
			theLocalizedLocationText = theLocalizedLocationText.substr(1, theLocalizedLocationText.size());
		}

		// Draw handicap text as well
		int theHandicap = (int)this->GetHUDHandicap();
		if(theHandicap < 100)
		{
			// draw "(handicap 70%)"
			string theHandicapString;
			if(LocalizeString(kHandicap, theHandicapString))
			{
				char theFormattedHandicapString[256];
				sprintf(theFormattedHandicapString, " (%d%% %s)", theHandicap, theHandicapString.c_str());
				theLocalizedLocationText += string(theFormattedHandicapString);
			}
		}

		// Draw info location
		if(theLocalizedLocationText != "")
		{
			char theCharArray[512];
			sprintf(theCharArray, "%s", theLocalizedLocationText.c_str());
			
			this->DrawHudString(theX, theY, ScreenWidth(), theCharArray, theR, theG, theB);
		}
	}

	// Don't draw time when playing back, it isn't right and not worth breaking backward-compatibility over.
	// TODO: Draw time next time demo version changes
	if(!gEngfuncs.pDemoAPI->IsPlayingback() && this->GetHUDUser3() != AVH_USER3_ALIEN_EMBRYO)
	{
		// Whether we draw first line or not, increment for second line below
		theY += this->GetHudStringHeight();

		// Optionally draw time left below it
		int theTimeLimitSeconds = (int)this->GetGameTimeLimit();
		int theTimeElapsed = this->GetGameTime();
		int theMinutesElapsed = theTimeElapsed/60;
		int theSecondsElapsed = theTimeElapsed%60;
		int theTimeLeftSeconds = theTimeLimitSeconds - theTimeElapsed;
		int theMinutesLeft = theTimeLeftSeconds/60;
		int theSecondsLeft = theTimeLeftSeconds%60;
		int theMinutesLimit = theTimeLimitSeconds/60;
		int theSecondsLimit = theTimeLimitSeconds%60;

		// If we're in tournament mode or playing Combat, draw the timelimit
		bool theTournyMode = (gHUD.GetServerVariableFloat(kvTournamentMode) > 0);
		bool theDisplayTimeLimit = theTournyMode || gHUD.GetIsCombatMode();

		string theGameTimeText;
		if(LocalizeString(kGameTime, theGameTimeText))
		{
			bool theTimeVisible = true;

			// Flash time when we're almost out of time
			if((theMinutesLeft < 1) && this->GetGameStarted() && theDisplayTimeLimit)
			{
				float theTime = gHUD.GetTimeOfLastUpdate();
				float theTimeFraction = theTime - floor(theTime);
				if(theTimeFraction < .5f)
				{
					theTimeVisible = false;
				}
			}

			// Game time - 12:43
			char theGameTimeCStr[256];
			sprintf(theGameTimeCStr, " - %02d:%02d", theMinutesElapsed, theSecondsElapsed);
			theGameTimeText += string(theGameTimeCStr);

			if(theTimeVisible)
			{
				this->DrawHudString(theX, theY, ScreenWidth(), theGameTimeText.c_str(), theR, theG, theB);
			}

			// Increment X so time limit is drawn properly
			theX += this->GetHudStringWidth(theGameTimeText.c_str());
		}

		if(theDisplayTimeLimit)
		{
			string theTimeLimitString;
			if(LocalizeString(kTimeLimit, theTimeLimitString))
			{
				// Format: Time limit - 60:00
				char theTimeLimitCStr[256];
				sprintf(theTimeLimitCStr, "  %s - %02d:%02d", theTimeLimitString.c_str(), theMinutesLimit, theSecondsLimit);
				
				string theTimeLimitText = string(theTimeLimitCStr);

				this->DrawHudString(theX, theY, ScreenWidth(), theTimeLimitText.c_str(), theR, theG, theB);
			}

			if(gHUD.GetIsCombatMode())
			{
				theY += this->GetHudStringHeight();
				
				// Draw "attacking" or "defending"
				AvHTeamNumber theTeamNumber = this->GetHUDTeam();
				string theDisplayString = "";
				if(theTeamNumber != TEAM_IND)
				{
					if(theTeamNumber == this->GetCombatAttackingTeamNumber())
					{
						LocalizeString(kAttacking, theDisplayString);
					}
					else
					{
						LocalizeString(kDefending, theDisplayString);
					}

					this->DrawHudString(theLeftEdge, theY, ScreenWidth(), theDisplayString.c_str(), theR, theG, theB);
				}
			}
		}
	}
}

void AvHHud::DrawMouseCursor(int inBaseX, int inBaseY)
{
	if ( g_iVisibleMouse && !(this->GetInTopDownMode() && gEngfuncs.pDemoAPI->IsPlayingback()) )
	{

        HSPRITE theCursorSprite;
        int theCursorFrame;

        GetCursor(theCursorSprite, theCursorFrame);

		if (theCursorSprite > 0)
		{
			float theGammaSlope = this->GetGammaSlope();
			ASSERT(theGammaSlope > 0.0f);

            /*
			int theColorComponent = 255/theGammaSlope;
			SPR_Set(this->mCursorSprite, theColorComponent, theColorComponent, theColorComponent);
			
			// Draw the logo at 20 fps
			//SPR_DrawAdditive( 0, this->mMouseCursorX - inBaseX, this->mMouseCursorY - inBaseY, NULL );
			const int kMouseHotSpotX = -1;
			const int kMouseHotSpotY = -1;
			SPR_DrawHoles(this->mCurrentCursorFrame, this->mMouseCursorX - inBaseX - kMouseHotSpotX, this->mMouseCursorY - inBaseY - kMouseHotSpotY, NULL );
            */

            // Draw the mouse cursor.

			const int kMouseHotSpotX = -1;
			const int kMouseHotSpotY = -1;
            
            AvHSpriteBeginFrame();

            AvHSpriteEnableVGUI(true);
            AvHSpriteSetVGUIOffset(inBaseX, inBaseY);

            float x = this->mMouseCursorX - kMouseHotSpotX;
            float y = this->mMouseCursorY - kMouseHotSpotY;

            float w = SPR_Width(theCursorSprite, theCursorFrame);
            float h = SPR_Height(theCursorSprite, theCursorFrame);

            AvHSpriteSetRenderMode(kRenderTransAlpha);
			AvHSpriteDraw(theCursorSprite, theCursorFrame, x, y, x + w, y + h, 0, 0, 1, 1);
            
            // Draw the marquee if it's visible.
			
            if (mSelectionBoxVisible)
            {
				
                int sprite = Safe_SPR_Load(kWhiteSprite);
                
                int r, g, b;
                GetPrimaryHudColor(r, g, b, true, false);
				
                AvHSpriteSetRenderMode(kRenderTransAdd);
                AvHSpriteSetColor(r / 255.0, g / 255.0, b / 255.0, 0.3);
				
                AvHSpriteSetDrawMode(kSpriteDrawModeFilled);
                AvHSpriteDraw(sprite, 0, mSelectionBoxX1 + 1, mSelectionBoxY1 + 1, mSelectionBoxX2 - 1, mSelectionBoxY2 - 1, 0, 0, 1, 1);
				
                AvHSpriteSetRenderMode(kRenderNormal);
                AvHSpriteSetColor(1, 1, 1, 1);
				
                AvHSpriteSetDrawMode(kSpriteDrawModeBorder);
                AvHSpriteDraw(sprite, 0, mSelectionBoxX1, mSelectionBoxY1, mSelectionBoxX2, mSelectionBoxY2, 0, 0, 1, 1);
				
            }            
            
            AvHSpriteEndFrame();

        }
	}
}



void AvHHud::DrawTopDownBG()
{
	// If we're in top down mode, draw a black background
	float theDrawBackgroundHeight = -1;//cl_drawbg->value;
	
	// Draw the bottom plane at the map's min view height, unless overridden by cl_drawbg (this variable is for for testing purposes only)
	if(theDrawBackgroundHeight == -1)
	{
		if(this->mMapExtents.GetDrawMapBG())
		{
			theDrawBackgroundHeight = this->mMapExtents.GetMinViewHeight();
		}
	}
	
	if(theDrawBackgroundHeight != -1)
	{
		if(this->mBackgroundSprite)
		{
			// Build three points on plane described by max world dimensions at the draw background height
			Vector theUpperLeftWorldPos(-kMaxMapDimension, kMaxMapDimension, theDrawBackgroundHeight);
			Vector theUpperRightWorldPos(kMaxMapDimension, kMaxMapDimension, theDrawBackgroundHeight);
			Vector theLowerLeftWorldPos(-kMaxMapDimension, -kMaxMapDimension, theDrawBackgroundHeight);

			// Calculate plane info
			float thePlaneD;
			Vector thePlaneNormal;
			CalculatePlaneInfo(theUpperLeftWorldPos, theUpperRightWorldPos, theLowerLeftWorldPos, thePlaneD, thePlaneNormal);

			gEngfuncs.pTriAPI->RenderMode( kRenderNormal );
			gEngfuncs.pTriAPI->CullFace( TRI_NONE );
			gEngfuncs.pTriAPI->Brightness( 1 );
			
			if(gEngfuncs.pTriAPI->SpriteTexture((struct model_s *)gEngfuncs.GetSpritePointer(this->mBackgroundSprite), 0))
			{
				gEngfuncs.pTriAPI->Begin( TRI_TRIANGLE_STRIP );
				
				gEngfuncs.pTriAPI->Color4f(1.0f, 1.0f, 1.0f, 1.0f);

				Vector thePoint;

				CalculatePointOnPlane(0, ScreenHeight(), GetViewOrigin(), thePlaneNormal, thePlaneD, thePoint);
				gEngfuncs.pTriAPI->TexCoord2f(0, 1);
				gEngfuncs.pTriAPI->Vertex3fv((float*)&thePoint);

				CalculatePointOnPlane(0, 0, GetViewOrigin(), thePlaneNormal, thePlaneD, thePoint);
				gEngfuncs.pTriAPI->TexCoord2f(0, 0);
				gEngfuncs.pTriAPI->Vertex3fv((float*)&thePoint);
				
				CalculatePointOnPlane(ScreenWidth(), ScreenHeight(), GetViewOrigin(), thePlaneNormal, thePlaneD, thePoint);
				gEngfuncs.pTriAPI->TexCoord2f(1, 1);
				gEngfuncs.pTriAPI->Vertex3fv((float*)&thePoint);

				CalculatePointOnPlane(ScreenWidth(), 0, GetViewOrigin(), thePlaneNormal, thePlaneD, thePoint);
				gEngfuncs.pTriAPI->TexCoord2f(1, 0);
				gEngfuncs.pTriAPI->Vertex3fv((float*)&thePoint);
				
				// Add in some buffer because of perspective
//				pVector ver;
//				ver.z = theDrawBackgroundHeight;
//				
//				// Lower left
//				gEngfuncs.pTriAPI->TexCoord2f(0,1);
//				ver.x = -kMaxMapDimension;
//				ver.y = -kMaxMapDimension;
//				gEngfuncs.pTriAPI->Vertex3fv((float*)&ver);
//				
//				// Upper left
//				gEngfuncs.pTriAPI->TexCoord2f(0,0);
//				ver.x = -kMaxMapDimension;
//				ver.y = kMaxMapDimension;
//				gEngfuncs.pTriAPI->Vertex3fv((float*)&ver);
//				
//				// Upper right
//				gEngfuncs.pTriAPI->TexCoord2f(1,0);
//				ver.x = kMaxMapDimension;
//				ver.y = kMaxMapDimension;
//				gEngfuncs.pTriAPI->Vertex3fv((float*)&ver);
//				
//				// Lower right
//				gEngfuncs.pTriAPI->TexCoord2f(1,1);
//				ver.x = kMaxMapDimension;
//				ver.y = -kMaxMapDimension;
//				gEngfuncs.pTriAPI->Vertex3fv((float*)&ver);
				
				gEngfuncs.pTriAPI->End();
			}
		}
	}
}

void AvHHud::PostModelRender(char* inModelName)
{

	// Get our view model name
	cl_entity_t* theViewEntity = gEngfuncs.GetViewModel();
	if(theViewEntity)
	{
		// If this is our view model, that means we can now render our own stuff in screen space without z-buffering on top of everything else
		if(theViewEntity->model)
		{
			if(!strcmp(theViewEntity->model->name, inModelName))
			{
				this->RenderNoZBuffering();
			}
		}
	}
    
}

float AvHHud::GetHUDExperience() const
{
	vec3_t theVUser4;
	theVUser4.z = 0.0f;
	
	cl_entity_s* theLocalPlayer = gEngfuncs.GetLocalPlayer();
	if(theLocalPlayer)
	{
		theVUser4 = theLocalPlayer->curstate.vuser4;
	}
	
	if(g_iUser1 == OBS_IN_EYE)
	{
		cl_entity_t* theEnt = gEngfuncs.GetEntityByIndex(g_iUser2);
		if(theEnt)
		{
			theVUser4 = theEnt->curstate.vuser4;
		}
	}

	float theExperience = theVUser4.z/kNumericNetworkConstant;
	
	return theExperience;
}

int AvHHud::GetHUDExperienceLevel() const
{
	float theExperience = this->GetHUDExperience();
	int theLevel = AvHPlayerUpgrade::GetPlayerLevel(theExperience);
	return theLevel;
}

float AvHHud::GetHUDHandicap() const
{
	float theHandicap = 100.0f;

    AvHTeamNumber theTeamNumber = this->GetHUDTeam();
	switch(theTeamNumber)
	{
	case TEAM_ONE:
		theHandicap = this->GetServerVariableFloat(kvTeam1DamagePercent);
		break;
		
	case TEAM_TWO:
		theHandicap = this->GetServerVariableFloat(kvTeam2DamagePercent);
		break;
	}
	
	return theHandicap;
}

AvHUser3 AvHHud::GetHUDUser3() const
{
	AvHUser3 theUser3 = AVH_USER3_NONE;

	cl_entity_s* theLocalPlayer = gEngfuncs.GetLocalPlayer();
	if(theLocalPlayer)
	{
		theUser3 = (AvHUser3)(theLocalPlayer->curstate.iuser3);
	}

	if(g_iUser1 == OBS_IN_EYE)
	{
		cl_entity_t* theEnt = gEngfuncs.GetEntityByIndex(g_iUser2);
		if(theEnt)
		{
			theUser3 = (AvHUser3)(theEnt->curstate.iuser3);
		}
	}

	return theUser3;
}

AvHTeamNumber AvHHud::GetHUDTeam() const
{
	AvHTeamNumber theTeamNumber = TEAM_IND;

	cl_entity_s* thePlayer = this->GetVisiblePlayer();
	if(thePlayer)
	{
		theTeamNumber = AvHTeamNumber(thePlayer->curstate.team);
	}

	return theTeamNumber;
}

int AvHHud::GetHUDUpgrades() const
{
	int theUpgrades = 0;

	cl_entity_s* thePlayer = this->GetVisiblePlayer();
	if(thePlayer)
	{
		theUpgrades = thePlayer->curstate.iuser4;
	}

	return theUpgrades;
}

int AvHHud::GetHUDMaxArmor() const
{
	int theHUDUpgrades = this->GetHUDUpgrades();
	AvHUser3 theUser3 = this->GetHUDUser3();

	int theMaxArmor = AvHPlayerUpgrade::GetMaxArmorLevel(theHUDUpgrades, theUser3);

	#ifdef AVH_PLAYTEST_BUILD
	theMaxArmor = 100;
	#endif

	return theMaxArmor;
}

int AvHHud::GetHUDMaxHealth()	const
{
	int theHUDUpgrades = this->GetHUDUpgrades();
	AvHUser3 theUser3 = this->GetHUDUser3();
	int theHUDExperienceLevel = this->GetHUDExperienceLevel();

	int theMaxHealth = AvHPlayerUpgrade::GetMaxHealth(theHUDUpgrades, theUser3, theHUDExperienceLevel);

	#ifdef AVH_PLAYTEST_BUILD
	theMaxHealth = 100;
	#endif

	return theMaxHealth;
}

void AvHHud::GetPrimaryHudColor(int& outR, int& outG, int& outB, bool inIgnoreUpgrades, bool gammaCorrect) const
{
	if(this->GetIsMarine())
	{
		UnpackRGB(outR, outG, outB, RGB_MARINE_BLUE);
	}
	else
	{
		// HUD turns green when we're frenzying
		//if(GetHasUpgrade(this->GetHUDUpgrades(), MASK_PRIMALSCREAM) && !inIgnoreUpgrades)
		//{
		//	UnpackRGB(outR, outG, outB, RGB_GREENISH);
		//}
		//else
		//{
			UnpackRGB(outR, outG, outB, RGB_YELLOWISH);
		//}
	}

    if (gammaCorrect)
    {
	    // Take into account current gamma?
	    float theGammaSlope = this->GetGammaSlope();
	    outR /= theGammaSlope;
	    outG /= theGammaSlope;
	    outB /= theGammaSlope;
    }

}

void AvHHud::HandleFog()
{
	float theFogColor[3];
	theFogColor[0] = this->mFogColor.x;
	theFogColor[1] = this->mFogColor.y;
	theFogColor[2] = this->mFogColor.z;

	gEngfuncs.pTriAPI->Fog(theFogColor, this->mFogStart, this->mFogEnd, this->mFogActive);
}

void AvHHud::PreRenderFrame()
{
	bool theRenderForTopDown = this->mInTopDownMode /*&& !this->mIsRenderingSelectionView*/;

	if(!theRenderForTopDown)
	{
		this->HandleFog();
	}
	else
	{
		this->DrawTopDownBG();
		
		// Now draw commander HUD scaled
		//void CreatePickingRay( int mousex, int mousey, Vector& outVecPickingRay )
//		static int theCommanderHUDSprite = 0;
//		if(!theCommanderHUDSprite)
//		{
//			theCommanderHUDSprite = Safe_SPR_Load("sprites/.spr");
//		}
//		
//		if(theCommanderHUDSprite)
//		{
//			gEngfuncs.pTriAPI->RenderMode( kRenderNormal );
//			gEngfuncs.pTriAPI->CullFace( TRI_NONE );
//			gEngfuncs.pTriAPI->Brightness( 1 );
//			
//			if(gEngfuncs.pTriAPI->SpriteTexture((struct model_s *)gEngfuncs.GetSpritePointer(theCommanderHUDSprite), 0))
//			{
//				gEngfuncs.pTriAPI->Begin( TRI_QUADS );
//				
//				gEngfuncs.pTriAPI->Color4f(1.0f, 1.0f, 1.0f, .5f);
//				
//				pVector ver;
//				
//				// Lower left
//				const float kMaxMapDimension = 4096;
//				//ver.z = -kMaxMapDimension;
//				ver.z = theDrawBackgroundHeight;
//				
//				gEngfuncs.pTriAPI->TexCoord2f(0,1);
//				ver.x = -kMaxMapDimension;
//				ver.y = -kMaxMapDimension;
//				gEngfuncs.pTriAPI->Vertex3fv((float*)&ver);
//				
//				// Upper left
//				gEngfuncs.pTriAPI->TexCoord2f(0,0);
//				ver.x = -kMaxMapDimension;
//				ver.y = kMaxMapDimension;
//				gEngfuncs.pTriAPI->Vertex3fv((float*)&ver);
//				
//				// Upper right
//				gEngfuncs.pTriAPI->TexCoord2f(1,0);
//				ver.x = kMaxMapDimension;
//				ver.y = kMaxMapDimension;
//				gEngfuncs.pTriAPI->Vertex3fv((float*)&ver);
//				
//				// Lower right
//				gEngfuncs.pTriAPI->TexCoord2f(1,1);
//				ver.x = kMaxMapDimension;
//				ver.y = -kMaxMapDimension;
//				gEngfuncs.pTriAPI->Vertex3fv((float*)&ver);
//				
//				gEngfuncs.pTriAPI->End();
//			}
//		}
	}

	AvHScriptManager::Instance()->DrawNormal();
}

void AvHHud::PostRenderFrame()
{
	// Restore player angles and view position
//	v_origin = gPlayerOrigin;
//	v_angles = gPlayerAngles;
}

void AvHHud::DrawActionButtons()
{
	// Look up AvHActionButtons component
	AvHActionButtons* theActionButtons = NULL;
	if(this->GetManager().GetVGUIComponentNamed(kActionButtonsComponents, theActionButtons))
	{
		int theNumCols = theActionButtons->GetNumCols();
		int theNumRows = theActionButtons->GetNumRows();

		// Iterate through num cols
		for(int theCol = 0; theCol < theNumCols; theCol++)
		{
			// Iterate through num rows
			for(int theRow = 0; theRow < theNumRows; theRow++)
			{
				// Get current ActionButton
				ActionButton* theActionButton = theActionButtons->GetActionButtonAtPos(theCol, theRow);
				ASSERT(theActionButton);

				// Get message ID for button
				AvHMessageID theMessageID = theActionButton->GetMessageID();

				// Find the group that it belongs to (20, 30, 40, etc.)
				int theMessageNumber = (int)theMessageID - (theMessageID % 10);

//				// Load sprite if not loaded
//				bool theSpriteLoaded = (this->mActionButtonSprites[theMessageNumber] > 0);
//				if(!theSpriteLoaded)
//				{
//					// Build sprite name for message ID
//					char theMessageNumberString[16];
//					sprintf(theMessageNumberString, "%d", (int)theMessageNumber);
//					//string theSpriteName = kTechTreeSpriteDirectory + string("/") + kTechTreeSpritePrefix + string(theMessageIDString) + string(".spr");
//					string theSpriteName = kTechTreeSpriteDirectory + string("/") + kTechTreeSpritePrefix + string(theMessageNumberString) + string("s.spr");
//					int theSpriteHandle = Safe_SPR_Load(theSpriteName.c_str());
//
//					// Sprite handle can be 0, as I don't have sprites for all tech yet
//					this->mActionButtonSprites[theMessageNumber] = theSpriteHandle;
//				}

				// Get pos and size for component
				int thePosX, thePosY;
				theActionButton->getPos(thePosX, thePosY);
				
				int theWidth, theHeight;
				theActionButton->getSize(theWidth, theHeight);
				
				// Set sprite frame depending if button is available, active
				bool theTechEnabled = theActionButton->GetTechEnabled();
				bool theMouseOver = theActionButton->GetMouseOver();
				bool theCostMet = theActionButton->GetCostMet();

				// 0 = default
				// 1 = highlighted
				// 2 = dark
				// 3 = red
				int theFrame = 2;

				// If it's enabled, or if it's an icon in the "menu navigation" category, allow it to be highlighted
				if(theTechEnabled || (theMessageNumber == 80))
				{
					if(theCostMet)
					{
						if(theMouseOver)
						{
							theFrame = 1;
						}
						else
						{
							theFrame = 0;
						}
					}
					else
					{
						theFrame = 3;
					}
				}

				// Also highlight menu category headings for open menus, and for active nodes just pressed
				if(gCommanderHandler.GetDisplayMenuMessageID() == theMessageID)
				{
					theFrame = 1;
				}
				else
				{
					AvHMessageID theMessageJustActivated = MESSAGE_NULL;
					if(gCommanderHandler.GetAndClearTechNodePressed(theMessageJustActivated, false))
					{
						if(theMessageJustActivated == theMessageID)
						{
							if(theTechEnabled)
							{
								theFrame = 1;
							}
						}
					}
				}
				
				this->DrawTechTreeSprite(theMessageID, thePosX, thePosY, theWidth, theHeight, theFrame);
			}
		}
	}
}

int AvHHud::GetTechTreeSprite(AvHMessageID inMessageID)
{
	// Find the group that it belongs to (20, 30, 40, etc.)
	int theMessageNumber = (int)inMessageID - (inMessageID % 10);
	
	// Load sprite if not loaded
	bool theSpriteLoaded = (this->mActionButtonSprites[theMessageNumber] > 0);
	if(!theSpriteLoaded && (theMessageNumber != 0))
	{
		// Build sprite name for message ID
		char theMessageNumberString[16];
		sprintf(theMessageNumberString, "%d", (int)theMessageNumber);
		//string theSpriteName = kTechTreeSpriteDirectory + string("/") + kTechTreeSpritePrefix + string(theMessageIDString) + string(".spr");
		string theSpriteName = kTechTreeSpriteDirectory + string("/") + kTechTreeSpritePrefix + string(theMessageNumberString) + string("s.spr");
		int theSpriteHandle = Safe_SPR_Load(theSpriteName.c_str());
		
		// Sprite handle can be 0, as I don't have sprites for all tech yet
		this->mActionButtonSprites[theMessageNumber] = theSpriteHandle;
	}
	
	// Fetch sprite handle
	int theSpriteHandle = this->mActionButtonSprites[theMessageNumber];

	return theSpriteHandle;
}

void AvHHud::DrawTechTreeSprite(AvHMessageID inMessageID, int inPosX, int inPosY, int inWidth, int inHeight, int inFrame)
{
	if(inMessageID != MESSAGE_NULL)
	{
		// Check for alien sprites
		bool theIsAlienSprite = false;
		int theSpriteHandle = 0;
		int theRenderMode = kRenderTransAlpha; // kRenderNormal
		
		switch(inMessageID)
		{
		case ALIEN_BUILD_DEFENSE_CHAMBER:
			theIsAlienSprite = true;
			inFrame = 0;
			break;
		case ALIEN_BUILD_OFFENSE_CHAMBER:
			theIsAlienSprite = true;
			inFrame = 1;
			break;
		case ALIEN_BUILD_MOVEMENT_CHAMBER:
			theIsAlienSprite = true;
			inFrame = 2;
			break;
		case ALIEN_BUILD_SENSORY_CHAMBER:
			theIsAlienSprite = true;
			inFrame = 3;
			break;
		case ALIEN_BUILD_RESOURCES:
			theIsAlienSprite = true;
			inFrame = 4;
			break;
		case ALIEN_BUILD_HIVE:
			theIsAlienSprite = true;
			inFrame = 5;
			break;
		}

		float theStartU = 0.0f;
		float theStartV = 0.0f;
		float theEndU = 1.0f;
		float theEndV = 1.0f;

		if(theIsAlienSprite)
		{
			theRenderMode = kRenderTransAlpha;
			theSpriteHandle = this->mAlienUIUpgradeCategories;
		}
		else
		{
			// Fetch sprite handle
			theSpriteHandle = this->GetTechTreeSprite(inMessageID);

			int theIndex = inMessageID % 10;
			int theXIndex = theIndex % 4;
			int theYIndex = (theIndex / 4);
			theStartU = theXIndex*.25f;
			theStartV = theYIndex*.25f;
			theEndU = (theXIndex+1)*.25f;
			theEndV = (theYIndex+1)*.25f;
		}

		if(theSpriteHandle > 0)
		{
			// Draw sprite scaled here
			AvHSpriteSetRenderMode(theRenderMode);
			AvHSpriteDraw(theSpriteHandle, inFrame, inPosX, inPosY, inPosX + inWidth, inPosY + inHeight, theStartU, theStartV, theEndU, theEndV);
		}
	}
}

void AvHHud::DrawHotgroups()
{
	AvHMessageID theHotgroups[kNumHotkeyGroups] = {GROUP_SELECT_1, GROUP_SELECT_2, GROUP_SELECT_3, GROUP_SELECT_4, GROUP_SELECT_5};

	// Run through list of hotgroups, drawing them if they exist
	for(int i = 0; i < kNumHotkeyGroups; i++)
	{
		EntityListType& theHotgroup = this->mGroups[i];

		if(theHotgroup.size() > 0)
		{
			// Get message ID to draw
			AvHUser3 theGroupTypeUser3 = this->mGroupTypes[i];

			// Default is marine face
			AvHMessageID theHotgroupIcon = MENU_SOLDIER_FACE;
			AvHSHUUser3ToMessageID(theGroupTypeUser3, theHotgroupIcon);

			// Build component name ("PendingImpulseXPanel", where X is the impulse)
			AvHMessageID theHotgroupMessageID = theHotgroups[i];
			char theComponentName[256];
			sprintf(theComponentName, kPendingImpulseSpecifier, (int)theHotgroupMessageID);
			
			AvHTechImpulsePanel* theTechImpulsePanel = NULL;
			if(this->GetManager().GetVGUIComponentNamed(theComponentName, theTechImpulsePanel))
			{
				int thePosX, thePosY;
				theTechImpulsePanel->getPos(thePosX, thePosY);

				int theWidth, theHeight;
				theTechImpulsePanel->getSize(theWidth, theHeight);

				// Highlight if mouse is in region or if it's our current selection
				bool theIsHighlighted = this->GetIsMouseInRegion(thePosX, thePosY, theWidth, theHeight) || (this->mSelected == theHotgroup);
				int theFrame =  theIsHighlighted ? 1 : 0;

				int theSecondOfLastUpdate = (int)this->mTimeOfLastUpdate;
				if((this->mGroupAlerts[i] == ALERT_UNDER_ATTACK) && (theSecondOfLastUpdate % 2))
				{
					// Play blinking red frame when being attacked
					theFrame = 3;
				}

				this->DrawTechTreeSprite(theHotgroupIcon, thePosX, thePosY, theWidth, theHeight, theFrame);

				theTechImpulsePanel->SetVisualNumber(theHotgroup.size());
			}
		}
	}
}

// Draw pending requests
void AvHHud::DrawPendingRequests()
{
	// Run through list of requests and delete any entries with
	PendingRequestListType::iterator theIterator;
	for(theIterator = this->mPendingRequests.begin(); theIterator != this->mPendingRequests.end(); /* nothing */)
	{
		if(theIterator->second == 0)
		{
            PendingRequestListType::iterator theSavedIter = theIterator;
            theSavedIter++;
            this->mPendingRequests.erase(theIterator);
            theIterator = theSavedIter;
		}
		else
		{
			theIterator++;
		}
	}

	int theNumRequestsToDraw = this->mPendingRequests.size();
	int theCounter = 0;
	for(theIterator = this->mPendingRequests.begin(); theIterator != this->mPendingRequests.end(); theIterator++)
	{
		// Draw each one above the minimap
		AvHMessageID theMessageID = theIterator->first;
		int theNumRequests = theIterator->second;

		// Build component name ("PendingImpulseXPanel", where X is the impulse)
		char theComponentName[256];
		sprintf(theComponentName, kPendingImpulseSpecifier, (int)theMessageID);

		AvHTechImpulsePanel* theTechImpulsePanel = NULL;
		if(this->GetManager().GetVGUIComponentNamed(theComponentName, theTechImpulsePanel))
		{
			// Get size of panel and draw tech sprite there
			int thePosX, thePosY;
			theTechImpulsePanel->getPos(thePosX, thePosY);

			int theWidth, theHeight;
			theTechImpulsePanel->getSize(theWidth, theHeight);

			AvHMessageID theMessageToDraw = theMessageID;
			switch(theMessageID)
			{
			case COMMANDER_NEXTIDLE:
				theMessageToDraw = MENU_SOLDIER_FACE;
				break;
			case COMMANDER_NEXTAMMO:
				theMessageToDraw = BUILD_AMMO;
				break;
			case COMMANDER_NEXTHEALTH:
				theMessageToDraw = BUILD_HEALTH;
				break;
			}

			int theFrame = this->GetIsMouseInRegion(thePosX, thePosY, theWidth, theHeight) ? 1 : 0;
			this->DrawTechTreeSprite(theMessageToDraw, thePosX, thePosY, theWidth, theHeight, theFrame);

			theTechImpulsePanel->SetVisualNumber(theNumRequests);
			if(theNumRequests > 0)
			{
				theTechImpulsePanel->setVisible(true);
			}
			else
			{
				theTechImpulsePanel->setVisible(false);
			}
			
			//this->DrawHUDNumber(thePosX + kTileWidth, thePosY + kTileHeight, DHN_2DIGITS, theNumRequests);
		}

		// Draw indicator on sprite showing how many requests there are
		theCounter++;
	}
}


void AvHHud::DrawBuildHealthEffectsForEntity(int inEntityIndex)
{
	// Get entity
	int theUser3 = 0;
	int theUser4 = 0;
	float theFuser1 = 0.0f;
	int theEntityTeam = 0;
	vec3_t theOrigin;
	vec3_t theMins;
	vec3_t theMaxs;
	bool theContinue = false;
	float theHealthPercentage = 0.0f;
	double theDistanceToEntity = 0;
	
	// Must treat these two cases differently, as rendering with no z-buffering happens in two different ways.  It's an awful hack but hey, I don't have access to the engine so I have to make do.
//	if(!this->GetInTopDownMode())
//	{
//		physent_t* theEntity = gEngfuncs.pEventAPI->EV_GetPhysent(inEntityIndex);
//		if(theEntity)
//		{
//			theUser3 = theEntity->iuser3;
//			theUser4 = theEntity->iuser4;
//			theFuser1 = theEntity->fuser1;
//			theEntityTeam = theEntity->team;
//			theOrigin = theEntity->origin;
//			theMins = theEntity->mins;
//			theMaxs = theEntity->maxs;
//			theHealthPercentage = theEntity->fuser2/kNormalizationNetworkFactor;
//			theContinue = true;
//		}
//	}
//	else
//	{
		cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(inEntityIndex);
		if(theEntity)
		{
			theUser3 = theEntity->curstate.iuser3;
			theUser4 = theEntity->curstate.iuser4;
			theFuser1 = theEntity->curstate.fuser1;
			theEntityTeam = theEntity->curstate.team;
			
			//theOrigin = theEntity->curstate.origin;
			theOrigin = AvHSHUGetRealLocation(theEntity->origin, theEntity->curstate.mins, theEntity->curstate.maxs);
			if(theEntity->player)
			{
				// Subtract half-height to be at feet
				float theHeight = theEntity->curstate.maxs[2] - theEntity->curstate.mins[2];
				theOrigin[2] -= theHeight/2.0f;
			}
			theDistanceToEntity = VectorDistance(gPredictedPlayerOrigin, theOrigin);

			theMins = theEntity->curstate.mins;
			theMaxs = theEntity->curstate.maxs;
			theHealthPercentage = theEntity->curstate.fuser2/kNormalizationNetworkFactor;
			
			theContinue = true;
		}
//	}

	// Get local player
	cl_entity_s* theLocalPlayer = gEngfuncs.GetLocalPlayer();
	
	bool theDrewBuildInProgress = false;
	float theOversizeScalar = 1.0f;
	bool theEntityIsPlayer = ((inEntityIndex > 0) && (inEntityIndex <= gEngfuncs.GetMaxClients()));
    bool theIsOnOurTeam = (theEntityTeam == (int)this->GetHUDTeam());
	
	if(AvHSHUGetDrawRingsForUser3((AvHUser3)theUser3, theOversizeScalar))
	{
		if(theContinue && theLocalPlayer)
		{
			const kDrawEnemyBuildingDistance = 200;

			// Draw effects if we are in top-down mode OR
			if(	this->GetInTopDownMode() ||

				// It's an unfriendly building that's very close OR
				(!theEntityIsPlayer && (theDistanceToEntity < kDrawEnemyBuildingDistance)) ||

				// It's a friendly entity and we're a builder
				(theIsOnOurTeam && (this->GetHUDUser3() == AVH_USER3_ALIEN_PLAYER2))

				)
			{
				
			// If they're not on opposite teams
			//if((theEntityTeam == theLocalPlayer->curstate.team) || (theEntityTeam == 0))
			//{
				// Get entity build/research state
				bool theIsBuilding = false;
				bool theIsResearching = false;
				float theNormalizedPercentage = 0.0f;
		
				// Calculate percentage full
				AvHSHUGetBuildResearchState(theUser3, theUser4, theFuser1, theIsBuilding, theIsResearching, theNormalizedPercentage);
		
				bool theDrawHealth = true;
				int theSpriteToUse = this->GetIsAlien() ? this->mAlienHealthSprite : this->mMarineHealthSprite;
                bool theDrawAsRecyling = (GetHasUpgrade(theUser4, MASK_RECYCLING) && theIsOnOurTeam);

				if((theIsBuilding && (GetHasUpgrade(theUser4, MASK_BUILDABLE))) || theDrawAsRecyling)
				{
					theSpriteToUse = this->GetIsAlien() ? this->mAlienBuildSprite : this->mMarineBuildSprite;
					theDrawHealth = false;

                    // Draw progress inverted, as we're "undoing" the structure
                    if(theDrawAsRecyling)
                    {
                        theNormalizedPercentage = (1.0f - theNormalizedPercentage);
                    }
				}
				else
				{
					theNormalizedPercentage = theHealthPercentage;
				}
		
				if(theDrawHealth || (theEntityTeam == theLocalPlayer->curstate.team))
				{
					// Draw it
					int theNumFrames = SPR_Frames(theSpriteToUse);
					ASSERT(theNumFrames > 0);
					
					int theCurrentFrame;
					if ((theHealthPercentage < 1.0f) || theDrawAsRecyling)
					{
						theCurrentFrame = theNormalizedPercentage * (theNumFrames - 1);
						// tankefugl: 0000893
						// quick hack to eliminate 1 red bar shown for dead players
						if (theEntity->player)
                            theCurrentFrame = min(max(0, theCurrentFrame), theNumFrames - 1);
						else
							theCurrentFrame = min(max(1, theCurrentFrame), theNumFrames - 1);
						// :tankefugl
					}
					else 
					{
						theCurrentFrame = theNumFrames - 1;
					}
					
					// Get real position of entity
					vec3_t thePosition;
					thePosition = AvHSHUGetRealLocation(theOrigin, theMins, theMaxs);
					
					float theMaxX = theMaxs[0] - theMins[0];
					float theMaxY = theMaxs[1] - theMins[1];
					
					float theRadius = max(theMaxX, theMaxY)*theOversizeScalar;

					// Bring position off ground just a little to prevent z-fighting
					thePosition.z += kZFightingOffset;
					
					//GetHasUpgrade(this->GetHUDUpgrades(), MASK_PARASITED)

					DrawSpriteOnGroundAtPoint(thePosition, theRadius, theSpriteToUse, kRenderTransAdd, theCurrentFrame);
					
					theDrewBuildInProgress = true;
				}
			}
		}
	}
	
	if(!theDrewBuildInProgress)
	{
		int a = 0;
	}
}

void AvHHud::DrawHUDNumber(int inX, int inY, int inFlags, int inNumber)
{
	// Draw number on HUD, in our HUD color
	int theR, theG, theB;
	this->GetPrimaryHudColor(theR, theG, theB, false, false);

	int theGammaSlope = this->GetGammaSlope();
	theR /= theGammaSlope;
	theG /= theGammaSlope;
	theB /= theGammaSlope;

	this->DrawHudNumber(inX, inY, inFlags, inNumber, theR, theG, theB);
}

void AvHHud::DrawSelectionAndBuildEffects()
{
//	for(SelectionListType::iterator theIter = this->mSelectionEffects.begin(); theIter != this->mSelectionEffects.end(); theIter++)
//	{
//		// Draw selection effect around the entity
//		int theEntIndex = theIter->mEntIndex;
//		cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(theEntIndex);
//		//physent_t* theEntity = GetEntity(theEntIndex);
//		if(theEntity)
//		{
//			float theRadius = 17;
//			
//			// Draw spinning thingie around entity origin
//			//float theAngle = (theIter->mAngleOffset/(M_PI))*180;
//			int theAngle = theIter->mAngleOffset;
//			vec3_t thePosition;
//			
//			//VectorCopy(theEntity->origin, thePosition);
//			thePosition = AvHSHUGetRealLocation(theEntity->origin, theEntity->curstate.mins, theEntity->curstate.maxs);
//			
//			if(theEntity->player)
//			{
//				// Subtract half-height to be at feet
//				float theHeight = theEntity->curstate.maxs[2] - theEntity->curstate.mins[2];
//				thePosition[2] -= theHeight/2.0f;
//			}
//			//DrawCircleOnGroundAtPoint(thePosition, 9, theAngle, theRadius, 0, 1, 0, .5f, false, 0.0f);
//			//DrawSelectionCircleOnGroundAtPoint(thePosition, theRadius);
//
//			for(int i = 0; i < 2; i++)
//			{
//				// First frame is circle inside, second is outline
//				// Same opacity as the marquee component in ui.txt.
//				float theAlpha = (i == 0 ? .2f : .6f);
//				DrawSpriteOnGroundAtPoint(thePosition, theRadius, this->mSelectionCircleSprite, kRenderNormal, i, theAlpha);
//			}
//			
//			theIter->mAngleOffset = theAngle + 1;
//			
//			//gEngfuncs.pEfxAPI->R_SparkShower(theEntity->origin);
//		}
//	}
	
	//	gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction(false, true);
	//	
	//	// Store off the old count
	//	gEngfuncs.pEventAPI->EV_PushPMStates();
	//
	//	// Now add in all of the players.
	//	gEngfuncs.pEventAPI->EV_SetSolidPlayers(-1);
	//	gEngfuncs.pEventAPI->EV_SetTraceHull(2);
	
	// Draw build effects
	for(SelectionListType::iterator theSelectIter = this->mSelectionEffects.begin(); theSelectIter != this->mSelectionEffects.end(); theSelectIter++)
	{
		// Draw selection effect around the entity
		int theEntIndex = theSelectIter->mEntIndex;
		this->DrawBuildHealthEffectsForEntity(theEntIndex);
	}
	
	bool theDrawBuildingEffect = false;
	for(EntityListType::iterator theBuildingIter = this->mBuildingEffectsEntityList.begin(); theBuildingIter != this->mBuildingEffectsEntityList.end(); theBuildingIter++)
	{
		int theEntIndex = *theBuildingIter;
		this->DrawBuildHealthEffectsForEntity(theEntIndex);
	}
/*	
	// Draw range for current ghost building, if applicable
	EntityListType theEntities;
	IntList theDistanceRequirements;
	float theZAdjustment = 0.0f;
	bool theSnapToLocation = false;
	bool theDrewGhostRegions = false;
	
	AvHSHUGetBuildRegions(this->mGhostBuilding, theEntities, theDistanceRequirements, theZAdjustment, theSnapToLocation);

	// For each entity to draw
	int theDistanceCounter = 0;
	for(EntityListType::iterator theRangeIter = theEntities.begin(); theRangeIter != theEntities.end(); theRangeIter++, theDistanceCounter++)
	{
		//cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(*theRangeIter);
		physent_t* theEntity = gEngfuncs.pEventAPI->EV_GetPhysent(*theRangeIter);
		if(theEntity)
		{
			vec3_t thePosition;
			thePosition = AvHSHUGetRealLocation(theEntity->origin, theEntity->mins, theEntity->maxs);

			//int theSprite = (theEntity->iuser3 == AVH_USER3_SIEGETURRET) ? this->mSiegeTurretSprite : this->mBuildCircleSprite;
			int theSprite = this->mBuildCircleSprite;

			int theDistanceRequirement = theDistanceRequirements[theDistanceCounter];
			DrawSpriteOnGroundAtPoint(thePosition, theDistanceRequirement, theSprite, kRenderTransAdd, 0, .15f);

			theDrewGhostRegions = true;
		}
	}

    // Draw selection as well
	for(EntityListType::iterator theSelectedIter = this->mSelected.begin(); theSelectedIter != this->mSelected.end(); theSelectedIter++)
	{
		cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(*theSelectedIter);
		//physent_t* theEntity = gEngfuncs.pEventAPI->EV_GetPhysent(*theSelectedIter);
		if(theEntity)
		{
			vec3_t thePosition;
			thePosition = AvHSHUGetRealLocation(theEntity->curstate.origin, theEntity->curstate.mins, theEntity->curstate.maxs);
			
			AvHUser3 theUser3 = (AvHUser3)(theEntity->curstate.iuser3);
			int theRange = AvHSHUGetDrawRangeForUser3(theUser3);
			if(theRange > 0)
			{
				// Don't draw structures that are recycling and therefore inactive
				if(!GetHasUpgrade(theEntity->curstate.iuser4, MASK_RECYCLING))
				{
					//int theSprite = (theEntity->curstate.iuser3 == AVH_USER3_SIEGETURRET) ? this->mSiegeTurretSprite : this->mBuildCircleSprite;
					int theSprite = this->mBuildCircleSprite;
					DrawSpriteOnGroundAtPoint(thePosition, theRange, theSprite, kRenderTransAdd, 0, .15f);
				}
				else
				{
					int a = 0;
				}
			}
		}
	}
*/

//	// Draw an additive circle above every structure
//	if(this->GetInTopDownMode() /*&& !theDrewGhostRegions*/)
//	{
//		EntityListType theEntities;
//		AvHSHUGetEntities(-1, theEntities);
//		
//		for(EntityListType::iterator theEntityIter = theEntities.begin(); theEntityIter != theEntities.end(); theEntityIter++)
//		{
//			// If entity is on our team and on-screen, draw a circle above it
//			physent_t* theEntity = gEngfuncs.pEventAPI->EV_GetPhysent(*theEntityIter);
//			if(theEntity && (theEntity->team == (int)(this->mTeam)) && !theEntity->player)
//			{
//				// Approach #1
//				this->DrawBuildHealthEffectsForEntity(*theEntityIter);
//
//				// Approach #2
//				AvHMessageID theMessageID = AvHCUUser3ToTechSprite((AvHUser3)theEntity->iuser3);
//				if(theMessageID != MENU_ORDERS)
//				{
//					vec3_t thePosition;
//					thePosition = AvHSHUGetRealLocation(theEntity->origin, theEntity->mins, theEntity->maxs);
//
//					vec3_t theMinSize, theMaxSize;
//					AvHSHUGetSizeForTech(theMessageID, theMinSize, theMaxSize);
//					thePosition.z += (theMaxSize.z - theMinSize.z);
//					
//					//int theSprite = (theEntity->iuser3 == AVH_USER3_SIEGETURRET) ? this->mSiegeTurretSprite : this->mBuildCircleSprite;
//					int theSprite = this->mBuildCircleSprite;
//
//					float theRingScalar = 1.0f;
//					if(AvHSHUGetDrawRingsForUser3((AvHUser3)(theEntity->iuser3), theRingScalar))
//					{
//						float theMaxX = theMaxSize[0] - theMinSize[0];
//						float theMaxY = theMaxSize[1] - theMinSize[1];
//						float theRadius = max(theMaxX, theMaxY)*theRingScalar;
//						DrawSpriteOnGroundAtPoint(thePosition, (int)theRadius, theSprite, kRenderTransAdd, 0, .10f);
//					}
//				}
//			}
//		}
//	}

	// Draw circle for ghost building as well
	//int theDistance = AvHSHUGetDrawRangeForMessageID(this->mGhostBuilding);
	//if(theDistance > 0)
	//{
	//	DrawSpriteOnGroundAtPoint(this->mGhostWorldLocation, theDistance, this->mBuildCircleSprite, kRenderTransAdd, 0, .07f);
	//}
	
	//	gEngfuncs.pEventAPI->EV_PopPMStates();
}


void AvHHud::Render()
{

    if (!IEngineStudio.IsHardware())
    {

        // Don't show anything in software mode.
        
        const char* theMessage = "Software mode is not supported by Natural Selection";

        int theWidth;
        int theHeight;

	    float gammaScale = 1.0f / GetGammaSlope();

        gEngfuncs.pfnDrawSetTextColor(0, gammaScale, 0);    
        gEngfuncs.pfnDrawConsoleStringLen(theMessage, &theWidth, &theHeight);
        gEngfuncs.pfnDrawConsoleString((ScreenWidth() - theWidth) / 2, (ScreenHeight() - theHeight) / 2, (char*)theMessage);
        
        return;

    }

    if (m_Spectator.IsInOverviewMode())
    {
        AvHSpriteSetViewport(mSpecialViewport[0], mSpecialViewport[1],
            mSpecialViewport[0] + mSpecialViewport[2], mSpecialViewport[1] + mSpecialViewport[3]);
    }

    AvHSpriteBeginFrame();

    if (mSteamUIActive)
    {
        // Use the old 2D method if we're in the Steam UI.
        AvHSpriteEnableVGUI(false);
    }
    else
    {
        AvHSpriteEnableVGUI(true);
        AvHSpriteSetVGUIOffset(0, 0);
    }

#ifdef DEBUG
    if ( CVAR_GET_FLOAT( "hud_hideview" ) != 0 )
    {

        // Black out the screen
        
        int sprite = Safe_SPR_Load(kWhiteSprite);
        AvHSpriteSetColor(0, 0, 0, 1);
        AvHSpriteDraw(sprite, 0, 0, 0, ScreenWidth(), ScreenHeight(), 0, 0, 1, 1);
        AvHSpriteSetColor(1, 1, 1, 1);

    }
#endif

	// Don't draw the HUD while being digested.

    if (GetIsBeingDigested())
	{
    
		if (this->mDigestingSprite)
        {
            AvHSpriteSetColor(1,1,1);
            AvHSpriteSetRenderMode(kRenderNormal);
            DrawWarpedOverlaySprite(mDigestingSprite, 4, 3, .02, .02, .3, .15);
        }        

	}
    else
    {
   
        if (this->GetHUDPlayMode() == PLAYMODE_PLAYING ||
            this->GetHUDPlayMode() == PLAYMODE_READYROOM)
        {

            if (!mSteamUIActive)
            {
		        this->DrawReticleInfo();
	    	    this->DrawPlayerNames();
		        this->DrawToolTips();
            }

        }

        if (this->GetHUDPlayMode() == PLAYMODE_PLAYING)
        {

            RenderCommonUI();

            if (GetIsMarine())
            {
                if (GetInTopDownMode())
                {
                    RenderCommanderUI();
                }
                else
                {
                    RenderMarineUI();
                }
            }
            else if (GetIsAlien())
            {
                RenderAlienUI();
            }
        }

    }

    AvHSpriteEndFrame();
    AvHSpriteClearViewport();

}

void AvHHud::RenderCommonUI()
{


    /*
    // Draw the crosshair.

    if (mCrosshairShowCount > 0 && mCrosshairSprite)
    {

        float x1 = mCrosshairRect.left;
        float y1 = mCrosshairRect.top;
        float x2 = mCrosshairRect.right;
        float y2 = mCrosshairRect.bottom;

	    //kRenderNormal,			// src
	    //kRenderTransColor,		// c*a+dest*(1-a)
	    //kRenderTransTexture,	// src*a+dest*(1-a)
	    //kRenderGlow,			// src*a+dest -- No Z buffer checks
	    //kRenderTransAlpha,		// src*srca+dest*(1-srca)
	    //kRenderTransAdd,		// src*a+dest

        AvHSpriteSetRenderMode(kRenderTransAlpha);
        AvHSpriteDraw(mCrosshairSprite, 0, x1, y1, x2, y2, 0, 0, 1, 1);

    }
    */

    if (!mSteamUIActive)
    {
        
        if (gHUD.GetServerVariableFloat("sv_cheats") != 0 && CVAR_GET_FLOAT("cl_showspeed") != 0)
        {

            // Draw the speedometer.

            int theR, theG, theB;
            this->GetPrimaryHudColor(theR, theG, theB, true, false);

            extern playermove_s* pmove;
        
            char buffer[1024];

            sprintf(buffer, "Speed = %d", (int)Length(pmove->velocity));
            mFont.DrawString(10, 10, buffer, theR, theG, theB);

            float theGroundSpeed = sqrtf(pmove->velocity[0] * pmove->velocity[0] + pmove->velocity[1] * pmove->velocity[1]);

            sprintf(buffer, "Ground speed = %d", (int)theGroundSpeed);
            mFont.DrawString(10, 12 + mFont.GetStringHeight(), buffer, theR, theG, theB);
            

        }

        DrawInfoLocationText();
        DrawHUDStructureNotification();

        this->DrawOrders();
        this->DrawHelpIcons();

        if (this->GetIsCombatMode())
        {
	        // If we're in combat mode, draw our rank
	        const float kTitleYInset = (kPlayerStatusVerticalInset+5*kPlayerStatusStatusSpacing);

	        string theTitleText = this->GetRankTitle(true);

	        char theCharArray[512];
	        sprintf(theCharArray, theTitleText.c_str());

	        // Draw it

	        int theX = mViewport[0] + kPlayerStatusHorizontalCenteredInset*(mViewport[2] - mViewport[0]);
	        int theY = mViewport[1] + mViewport[3] - (1-kTitleYInset)*ScreenHeight();

	        int theR, theG, theB;
	        this->GetPrimaryHudColor(theR, theG, theB, true, false);

	        this->DrawHudStringCentered(theX, theY, ScreenWidth(), theCharArray, theR, theG, theB);
        }

	    // If we're parasited, draw a message as such
	    if (this->GetIsAlive())
	    {
		    string theText;
		    char theCharArray[512];
		    
		    int theR, theG, theB;
		    //UnpackRGB(theR, theG, theB, RGB_YELLOWISH);
		    this->GetPrimaryHudColor(theR, theG, theB, true, false);

		    int theSecondOfLastUpdate = (int)this->mTimeOfLastUpdate;
		    
		    // Draw blinking primal scream message
		    if(GetHasUpgrade(this->GetHUDUpgrades(), MASK_BUFFED) && (theSecondOfLastUpdate % 2))
		    {
                if(this->GetIsAlien())
                {
                    LocalizeString(kPrimalScreamed, theText);
                }
                else if(this->GetIsMarine())
                {
                    LocalizeString(kCatalysted, theText);
                }

                // Draw it
                sprintf(theCharArray, "%s", theText.c_str());
                this->DrawHudStringCentered(kPlayerStatusHorizontalCenteredInset*ScreenWidth(), kPlayerStatusVerticalInset*ScreenHeight(), ScreenWidth(), theCharArray, theR, theG, theB);
		    }

		    // Draw parasited indicator
		    if(GetHasUpgrade(this->GetHUDUpgrades(), MASK_PARASITED))
		    {
			    LocalizeString(kParasited, theText);
			    sprintf(theCharArray, "%s", theText.c_str());
			    
			    // Draw it
			    this->DrawHudStringCentered(kPlayerStatusHorizontalCenteredInset*ScreenWidth(), (kPlayerStatusVerticalInset+kPlayerStatusStatusSpacing)*ScreenHeight(), ScreenWidth(), theCharArray, theR, theG, theB);
		    }

		    // Draw umbraed indicator
		    if(GetHasUpgrade(this->GetHUDUpgrades(), MASK_UMBRA))
		    {
			    LocalizeString(kUmbraed, theText);
			    sprintf(theCharArray, "%s", theText.c_str());
			    
			    // Draw it
			    this->DrawHudStringCentered(kPlayerStatusHorizontalCenteredInset*ScreenWidth(), (kPlayerStatusVerticalInset+2*kPlayerStatusStatusSpacing)*ScreenHeight(), ScreenWidth(), theCharArray, theR, theG, theB);
		    }

		    // Draw blinking "webbed" message
		    if(GetHasUpgrade(this->GetHUDUpgrades(), MASK_ENSNARED) && (theSecondOfLastUpdate % 2))
		    {
			    LocalizeString(kWebbed, theText);
			    sprintf(theCharArray, "%s", theText.c_str());
			    
			    // Draw it
			    this->DrawHudStringCentered(kPlayerStatusHorizontalCenteredInset*ScreenWidth(), (kPlayerStatusVerticalInset+3*kPlayerStatusStatusSpacing)*ScreenHeight(), ScreenWidth(), theCharArray, theR, theG, theB);
		    }

		    // Draw "stunned" message (it's so fast, try not blinking it)
		    if(GetHasUpgrade(this->GetHUDUpgrades(), MASK_PLAYER_STUNNED) /*&& (theSecondOfLastUpdate % 2)*/)
		    {
			    LocalizeString(kStunned, theText);
			    sprintf(theCharArray, "%s", theText.c_str());
			    
			    // Draw it
			    this->DrawHudStringCentered(kPlayerStatusHorizontalCenteredInset*ScreenWidth(), (kPlayerStatusVerticalInset+4*kPlayerStatusStatusSpacing)*ScreenHeight(), ScreenWidth(), theCharArray, theR, theG, theB);
		    }

		    // Draw "being digested" or "digesting" message
		    if(this->GetIsBeingDigested() && (theSecondOfLastUpdate % 2))
		    {
			    LocalizeString(kDigested, theText);
			    sprintf(theCharArray, "%s", theText.c_str());
			    
			    // Draw it
			    this->DrawHudStringCentered(kPlayerStatusHorizontalCenteredInset*ScreenWidth(), (kPlayerStatusVerticalInset+5*kPlayerStatusStatusSpacing)*ScreenHeight(), ScreenWidth(), theCharArray, theR, theG, theB);
		    }
		    else if(this->GetIsDigesting() && (theSecondOfLastUpdate % 2))
		    {
			    // Look up player in progress entity
			    if((this->mProgressBarEntityIndex >= 1) && (this->mProgressBarEntityIndex <= gEngfuncs.GetMaxClients()))
			    {
				    hud_player_info_t thePlayerInfo;
				    gEngfuncs.pfnGetPlayerInfo(this->mProgressBarEntityIndex, &thePlayerInfo);

				    char* thePlayerName = thePlayerInfo.name;
				    if(thePlayerName)
				    {
					    LocalizeString(kDigestingPlayer, theText);
					    sprintf(theCharArray, theText.c_str(), thePlayerName);
				    }
			    }
			    
			    // Draw it
			    this->DrawHudStringCentered(kPlayerStatusHorizontalCenteredInset*ScreenWidth(), (kPlayerStatusVerticalInset+5*kPlayerStatusStatusSpacing)*ScreenHeight(), ScreenWidth(), theCharArray, theR, theG, theB);
		    }
		    
		    // If we are in a squad, draw it on our HUD
		    if(this->mCurrentSquad > 0)
		    {
			    string theSquadIndicator;
			    if(LocalizeString(kSquadIndicator, theSquadIndicator))
			    {
				    sprintf(theCharArray, theSquadIndicator.c_str(), this->mCurrentSquad);
				    
				    // Draw it
				    this->DrawHudStringCentered(kPlayerStatusHorizontalCenteredInset*ScreenWidth(), (kPlayerStatusVerticalInset+6*kPlayerStatusStatusSpacing)*ScreenHeight(), ScreenWidth(), theCharArray, theR, theG, theB);
			    }
		    }
	    }

	    // Draw the numerical effects.

	    if(this->GetIsAlive())
	    {
		    for(NumericalInfoEffectListType::iterator theIter = this->mNumericalInfoEffects.begin(); theIter != this->mNumericalInfoEffects.end(); theIter++)
		    {
			    // Draw it
			    Vector theScreenPos;
			    float theWorldPosition[3];
			    theIter->GetPosition(theWorldPosition);
			    if(AvHCUWorldToScreen(theWorldPosition, (float*)&theScreenPos))
			    {
				    float theNormX = theScreenPos.x/ScreenWidth();
				    float theNormY = theScreenPos.y/ScreenHeight();
				    if(!this->GetInTopDownMode() || !this->GetIsRegionBlockedByUI(theNormX, theNormY))
				    {
					    float theNumber = theIter->GetNumber();
					    string thePrependString("+");
					    
					    int theR, theG, theB;
					    this->GetPrimaryHudColor(theR, theG, theB, true, false);
					    if(theNumber < 0)
					    {
						    // Red, minus for negatives
						    theR = 255;
						    theG = 0;
						    theB = 0;
					    
						    // The "-" is prepended by MakeStringFromInt when negative
						    thePrependString = string("");
					    }
					    
					    const char* thePostPendStringToTranslate = NULL;
					    string thePostPendString;
					    
					    switch(theIter->GetEventType())
					    {
					    case kNumericalInfoResourcesEvent:
						    thePostPendStringToTranslate = kNumericalEventResources;
						    break;
					    case kNumericalInfoHealthEvent:
						    thePostPendStringToTranslate = kNumericalEventHealth;
						    break;
					    case kNumericalInfoResourcesDonatedEvent:
						    thePostPendStringToTranslate = kNumericalEventResourcesDonated;
						    break;
					    case kNumericalInfoAmmoEvent:
						    thePostPendStringToTranslate = kNumericalEventAmmo;
						    break;
					    }
					    
					    if(thePostPendStringToTranslate)
					    {
						    LocalizeString(thePostPendStringToTranslate, thePostPendString);
					    }
					    
					    // Don't draw 0, so we can have other messages
					    string theNumberString;
					    if(theNumber != 0)
					    {
						    theNumberString = thePrependString + MakeStringFromFloat(theNumber) + " ";
					    }
					    
					    string theDisplayString = theNumberString + thePostPendString;
					    
					    char theCharBuffer[512];
					    sprintf(theCharBuffer, "%s", theDisplayString.c_str());
					    
					    this->DrawHudStringCentered(theScreenPos.x, theScreenPos.y, ScreenWidth(), theCharBuffer, theR, theG, theB);
				    }
			    }
		    }
	    }
    
    }

	// Draw the combat HUD.
	
    if (this->GetIsCombatMode())
	{
		// Now draw our current experience level, so people know how close they are to the next level
		// Load alien resource and energy sprites
		string theSpriteName = UINameToSprite(kCombatExperienceSprite, ScreenWidth());
		int theExperienceSprite = Safe_SPR_Load(theSpriteName.c_str());
		
		if(theExperienceSprite)
		{
			const float kNormalizedWidth = .1f;
			const float kNormalizedYInset = .96f;
			const float kNormalizedHeight = .025f;
			const int kBaseIndex = this->GetIsMarine() ? 2 : 0;
			
			// Draw full background
			const int kXStart = mViewport[0] + (.5f - kNormalizedWidth/2.0f)*(mViewport[2] - mViewport[0]);
			const int kYStart = mViewport[1] + mViewport[3] - (1 - kNormalizedYInset)*ScreenHeight();
			

            AvHSpriteSetColor(1,1,1);
            AvHSpriteSetRenderMode(kRenderTransAlpha);

			AvHSpriteDraw(theExperienceSprite, kBaseIndex + 1, kXStart, kYStart, kXStart + kNormalizedWidth*ScreenWidth(), kYStart + kNormalizedHeight*ScreenHeight(), 0, 0, 1, 1);
			
			// Draw overlay showing amount of experience
			float thePercentToNextLevel = AvHPlayerUpgrade::GetPercentToNextLevel(this->GetHUDExperience());
			if((thePercentToNextLevel >= 0.0f) && (thePercentToNextLevel <= 1.0f))
            {
    			AvHSpriteDraw(theExperienceSprite, kBaseIndex, kXStart, kYStart, kXStart + thePercentToNextLevel*kNormalizedWidth*ScreenWidth(), kYStart + kNormalizedHeight*ScreenHeight(), 0, 0, thePercentToNextLevel, 1.0f);
            }
		}
		
		if(this->GetIsAlive(false))
		{
			int theR, theG, theB;
			this->GetPrimaryHudColor(theR, theG, theB, false, false);
			this->mCombatUpgradeMenu.SetR(theR);
			this->mCombatUpgradeMenu.SetG(theG);
			this->mCombatUpgradeMenu.SetB(theB);

			this->mCombatUpgradeMenu.Draw();
		}
	}

	// Draw top down help
	if(this->GetInTopDownMode())
	{
		this->mTopDownActionButtonHelp.Draw();
	}

}

void AvHHud::RenderMiniMap(int inX, int inY, int inWidth, int inHeight)
{
    
    AvHOverviewMap& theOverviewMap = gHUD.GetOverviewMap();

    AvHOverviewMap::DrawInfo theDrawInfo;
    
    theDrawInfo.mX          = inX;
    theDrawInfo.mY          = inY;
    theDrawInfo.mWidth      = inWidth;
    theDrawInfo.mHeight     = inHeight;
    theDrawInfo.mFullScreen = false;

    float worldViewWidth = 800.0f;
    
    float aspectRatio = (float)(theDrawInfo.mHeight) / theDrawInfo.mWidth;

    float thePlayerX;
    float thePlayerY;

    theOverviewMap.GetWorldPosition(thePlayerX, thePlayerY);

    theDrawInfo.mViewWorldMinX = thePlayerX - worldViewWidth;
    theDrawInfo.mViewWorldMinY = thePlayerY - worldViewWidth * aspectRatio;
    theDrawInfo.mViewWorldMaxX = thePlayerX + worldViewWidth;
    theDrawInfo.mViewWorldMaxY = thePlayerY + worldViewWidth * aspectRatio;

    theOverviewMap.Draw(theDrawInfo);

}

void AvHHud::RenderMarineUI()
{

	int theR, theG, theB;
	this->GetPrimaryHudColor(theR, theG, theB, false, false);


    if (mMarineTopSprite && (this->mMapMode == MAP_MODE_NS))
    {
	    
        float theX;
        float theY;
        float theWidth  = .75f*ScreenWidth();
	    float theHeight = ((float)256/768)*ScreenHeight();

        AvHSpriteSetRenderMode(kRenderTransAdd);
        AvHSpriteSetColor(1,1,1);
        AvHSpriteDrawTiles(mMarineTopSprite, 3, 1, mViewport[2] - theWidth + mViewport[0],
            mViewport[1], mViewport[2] + mViewport[0], mViewport[1] + theHeight, 0, 0, 1, 1);

        // Draw the minimap.

        int theMiniMapX = mViewport[2] - 0.21f * ScreenWidth() + mViewport[0];
        int theMiniMapY = mViewport[1] + 0.013 * ScreenHeight();
        int theMiniMapWidth =  0.200 * ScreenWidth();
        int theMiniMapHeight = 0.202 * ScreenHeight();

        RenderMiniMap(theMiniMapX, theMiniMapY, theMiniMapWidth, theMiniMapHeight);

        // Draw the resource label.
		
        theHeight = ScreenHeight() * 0.038;

        std::string theResourceText;
        char theResourceBuffer[64];
        
        LocalizeString(kMarineResourcePrefix, theResourceText);
		_snprintf(theResourceBuffer, 64, "%s %d", theResourceText.c_str(), this->mVisualResources);
        
        theX = mViewport[0] + 0.3 * ScreenWidth();
        theY = mViewport[1] + 0.007 * ScreenHeight() + (theHeight - GetSmallFont().GetStringHeight()) / 2;
        
        GetSmallFont().DrawString(theX, theY, theResourceBuffer, theR, theG, theB);

        // Draw the commander status label.

        std::string theCommanderName;
        bool theCommanderNameVisible = true;
        
        if (!GetCommanderLabelText(theCommanderName))
        {
            // Blink if there is no commander.
		    if ((int)this->mTimeOfLastUpdate % 2)
		    {
			    theCommanderNameVisible = false;
		    }
        }

        if (theCommanderNameVisible)
        {
        
            theX = mViewport[0] + 0.50 * ScreenWidth();
            theY = mViewport[1] + 0.006 * ScreenHeight() + (theHeight - GetSmallFont().GetStringHeight()) / 2;
        
            GetSmallFont().DrawString(theX, theY, theCommanderName.c_str(), theR, theG, theB);
        
        }

    }

    AvHSpriteEnableClippingRect(false);

    // TODO: Draw various marine upgrades (assumes 256x256 sprite, with each upgrade being 64x64, listed right to left, top to bottom, armor upgrades first, 
	// weapon upgrades next, then motion-tracking, then jetpacks, then exoskeleton)
	
	// Do we have a jetpack?
	if(GetHasUpgrade(this->GetHUDUpgrades(), MASK_UPGRADE_7))
	{
		// Draw jetpack energy indicator
		if(this->mMarineUIJetpackSprite)
		{
			float theFactor = 1 - pmove->fuser3/kNormalizationNetworkFactor;
			int theFrame = 0;
	
			string theOutputMessage;
			if(LocalizeString(kJetpackEnergyHUDText, theOutputMessage))
			{
			
                float theX = .9f*ScreenWidth();
                float theY = .8f*ScreenHeight();
                float theWidth = .02f*ScreenWidth();
                float theHeight = .1f*ScreenHeight();

                AvHSpriteSetRenderMode(kRenderTransAdd);
                AvHSpriteSetColor(1,1,1);
                                
                AvHSpriteDraw(mMarineUIJetpackSprite, 0, theX, theY, theX + theWidth, theY + theHeight * theFactor, 0, 0, 1, theFactor);    
                AvHSpriteDraw(mMarineUIJetpackSprite, 1, theX, theY + theHeight * theFactor, theX + theWidth, theY + theHeight, 0, theFactor, 1, 1);

            }
		}
	}


	const int kNumUpgradesToDraw = 4;
	AvHUpgradeMask kUpgradeToMaskTable[kNumUpgradesToDraw] = {MASK_UPGRADE_4, MASK_UPGRADE_1, MASK_UPGRADE_8, MASK_UPGRADE_7};

    const float kAspectRatio = ScreenWidth()/ScreenHeight();
	
	const float kNormalizedSpacing = 0.01f;
	const int kBaseRightOffset = kNormalizedSpacing*ScreenWidth();
	const int kVerticalUpgradeSpacing = kNormalizedSpacing*kAspectRatio*ScreenHeight();
	int theUpgradeVar = this->GetHUDUpgrades();
	const int kUpgradeFrame = 0;
	const float kUpgradeSize = 0.05;
	int theUpgradeWidth = kUpgradeSize*ScreenWidth();
	int theUpgradeHeight = kUpgradeSize*kAspectRatio*ScreenHeight();
    
    for(int i = 0; i < kNumUpgradesToDraw; i++)
	{
		AvHUpgradeMask theUpgradeMask = kUpgradeToMaskTable[i];

		// Draw highest ammo upgrade level
		if(theUpgradeMask == MASK_UPGRADE_4)
		{
			if(GetHasUpgrade(theUpgradeVar, MASK_UPGRADE_5))
			{
				theUpgradeMask = MASK_UPGRADE_5;
				
				if(GetHasUpgrade(theUpgradeVar, MASK_UPGRADE_6))
				{
					theUpgradeMask = MASK_UPGRADE_6;
				}
			}
		}

		// Draw highest armor level
		if(theUpgradeMask == MASK_UPGRADE_1)
		{
			if(GetHasUpgrade(theUpgradeVar, MASK_UPGRADE_2))
			{
				theUpgradeMask = MASK_UPGRADE_2;
				
				if(GetHasUpgrade(theUpgradeVar, MASK_UPGRADE_3))
				{
					theUpgradeMask = MASK_UPGRADE_3;
				}
			}
		}

		// Draw heavy armor instead of jetpacks if they have it
		if(theUpgradeMask == MASK_UPGRADE_7)
		{
			if(GetHasUpgrade(theUpgradeVar, MASK_UPGRADE_13))
			{
				theUpgradeMask = MASK_UPGRADE_13;
			}
		}
		
		if(GetHasUpgrade(theUpgradeVar, theUpgradeMask))
		{
			int theFrame = 0;

			switch(theUpgradeMask)
			{
			case MASK_UPGRADE_4:
				theFrame = 0;
				break;
			case MASK_UPGRADE_5:
				theFrame = 1;
				break;
			case MASK_UPGRADE_6:
				theFrame = 2;
				break;
			case MASK_UPGRADE_1:
				theFrame = 3;
				break;
			case MASK_UPGRADE_2:
				theFrame = 4;
				break;
			case MASK_UPGRADE_3:
				theFrame = 5;
				break;
			case MASK_UPGRADE_8:
				theFrame = 6;
				break;
			case MASK_UPGRADE_7:
				theFrame = 7;
				break;
			case MASK_UPGRADE_13:
				theFrame = 8;
				break;
			}

			float theStartU = (theFrame % 4)*.25f;
			float theStartV = (theFrame / 4)*.333f;
			float theEndU = theStartU + .25f;
			float theEndV = theStartV + .333f;
			
			const int kBaseX = ScreenWidth() - .05*ScreenWidth();
			const int kBaseY = .75*ScreenHeight();
			const int kIconWidth = .05*ScreenWidth();
			const int kIconHeight = .05*ScreenHeight();
			
            float x1 = kBaseX;
            float y1 = kBaseY + i*kIconHeight;
            float x2 = x1 + kIconWidth;
            float y2 = y1 + kIconHeight;
            
			AvHSpriteSetRenderMode(kRenderTransAdd);
			AvHSpriteEnableClippingRect(false);
			AvHSpriteSetColor(1, 1, 1, this->GetGammaSlope());
            AvHSpriteDraw(mMarineUpgradesSprite, 0, x1, y1, x2, y2, theStartU, theStartV, theEndU, theEndV);
        
        }
	}

}

void AvHHud::RenderCommanderUI()
{

    RenderStructureRanges();

	// Draw command button
	if(this->mCommandButtonSprite)
	{
		// Animate the button unless the mouse is over it (?)
		int kNumFrames = 16; // Last frame is highlighted, first frame seems off
		const float kFramesPerSecond = 10;
		const float kCycleTime = (1.0f/kFramesPerSecond)*kNumFrames;

		float theNumCycles =  this->mTimeOfLastUpdate/kCycleTime;
		int theFrame = 1 + (theNumCycles - (int)theNumCycles)*kNumFrames;

		const int kStartX = 890;
		int theX = (kStartX/1024.0f)*ScreenWidth();
		int theY = (525/768.0f)*ScreenHeight();
		
		float theWidth = ((1024 - kStartX)/1024.0f)*ScreenWidth();
		float theHeight = (38/768.0f)*ScreenHeight();

        float x1 = theX;
        float y1 = theY;
        float x2 = x1 + theWidth;
        float y2 = y1 + theHeight;

        AvHSpriteSetRenderMode(kRenderTransAlpha);
        AvHSpriteDraw(mCommandButtonSprite, theFrame, x1, y2, x2, y2, 0, 0, 1, 1);
    
    }

	// Draw "select all" button
	if(this->mSelectAllSprite)
	{
		AvHTechImpulsePanel* theTechImpulsePanel = NULL;
		if(this->GetManager().GetVGUIComponentNamed(kSelectAllImpulsePanel, theTechImpulsePanel))
		{
			if(theTechImpulsePanel->isVisible())
			{
				int theX, theY;
				theTechImpulsePanel->getPos(theX, theY);
				
				int theWidth, theHeight;
				theTechImpulsePanel->getSize(theWidth, theHeight);
				
				// Draw unhighlighted, highlighted, or active
				int theFrame = 0;
				
				// If mouse is over, use frame 1
				if(this->GetIsMouseInRegion(theX, theY, theWidth, theHeight))
				{
					theFrame = 1;
				}
				
				// If all troops selected, use frame 2
				if((this->mSelected.size()) > 0 && (this->mSelected == this->mSelectAllGroup))
				{
					theFrame = 2;
				}
				
                AvHSpriteSetRenderMode(kRenderTransAlpha);
			    AvHSpriteDraw(mSelectAllSprite, theFrame, theX, theY, theX + theWidth, theY + theHeight, 0, 0, 1, 1);
            
            }
		}
	}
	
	// Draw blinking "under attack" indicator
	if(this->mCommandStatusSprite)
	{
		int theFrame = 0;
		
		int theX = (725/1024.0f)*ScreenWidth();
		int theY = (702/768.0f)*ScreenHeight();
		
		float theWidth = (61.5f/1024.0f)*ScreenWidth();
		float theHeight = (66/768.0f)*ScreenHeight();
		
		// Blink button when an alert is set!
		if(this->mBlinkingAlertType)
		{
			int theSecondOfLastUpdate = (int)this->mTimeOfLastUpdate;
			if(theSecondOfLastUpdate % 2)
			{
				theFrame = this->mBlinkingAlertType;
			}
		}

        AvHSpriteSetRenderMode(kRenderTransAlpha);
	    AvHSpriteDraw(mCommandStatusSprite, theFrame, theX, theY, theX + theWidth, theY + theHeight, 0, 0, 1, 1);
    
    }
	
	if(this->mTopDownTopSprite)
	{
		float theHeight = ((float)128/768)*ScreenHeight();
        AvHSpriteDrawTiles(mTopDownTopSprite, 4, 1, 0, 0, ScreenWidth(), theHeight, 0, 0, 1, 1);
	}

	if(this->mTopDownBottomSprite)
	{
		// The artwork is three 128s high
		float theHeight = ((float)256/768)*ScreenHeight();
        AvHSpriteSetRenderMode(kRenderTransAlpha);
        AvHSpriteDrawTiles(mTopDownBottomSprite, 4, 1, 0, ScreenHeight()-theHeight, ScreenWidth(), ScreenHeight(), 0, 0, 1, 1);
	}

	// Draw scaled sprites for all ActionButtons
	this->DrawActionButtons();

	// Draw hotgroups
	this->DrawHotgroups();

	// Draw pending requests
	this->DrawPendingRequests();
	
    // Draw logout button
	if(this->mLogoutSprite)
	{
		int theFrame = 0;

		int theX = .785*ScreenWidth();
		int theY = .013*ScreenHeight();
		
		float theWidth = .197f*ScreenWidth();
		float theHeight = .083f*ScreenHeight();

		// Detect mouseover
		if(this->GetIsMouseInRegion(theX, theY, theWidth, theHeight))
		{
			theFrame = 1;
		}

        AvHSpriteSetRenderMode(kRenderTransAlpha);
        AvHSpriteDraw(mLogoutSprite, theFrame, theX, theY, theX + theWidth, theY + theHeight, 0, 0, 1, 1);
    
    }

}

void AvHHud::RenderStructureRanges()
{

    float theRangeR = 0;
    float theRangeG = 1;
    float theRangeB = 0;
    float theRangeA = 0.2f;

	// Draw range for current ghost building, if applicable
	EntityListType theEntities;
	IntList theDistanceRequirements;
	float theZAdjustment = 0.0f;
	bool theSnapToLocation = false;
	bool theDrewGhostRegions = false;
	
	AvHSHUGetBuildRegions(this->mGhostBuilding, theEntities, theDistanceRequirements, theZAdjustment, theSnapToLocation);

	// For each entity to draw
	int theDistanceCounter = 0;
	for(EntityListType::iterator theRangeIter = theEntities.begin(); theRangeIter != theEntities.end(); theRangeIter++, theDistanceCounter++)
	{
		//cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(*theRangeIter);
		physent_t* theEntity = gEngfuncs.pEventAPI->EV_GetPhysent(*theRangeIter);
		if(theEntity)
		{
			vec3_t thePosition;
			thePosition = AvHSHUGetRealLocation(theEntity->origin, theEntity->mins, theEntity->maxs);

			//int theSprite = (theEntity->iuser3 == AVH_USER3_SIEGETURRET) ? this->mSiegeTurretSprite : this->mBuildCircleSprite;
			int theSprite = this->mBuildCircleSprite;

			int theDistanceRequirement = theDistanceRequirements[theDistanceCounter];
			RenderStructureRange(thePosition, theDistanceRequirement, theSprite, kRenderTransAdd, 0, theRangeR, theRangeG, theRangeB, theRangeA);

			theDrewGhostRegions = true;
		}
	}

    // Draw selection as well
	for(EntityListType::iterator theSelectedIter = this->mSelected.begin(); theSelectedIter != this->mSelected.end(); theSelectedIter++)
	{
		cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(*theSelectedIter);
		//physent_t* theEntity = gEngfuncs.pEventAPI->EV_GetPhysent(*theSelectedIter);
		if(theEntity)
		{
			vec3_t thePosition;
			thePosition = AvHSHUGetRealLocation(theEntity->curstate.origin, theEntity->curstate.mins, theEntity->curstate.maxs);
			
			AvHUser3 theUser3 = (AvHUser3)(theEntity->curstate.iuser3);
			int theRange = AvHSHUGetDrawRangeForUser3(theUser3);
			if(theRange > 0)
			{
				// Don't draw structures that are recycling and therefore inactive
				if(!GetHasUpgrade(theEntity->curstate.iuser4, MASK_RECYCLING))
				{
					//int theSprite = (theEntity->curstate.iuser3 == AVH_USER3_SIEGETURRET) ? this->mSiegeTurretSprite : this->mBuildCircleSprite;
					int theSprite = this->mBuildCircleSprite;
					RenderStructureRange(thePosition, theRange, theSprite, kRenderTransAdd, 0, theRangeR, theRangeG, theRangeB, theRangeA);
				}
				else
				{
					int a = 0;
				}
			}
		}
	}

    // Draw the minimum build radius violations.

    EntityListType theBuildViolations;
    AvHSHUGetMinBuildRadiusViolations(mGhostBuilding, mGhostWorldLocation, theBuildViolations);
   


	for (EntityListType::iterator theBuildViolationsIter = theBuildViolations.begin(); theBuildViolationsIter != theBuildViolations.end(); theBuildViolationsIter++)
	{	
		gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );
		
		// Store off the old count
		gEngfuncs.pEventAPI->EV_PushPMStates();
		
		// Now add in all of the players.
		gEngfuncs.pEventAPI->EV_SetSolidPlayers (-1);

		physent_t* theEntity = gEngfuncs.pEventAPI->EV_GetPhysent(*theBuildViolationsIter);

		gEngfuncs.pEventAPI->EV_PopPMStates();
			
		if(theEntity)
		{
			vec3_t thePosition;
			thePosition = AvHSHUGetRealLocation(theEntity->origin, theEntity->mins, theEntity->maxs);
			
			AvHUser3 theUser3 = (AvHUser3)(theEntity->iuser3);

            vec3_t theMinSize, theMaxSize;

            AvHSHUGetSizeForUser3(theUser3, theMinSize, theMaxSize);
            float theMaxRadius2 = max(max(theMinSize.x, theMaxSize.x), max(theMinSize.y, theMaxSize.y));

            int theSprite = this->mBuildCircleSprite;
			// joev: 0000291 
			// It's possible to place "on" marines if you're offset a little from center. This code and 
			// associated changes above and in AvHSharedUtil.cpp is to enforce a build distance around marines,
			// in the same way as structures, to prevent this exploit.
 			float theMinMarineBuildDistance;
            if (theUser3 == AVH_USER3_MARINE_PLAYER) {
				theMinMarineBuildDistance = BALANCE_FVAR(kMinMarinePlayerBuildDistance);
			}
			else 
			{
				theMinMarineBuildDistance = BALANCE_FVAR(kMinMarineBuildDistance);
			}
			// :joev
			RenderStructureRange(thePosition, theMinMarineBuildDistance + theMaxRadius2, theSprite, kRenderTransAdd, 0, 1, 0, 0, 0.3f);

		}
	}
}

void AvHHud::RenderStructureRange(vec3_t inOrigin, int inRadius, HSPRITE inSprite, int inRenderMode, int inFrame, float inR, float inG, float inB, float inAlpha)
{

    vec3_t w1;
    
    w1[0] = inOrigin[0] - inRadius;
    w1[1] = inOrigin[1] - inRadius;
    w1[2] = inOrigin[2];
    
    vec3_t s1;
    gEngfuncs.pTriAPI->WorldToScreen(w1, s1);

    vec3_t w2;
    
    w2[0] = inOrigin[0] + inRadius;
    w2[1] = inOrigin[1] + inRadius;
    w2[2] = inOrigin[2];
    
    vec3_t s2;
    gEngfuncs.pTriAPI->WorldToScreen(w2, s2);

    float x1 = XPROJECT(s1[0]);
    float y1 = YPROJECT(s1[1]);
    float x2 = XPROJECT(s2[0]);
    float y2 = YPROJECT(s2[1]);

    AvHSpriteSetColor(inR, inG, inB, inAlpha);
    AvHSpriteSetRenderMode(inRenderMode);
    AvHSpriteDraw(inSprite, inFrame, x1, y1, x2, y2, 0, 0, 1, 1);
    AvHSpriteSetColor(1, 1, 1, 1);

}

void AvHHud::RenderAlienUI()
{

	const float kAspectRatio = ScreenWidth()/ScreenHeight();

    // Draw the embryo overlay if the player is gestating.

    if (GetHUDUser3() == AVH_USER3_ALIEN_EMBRYO)
    {
		if (mMembraneSprite)
		{
            AvHSpriteSetRenderMode(kRenderTransAdd);
            AvHSpriteSetColor(1,1,1);
            DrawWarpedOverlaySprite(mMembraneSprite, 4, 3, .007 * 2, .002 * 2, .15, .3);
		}
        return;
    }

    AvHSpriteSetRenderMode(kRenderTransAlpha);

    int theWidth = kResourceEnergyBarWidth*ScreenWidth();
    int theHeight = kResourceEnergyBarHeight*ScreenHeight();

    int theX = mViewport[0];
    int theY = mViewport[3] - theHeight + mViewport[1];

	// Draw resource text label.

    if (!mSteamUIActive)
    {

	    const float kTextInset = kResourceEnergyBarWidth*.5f;
	    const int kNumericYOffset = 1.5*this->GetHudStringHeight();

        int theResourceLabelX = mViewport[0] + kTextInset*ScreenWidth();
	    int theResourceLabelY = theY -  + .05f * ScreenHeight();
	    
		if(this->mMapMode == MAP_MODE_NS)
		{
			string theLocalizedResourceDescription;
			if(LocalizeString(kAlienResourcePrefix, theLocalizedResourceDescription))
			{
				int theStringWidth = this->GetHudStringWidth(theLocalizedResourceDescription.c_str());
				int theR, theG, theB;
				this->GetPrimaryHudColor(theR, theG, theB, false, false);
				this->DrawHudString(theResourceLabelX, theResourceLabelY, ScreenWidth(), theLocalizedResourceDescription.c_str(), theR, theG, theB);
			}

			// Draw amount we have
			char theBuffer[128];
			sprintf(theBuffer, "(%d/%d)", this->mVisualResources, this->GetMaxAlienResources());
			this->DrawTranslatedString(theResourceLabelX, theResourceLabelY + kNumericYOffset, theBuffer);
		}
    }
    
    // Draw energy bar.

    if (mAlienUIEnergySprite)
    {
        theX = mViewport[2] - theWidth + mViewport[0];

        float theFactor = 1 - this->mVisualEnergyLevel;
        
        AvHSpriteSetColor(1,1,1);
        AvHSpriteSetRenderMode(kRenderTransTexture);

        AvHSpriteDraw(mAlienUIEnergySprite, 0, theX, theY, theX + theWidth, theY + theHeight * theFactor, 0, 0, 1, theFactor);    
        AvHSpriteDraw(mAlienUIEnergySprite, 1, theX, theY + theHeight * theFactor, theX + theWidth, theY + theHeight, 0, theFactor, 1, 1);

    }

	// Draw hive indicators.

    if (mHiveInfoSprite) //  && (this->mMapMode == MAP_MODE_NS)) // removed check to enable hive with health to be shown in combat
    {

	    int theHiveIndex = 0;

	    for (HiveInfoListType::iterator theIter = this->mHiveInfoList.begin(); theIter != this->mHiveInfoList.end(); theIter++, theHiveIndex++)
        {

	        // For this hive, figure out which frame to draw

		    int theFrame = theIter->mStatus;
		    
		    // If under attack, make it blink red
		    int theSecondOfLastUpdate = (int)this->mTimeOfLastUpdate;
		    if(theIter->mUnderAttack && (theSecondOfLastUpdate % 2))
		    {
			    theFrame = kHiveInfoStatusUnderAttack;
		    }

            int theHiveWidth = kHiveNormScreenWidth*ScreenWidth();

		    // Draw hive
		    //float theNormX = theHiveWidth;
		    float theNormY = kHiveNormScreenY + kHiveNormScreenVerticalSpacing*theHiveIndex;
		    
            //DrawScaledHUDSprite(this->mHiveInfoSprite, kRenderTransAlpha, 1, theNormX*ScreenWidth, theNormY*ScreenHeight(), kHiveNormScreenWidth*ScreenWidth, kHiveNormScreenHeight*ScreenHeight(), theFrame);
            
            float x1 = mViewport[0] + mViewport[2] - theHiveWidth;
            float y1 = mViewport[1] + theNormY*ScreenHeight();
            float x2 = x1 + theHiveWidth;
            float y2 = y1 + kHiveNormScreenHeight*ScreenHeight();
            
            AvHSpriteSetColor(1,1,1);
            AvHSpriteSetRenderMode(kRenderTransTexture);
            AvHSpriteDraw(mHiveInfoSprite, theFrame, x1, y1, x2, y2, 0, 0, 1, 1);

//            AvHSpriteSetColor(1,1,1);
//            AvHSpriteSetRenderMode(kRenderTransTexture);
//			AvHSpriteDraw(mHiveHealthSprite, 0, x1, y1, x1+100, y1+100,  0, 0, 1, 1);

			
			// use the hive sprite height for the hivehealth sprite height and width
			float theHealthSpriteHeight = (float)(kHiveNormScreenHeight) *ScreenHeight();
			float theHealthSpriteWidth = theHealthSpriteHeight;
			
			AvHSpriteSetColor(1,1,1);
            AvHSpriteSetRenderMode(kRenderTransTexture);

			// adjust the position for the sprite -- to the left
			float w1 = mViewport[0] + mViewport[2] - (kHiveNormScreenWidth + 0.02f)*ScreenWidth();

			AvHSpriteDraw(mHiveHealthSprite, 0, w1, y1, w1 + theHealthSpriteWidth, y1 + theHealthSpriteHeight,  0, 0, 1, 1);
			
			if (theIter->mStatus > 0) {
				if (theIter->mHealthPercentage < 100) {
					AvHSpriteDraw(mHiveHealthSprite, 0, w1, y1, w1 + theHealthSpriteWidth, y1 + theHealthSpriteHeight,  0, 0, 1, 1);
					AvHSpriteDraw(mHiveHealthSprite, 1, 
						w1, y1 + theHealthSpriteHeight - theHealthSpriteHeight * ((float)(theIter->mHealthPercentage) * 0.92f / 100),
						w1 + theHealthSpriteWidth, y1 + theHealthSpriteHeight,  
						0, 1 - ((float)(theIter->mHealthPercentage) * 0.92f / 100), 
						1, 1);
				} else {
					AvHSpriteDraw(mHiveHealthSprite, 1, w1, y1, w1 + theHealthSpriteWidth, y1 + theHealthSpriteHeight,  0, 0, 1, 1);
				}
			}



		    // Draw technology it's supporting
		    AvHMessageID theTechnology = (AvHMessageID)theIter->mTechnology;
		    theFrame = -1;
		    switch(theTechnology)
		    {
		    case ALIEN_BUILD_DEFENSE_CHAMBER:
			    theFrame = 0;
			    break;
		    case ALIEN_BUILD_SENSORY_CHAMBER:
			    theFrame = 3;
			    break;
		    case ALIEN_BUILD_MOVEMENT_CHAMBER:
			    theFrame = 2;
			    break;
		    }

		    // Draw it inset
		    if(theFrame >= 0)
		    {
			    
                float x1 = mViewport[0] + mViewport[2] - theHiveWidth + (kHiveTechnologyInsetXScalar*kHiveNormScreenWidth)*ScreenWidth();
                float y1 = mViewport[1] + (theNormY + kHiveTechnologyInsetYScalar*kHiveNormScreenHeight)*ScreenHeight();
                float x2 = x1 + kHiveTechnologyInsetWidthScalar*kHiveNormScreenWidth*ScreenWidth();
                float y2 = y1 + kHiveTechnologyInsetHeightScalar*kHiveNormScreenHeight*ScreenHeight();
                
                AvHSpriteDraw(mAlienUIUpgradeCategories, theFrame, x1, y1, x2, y2, 0, 0, 1, 1);    

		    }

        }
    
    }

    // Draw the upgrades.

	const int kNumberXInset = 2;
	const int kNumberYInset = 2;
	
	const int kBaseYOffset = .1*ScreenHeight();
	
	// Now draw alien upgrades
	const float kNormalizedSpacing = 0.01f;
	const int kBaseRightOffset = kNormalizedSpacing*ScreenWidth();
	const int kVerticalUpgradeSpacing = kNormalizedSpacing*kAspectRatio*ScreenHeight();
	int theUpgradeVar = this->GetHUDUpgrades();
	const int kUpgradeFrame = 0;
	const float kUpgradeSize = 0.05;
	int theUpgradeWidth = kUpgradeSize*ScreenWidth();
	int theUpgradeHeight = kUpgradeSize*kAspectRatio*ScreenHeight();
	
	// In Combat mode, we can have multiple upgrades in each category
	int theNumDrawnInCategory[ALIEN_UPGRADE_CATEGORY_MAX_PLUS_ONE + 1];
	memset(theNumDrawnInCategory, 0, sizeof(int)*(ALIEN_UPGRADE_CATEGORY_MAX_PLUS_ONE + 1));
	
	AvHUpgradeMask theUpgradeMasks[kNumAlienUpgrades] = {MASK_UPGRADE_1, MASK_UPGRADE_2, MASK_UPGRADE_3, MASK_NONE, MASK_NONE, MASK_NONE, MASK_UPGRADE_4, MASK_UPGRADE_5, MASK_UPGRADE_6, MASK_UPGRADE_7, MASK_UPGRADE_8, MASK_UPGRADE_9};
	for(int i = 0; i < kNumAlienUpgrades; i++)
	{
		AvHUpgradeMask theUpgradeMask = theUpgradeMasks[i];
		AvHAlienUpgradeCategory theCategory = ALIEN_UPGRADE_CATEGORY_INVALID;
		AvHGetAlienUpgradeCategoryFromMask(theUpgradeMask, theCategory);
		
		int theCategoryNumber = (int)theCategory;
		//int theRowNumber = i % (kNumAlienUpgrades/kNumAlienUpgradeCategories);

		// Quick hack: treat defense as offense for drawing purposes, because offense has been (temporarily?) removed
		int theCategoryNumberOffset = (int)(((theCategory == ALIEN_UPGRADE_CATEGORY_DEFENSE) ?  ALIEN_UPGRADE_CATEGORY_OFFENSE : theCategory));
		int theX = ScreenWidth() - theUpgradeWidth - kBaseRightOffset;

		// Inset drawing of multiple upgrades in same category (needed for Combat mode)
		theX -= (theNumDrawnInCategory[theCategory]*theUpgradeWidth);
		
		int theEnergyHeight = kResourceEnergyBarHeight*ScreenHeight();

		int theY = (3*kHiveNormScreenVerticalSpacing)*ScreenHeight() + kVerticalUpgradeSpacing + theCategoryNumberOffset*(kVerticalUpgradeSpacing + theUpgradeHeight);
		
		if(GetHasUpgrade(theUpgradeVar, theUpgradeMask))
		{
			theNumDrawnInCategory[theCategory]++;

			int theLevelOfUpgrade = AvHGetAlienUpgradeLevel(theUpgradeVar, theUpgradeMask);
			for(int theLevel = 0; theLevel < theLevelOfUpgrade; theLevel++)
			{
				// Draw them slightly overlapping
				const float kOffset = .01f;
			
                float x1 = theX - theLevel*(kOffset*ScreenWidth());
                float y1 = theY - theLevel*(kOffset*ScreenHeight());
                float x2 = x1 + theUpgradeWidth;
                float y2 = y1 + theUpgradeHeight;

                AvHSpriteDraw(mAlienUIUpgrades, i, x1, y1, x2, y2, 0, 0, 1, 1);
            }
		}
		else
		{
			if(this->GetGameStarted() && !this->GetIsCombatMode())
			{
				// If upgrade is pending, draw it blinking
				for(int i = 0; i < this->mNumUpgradesAvailable; i++)
				{
					if(this->mCurrentUpgradeCategory[i] == theCategory)
					{
						int theSecondOfLastUpdate = (int)this->mTimeOfLastUpdate;
						if(theSecondOfLastUpdate % 2)
						{
							int theFrame = theCategory-1;
						
							float x1 = theX;
							float y1 = theY;
							float x2 = x1 + theUpgradeWidth;
							float y2 = y1 + theUpgradeHeight;

							AvHSpriteDraw(mAlienUIUpgradeCategories, theFrame, x1, y1, x2, y2, 0, 0, 1, 1);
                    	}
						break;
					}
				}
			}
		}
	}


    if(this->GetIsAlien() && (this->GetHUDTeam() != TEAM_IND))
	{
		bool theIsGestating = (this->GetHUDUser3() == AVH_USER3_ALIEN_EMBRYO);
		bool theIsBeingDigested = this->GetIsBeingDigested();

		this->mSelectedNodeResourceCost = -1;
		
		// Find the blip nearest our view reticle
		int theNearestBlip = -1;
		float theDotProductOfClosestBlip = -1;
		
		// Get view vector
		Vector theViewVector;
		vec3_t theForward, theRight, theUp;
		AngleVectors(v_angles, theForward, theRight, theUp);
		VectorNormalize(theForward);

		for(int theBlip = 0; theBlip < this->mFriendlyBlips.mNumBlips; theBlip++)
		{
			// Get vector to current blip
			Vector theVectorToBlip;
			VectorSubtract(this->mFriendlyBlips.mBlipPositions[theBlip], gPredictedPlayerOrigin, theVectorToBlip);
			VectorNormalize(theVectorToBlip);

			// Dot them
			float theDotProduct = DotProduct(theForward, theVectorToBlip);

			// Is dot product closer to 1 then best?
			if(theDotProduct > theDotProductOfClosestBlip)
			{
				// Save new blip and dot product
				theNearestBlip = theBlip;
				theDotProductOfClosestBlip = theDotProduct;
			}
		}
			
		// Draw information about our friendly blips
		theBlip = theNearestBlip;
		if(theNearestBlip >= 0)
		{
			ASSERT(theNearestBlip < this->mFriendlyBlips.mNumBlips);

			// Draw location when player under attack
			int theBlipStatus = this->mFriendlyBlips.mBlipStatus[theBlip];
			//if((theBlipStatus == kVulnerableFriendlyBlipStatus) || ((theBlipStatus >= kSayingOne) && (theBlipStatus <= kSayingSix)))
			//{
				// Get location
				string theLocationName = this->GetNameOfLocation(this->mFriendlyBlips.mBlipPositions[theBlip]);
				
				// Get name of entity
				string theBlipName;
				
				int theBlipInfo = this->mFriendlyBlips.mBlipInfo[theBlip];
				if(theBlipInfo <= kBaseBlipInfoOffset)
				{
					hud_player_info_t thePlayerInfo;
					gEngfuncs.pfnGetPlayerInfo(theBlipInfo, &thePlayerInfo);
					if(thePlayerInfo.name)
					{
						theBlipName = thePlayerInfo.name;
					}
				}
				else
				{
					AvHUser3 theUser3 = AvHUser3(theBlipInfo - kBaseBlipInfoOffset);
					this->GetTranslatedUser3Name(theUser3, theBlipName);
				}
				
				string theBlipStatusText;
				char theBlipStatusString[512];
				sprintf(theBlipStatusString, "#%s%d", kBlipStatusPrefix, theBlipStatus);
				LocalizeString(theBlipStatusString, theBlipStatusText);
				
				Vector theScreenPos;
				Vector theMessageWorldPos = this->mFriendlyBlips.mBlipPositions[theBlip];
				const float kSpacingScalar = 1.2f;
				theMessageWorldPos.z -= (kWorldBlipScale/2.0f)*kSpacingScalar;

				if(AvHCUWorldToScreen(theMessageWorldPos, (float*)&theScreenPos))
				{
					if((theBlipName != "") && (theBlipStatusText != "") && (theLocationName != ""))
					{
						// "MonsieurEvil is under attack"
						// "Resource tower is under attack"
						char theFirstLine[512];
						sprintf(theFirstLine, "%s %s\n", theBlipName.c_str(), theBlipStatusText.c_str());
						this->DrawTranslatedString(theScreenPos[0], theScreenPos[1], theFirstLine, true, true);
						
						char theLocationNameCStr[512];
						strcpy(theLocationNameCStr, theLocationName.c_str());
						this->DrawTranslatedString(theScreenPos[0], theScreenPos[1] + .022f*ScreenHeight(), theLocationNameCStr, true, true, true);
					}
				}
			
            //}
		}

		// Draw hive locations under each hive indicator
		if(!theIsGestating && !theIsBeingDigested && (this->mMapMode == MAP_MODE_NS))
		{
			int theHiveIndex = 0;
			for(HiveInfoListType::iterator theIter = this->mHiveInfoList.begin(); theIter != this->mHiveInfoList.end(); theIter++, theHiveIndex++)
			{
				vec3_t theHivePosition(theIter->mPosX, theIter->mPosY, theIter->mPosZ);
				string theLocationName = this->GetNameOfLocation(theHivePosition);
			
                int theHiveWidth = kHiveNormScreenWidth*ScreenWidth();

                int theScreenPosX = mViewport[0] + mViewport[2] - theHiveWidth;
				int theScreenPosY = mViewport[1] + (kHiveNormScreenY + theHiveIndex*kHiveNormScreenVerticalSpacing + kHiveNormScreenHeight)*ScreenHeight();

				// Hack for nancy, because source is lost
				if((this->mMapName == "ns_nancy") && (theLocationName == ""))
				{
					theLocationName = "nancy_mother";
				}
				
				string theTranslatedLocationName;
				LocalizeString(theLocationName.c_str(), theTranslatedLocationName);
			
				AvHCUTrimExtraneousLocationText(theTranslatedLocationName);
			
				int theR, theG, theB;
				this->GetPrimaryHudColor(theR, theG, theB, false, false);
			
				// Draw text in greyscale if hive isn't building or active
				if(theIter->mStatus == kHiveInfoStatusUnbuilt)
				{
					theR = theG = theB = 100;
				}
			
				this->DrawHudStringReverse(mViewport[0] + mViewport[2] - 5, theScreenPosY, ScreenWidth(), (char*)theTranslatedLocationName.c_str(), theR, theG, theB);
			
				//char theLocationNameCStr[512];
				//strcpy(theLocationNameCStr, theLocationName.c_str());
				//this->DrawTranslatedString(theScreenPosX, theScreenPosY, theLocationNameCStr, false, false);
			}
		}
	}


}

void AvHHud::DrawWarpedOverlaySprite(int spriteHandle, int numXFrames, int numYFrames, float inWarpXAmount, float inWarpYAmount, float inWarpXSpeed, float inWarpYSpeed)
{
    
    float dx = ScreenWidth();
    float dy = ScreenHeight();

	float theCurrentTime = gHUD.GetTimeOfLastUpdate();
	float theNormXAmount = theCurrentTime*inWarpXSpeed - (int)(theCurrentTime*inWarpXSpeed); // Get fractional part of second
	float theNormYAmount = theCurrentTime*inWarpYSpeed - (int)(theCurrentTime*inWarpYSpeed);
	float theSinusoidalNormXAmount = cos(theNormXAmount*2.0f*M_PI);
	float theSinusoidalNormYAmount = sin(theNormYAmount*2.0f*M_PI);
	float theXAmount = theSinusoidalNormXAmount*inWarpXAmount;
	float theYAmount = theSinusoidalNormYAmount*inWarpYAmount;

    for (int frameY = 0; frameY < numYFrames; ++frameY)
    {
        for (int frameX = 0; frameX < numXFrames; ++frameX)
        {

            float theWarpXStartAmount = 0;
		    float theWarpYStartAmount = 0;
		    float theWarpXEndAmount = 0;
		    float theWarpYEndAmount = 0;
            
            int frame = frameX + frameY * numXFrames;

            float pw = SPR_Width(spriteHandle, frame);
            float ph = SPR_Height(spriteHandle, frame);
            
            float fx1 = ((float)(frameX)) / numXFrames;
            float fy1 = ((float)(frameY)) / numYFrames;
            
            float fx2 = ((float)(frameX + 1)) / numXFrames;
            float fy2 = ((float)(frameY + 1)) / numYFrames;

			if(frameX > 0)
			{
				theWarpXStartAmount = theXAmount*ScreenWidth();
			}
			if(frameX < numXFrames - 1)
			{
				theWarpXEndAmount = theXAmount*ScreenWidth();
			}
			if(frameY > 0)
			{
				theWarpYStartAmount = theYAmount*ScreenHeight();
			}
			if(frameY < numYFrames - 1)
			{
				theWarpYEndAmount = theYAmount*ScreenHeight();
			}
            
            AvHSpriteDraw(spriteHandle, frame,
                 dx * fx1 + theWarpXStartAmount,
                 dy * fy1 + theWarpYStartAmount,
                 dx * fx2 + theWarpXEndAmount,
                 dy * fy2 + theWarpYEndAmount,
                 1 / pw, 1 / ph, 1 - 1 / pw, 1 - 1 / ph);

        }
    }

}

void AvHHud::RenderNoZBuffering()
{

    if (mSteamUIActive)
    {
        // Hack since the HUD doesn't get drawn while the Steam UI is open.
        Render();
    }

	// Don't draw this stuff while being digested
	if(this->GetIsBeingDigested() || gParticleEditorHandler.GetInEditMode())
	{
		return;
	}

	// Temporary, so we can make movies without having the UI flit around (known HL playback bug)
	if(/*gEngfuncs.pDemoAPI->IsPlayingback() ||*/ gViewPort->IsOptionsMenuVisible())
	{
		return;
	}

	const int theDistance = 50;
	
	const float kAspectRatio = ScreenWidth()/ScreenHeight();
	
	float m_vRenderOrigin[3];
	pVector m_vUp;
	pVector m_vRight;
	pVector m_vNormal;
	
	//vec3_t theViewAngles;
	//gEngfuncs.GetViewAngles((float*)theViewAngles)
	//gEngfuncs.GetView
	
	IEngineStudio.GetViewInfo( m_vRenderOrigin, (float*)&m_vUp, (float*)&m_vRight, (float*)&m_vNormal );
	
	//float m_fSoftwareXScale, m_fSoftwareYScale;
	//IEngineStudio.GetAliasScale( &m_fSoftwareXScale, &m_fSoftwareYScale );
	
	//vec3_t theViewHeight;
	//gEngfuncs.pEventAPI->EV_LocalPlayerViewheight(theViewHeight);
	
	//	pVector p;
	//	p.x = m_vRenderOrigin[0] + m_vNormal.x*theDistance;
	//	p.y = m_vRenderOrigin[1] + m_vNormal.y*theDistance;
	//	p.z = m_vRenderOrigin[2] + m_vNormal.z*theDistance;
	
	//	pVector p;
	//	p.x = m_vRenderOrigin[0];
	//	p.y = m_vRenderOrigin[1];
	//	p.z = m_vRenderOrigin[2];
	//	p.x = v_origin[0];
	//	p.y = v_origin[1];
	//	p.z = v_origin[2];
	
	// Allow scripts to perform render
	AvHScriptManager::Instance()->DrawNoZBuffering();
	
//	if(cl_particleinfo->value)
//	{
//		// Draw particles here for debugging
//		pVector theRealView;
//		vec3_t angles, up, right, forward;
//		gEngfuncs.pfnAngleVectors(pmove->angles, forward, right, up);
//		
//		theRealView.x = forward[0];
//		theRealView.y = forward[1];
//		theRealView.z = forward[2];
//
//		AvHParticleSystemManager::Instance()->Draw(theRealView);
//	}
	
	//if(this->mMappingTechSprite && !this->mIsRenderingSelectionView && !this->mGameStarted)
	//{
	//	float theXPercentage = 256/1024.0f;
	//	float theYPercentage = 64/768.0f;
	//	DrawScaledHUDSprite(this->mMappingTechSprite, kRenderTransColor, 1, 0, ScreenHeight/2, theXPercentage*ScreenWidth, theYPercentage*ScreenHeight());
	//}

	// Draw blips, orders, selection and build effects for spectators and demo watchers too
	int theUpgradeVar = this->GetHUDUpgrades();
	bool theHasHiveSightUpgrade = true;//GetHasUpgrade(theUpgradeVar, MASK_ALIEN_UPGRADE_11);

	if(this->GetIsAlien())
	{
		if(theHasHiveSightUpgrade)
		{
			// Draw friendly blips
			this->mFriendlyBlips.Draw(m_vNormal, kFriendlyBlipStatus);
		}
	}
	
	// Draw enemy blips
	this->mEnemyBlips.Draw(m_vNormal, kEnemyBlipStatus);
	
	//this->DrawOrders(true);
	this->DrawSelectionAndBuildEffects();
	//this->DrawHelpIcons();

}

void AvHHud::VidInit(void)
{
	UIHud::VidInit();

    mOverviewMap.VidInit();

	int theScreenWidth = ScreenWidth();
	string theSpriteName;
	
	//	theSpriteName = UINameToSprite(kEggSprite, theScreenWidth);
	//	this->mAlienUIEggSprite = Safe_SPR_Load(theSpriteName.c_str());
	
	//	theSpriteName = UINameToSprite(kHiveSprite, theScreenWidth);
	//	this->mAlienUIHiveSprite = Safe_SPR_Load(theSpriteName.c_str());
	
	int i = 0;
	//	for(i = 0; i < kNumAlienLifeforms; i++)
	//	{
	//		char theBaseName[128];
	//		sprintf(theBaseName, "%s%d", kLifeformSprite, i+1);
	//		string theSpriteName = "sprites/level1_hud.spr";//UINameToSprite(theBaseName, theScreenWidth, true);
	//		this->mAlienUILifeforms[i] = Safe_SPR_Load(theSpriteName.c_str());
	//	}
	
	char theBaseName[128];
	sprintf(theBaseName, "%s", kAlienUpgradeSprite);
	theSpriteName = UINameToSprite(theBaseName, theScreenWidth);
	this->mAlienUIUpgrades = Safe_SPR_Load(theSpriteName.c_str());
	
	sprintf(theBaseName, "%s", kAlienUpgradeCategory);
	theSpriteName = UINameToSprite(theBaseName, theScreenWidth);
	this->mAlienUIUpgradeCategories = Safe_SPR_Load(theSpriteName.c_str());
	
	// Load jetpack sprite
	theSpriteName = UINameToSprite(kJetpackSprite, theScreenWidth);
	this->mMarineUIJetpackSprite = Safe_SPR_Load(theSpriteName.c_str());

	// Load alien energy sprite
	theSpriteName = UINameToSprite(kAlienEnergySprite, theScreenWidth);
	this->mAlienUIEnergySprite = Safe_SPR_Load(theSpriteName.c_str());

	// Load background for topdown mode
	this->mBackgroundSprite = Safe_SPR_Load(kTopDownBGSprite);

	// Load HUD
	this->mTopDownTopSprite = Safe_SPR_Load(kTopDownTopHUDSprite);
	this->mTopDownBottomSprite = Safe_SPR_Load(kTopDownBottomHUDSprite);
	this->mMarineTopSprite = Safe_SPR_Load(kMarineTopHUDSprite);

	this->mLogoutSprite = Safe_SPR_Load(kLogoutSprite);
	this->mCommandButtonSprite = Safe_SPR_Load(kCommandButtonSprite);
	this->mCommandStatusSprite = Safe_SPR_Load(kCommandStatusSprite);
	this->mSelectAllSprite = Safe_SPR_Load(kSelectAllSprite);

	//this->mTopDownBottomSprite = Safe_SPR_Load("sprites/distorttest.spr");
	//this->mTopDownBottomSprite = Safe_SPR_Load("sprites/ns.spr");
	//this->mTopDownBottomSprite = Safe_SPR_Load("sprites/distorttest.spr");

	// Load overlays
	this->mMembraneSprite = Safe_SPR_Load(kMembraneSprite);
	this->mDigestingSprite = Safe_SPR_Load(kDigestingSprite);
	
	// Load order sprite
	theSpriteName = UINameToSprite(kOrdersSprite, theScreenWidth);
	this->mOrderSprite = Safe_SPR_Load(theSpriteName.c_str());
	this->mHiveInfoSprite = Safe_SPR_Load(kHiveInfoSprite);
	this->mHiveHealthSprite = Safe_SPR_Load(kHiveHealthSprite);

	// Load cursor sprite
	this->mMarineCursor = Safe_SPR_Load(kCursorsSprite);
	this->mAlienCursor = Safe_SPR_Load(kAlienCursorSprite);
	this->mMarineOrderIndicator = Safe_SPR_Load(kMarineOrderSprite);
	this->mMarineUpgradesSprite = Safe_SPR_Load(kMarineUpgradesSprite);
	
	//#ifdef AVH_MAPPER_BUILD
	//this->mMappingTechSprite = Safe_SPR_Load("sprites/ns.spr");
	//#endif

	this->mAlienBuildSprite = Safe_SPR_Load(kAlienBuildSprite);
	this->mMarineBuildSprite = Safe_SPR_Load(kMarineBuildSprite);

	this->mAlienHealthSprite = Safe_SPR_Load(kAlienHealthSprite);
	this->mMarineHealthSprite = Safe_SPR_Load(kMarineHealthSprite);

	this->mBuildCircleSprite = Safe_SPR_Load(kBuildCircleSprite);
	//this->mSiegeTurretSprite = Safe_SPR_Load(kSiegeTurretSprite);

	this->mActionButtonSprites.clear();
	//this->mHelpSprites.clear();

	string theIconName = string(kHelpIconPrefix) + ".spr";
	this->mHelpSprite = Safe_SPR_Load(theIconName.c_str());

	this->mEnemyBlips.VidInit();
	this->mFriendlyBlips.VidInit();
}