---------------------
-- Your Name is Benny
---------------------

-- Stack related
function xy( x, y )
	return {x, y}
end

function hXY( x, y )
	local rx, ry = 0, 0
	for key, value in ipairs(stack) do
		rx = rx + value[1]
		ry = ry + value[2]
	end
	if x then rx = rx + x end
	if y then ry = ry + y end
	return rx, ry
end

function S_Push( x, y )
	stack:Push( xy( x, y ) )
end

function S_Pop( x, y )
	stack:Pop()
end


function hCol( r, g, b, a )
	return surface.SetDrawColor( r, g, b, a )
end

function hRect( x, y, w, h )
	gx, gy = hXY()
	x = (x or 0) + gx
	y = (y or 0) + gy

	surface.DrawRect( x, y, w, h )
end

function hRRect( x, y, w, h, r )
	gx, gy = hXY()
	x = (x or 0) + gx
	y = (y or 0) + gy

	draw.RoundedBox( r, x, y, w, h, surface.GetDrawColor() )
end

function hTRect( x, y, w, h )
	gx, gy = hXY()
	x = (x or 0) + gx
	y = (y or 0) + gy

	surface.DrawTexturedRect( x, y, w, h )
end

function hTrRect( x, y, w, h, d )
	gx, gy = hXY()
	x = (x or 0) + gx
	y = (y or 0) + gy

	surface.DrawTexturedRectRotated( x, y, w, h, d )
end

function hORect( x, y, w, h, r )
	gx, gy = hXY()
	x = (x or 0) + gx
	y = (y or 0) + gy

	surface.DrawOutlinedRect( x, y, w, h, r )
end

function hScis( x, y, w, h )
	gx, gy = hXY()
	x = (x or 0) + gx
	y = (y or 0) + gy

	render.SetScissorRect( x, y, x+w, y+h, true )
end

function hScisoff()
	render.SetScissorRect( 0, 0, 0, 0, false )
end

function qt( text, font, x, y, col, xalign, yalign, col2 )
	draw.SimpleText( text, font, x-1, y-1, col2, xalign, yalign )
	draw.SimpleText( text, font, x,   y-1, col2, xalign, yalign )
	draw.SimpleText( text, font, x+1, y-1, col2, xalign, yalign )

	draw.SimpleText( text, font, x-1, y,   col2, xalign, yalign )

	draw.SimpleText( text, font, x+1, y,   col2, xalign, yalign )

	draw.SimpleText( text, font, x-1, y+1, col2, xalign, yalign )
	draw.SimpleText( text, font, x,   y+1, col2, xalign, yalign )
	draw.SimpleText( text, font, x+1, y+1, col2, xalign, yalign )

	draw.SimpleText( text, font, x, y, col, xalign, yalign )
end


local sizes = {
	8, 10, 16, 24, 36, 48
}

local function regenfonts()
	for index, scale in ipairs( sizes ) do
		surface.CreateFont("HUD_" .. scale, {
			font = "Carbon Plus Bold",
			size = scale,
			weight = 0,
			extended = false,
			italic = false,
			antialias = true,
		})
	end
end
regenfonts()

FACTIONS = {
	["benny"] = {
		COLOR_MAIN = Color( 255, 238, 169 ),
		COLOR_DARK = Color( 54, 44, 39 ),
		CHARNAME = "BENNY",
	},
	["nikki"] = {
		COLOR_MAIN = Color( 255, 174, 210 ),
		COLOR_DARK = Color(37, 12, 40 ),
		CHARNAME = "NIKKI",
	},
	["igor"] = {
		COLOR_MAIN = Color( 253, 208, 207 ),
		COLOR_DARK = Color( 32, 14, 12 ),
		CHARNAME = "IGOR",
	},
	["yanghao"] = {
		COLOR_MAIN = Color( 157, 187, 253 ),
		COLOR_DARK = Color( 19, 21, 28 ),
		CHARNAME = "YANG-HAO",
	},
	-- MP
	["mp_cia"] = {
		COLOR_MAIN = Color( 255, 255, 255),
		COLOR_DARK = Color( 25, 23, 47 ),
		CHARNAME = "CIA",
	},
	["mp_halo"] = {
		COLOR_MAIN = Color( 130, 255, 255 ),
		COLOR_DARK = Color( 40, 40, 58 ),
		CHARNAME = "HALO",
	},
	["mp_plasof"] = {
		COLOR_MAIN = Color( 255, 153, 153 ),
		COLOR_DARK = Color( 45, 10, 10 ),
		CHARNAME = "PLASOF",
	},
	["mp_arng"] = {
		COLOR_MAIN = Color( 198, 255, 192 ),
		COLOR_DARK = Color( 23, 32, 23 ),
		CHARNAME = "NATGUARD",
	},
	["mp_militia"] = {
		COLOR_MAIN = Color( 255, 219, 153 ),
		COLOR_DARK = Color( 33, 18, 18 ),
		CHARNAME = "MILITIA",
	},
	["mp_viper"] = {
		COLOR_MAIN = Color( 248, 191, 225 ),
		COLOR_DARK = Color( 50, 20, 50 ),
		CHARNAME = "VIPER",
	},
	["unassigned"] = {
		COLOR_MAIN = Color( 220, 220, 220 ),
		COLOR_DARK = Color( 40, 40, 40),
		CHARNAME = "Unassigned...",
	},
}

local CURRCHAR		= "mp_arng"
local COLOR_MAIN	= FACTIONS[CURRCHAR].COLOR_MAIN
local COLOR_DARK	= FACTIONS[CURRCHAR].COLOR_DARK
local CHARNAME		= FACTIONS[CURRCHAR].CHARNAME
local COLOR_BRIGHT	= Color( 94, 94, 94 )

local alphabet = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"}

local xhair_dot = Material( "benny/hud/xhair/dotx.png", "mips smooth" )
local xhair_dot_shadow = Material( "benny/hud/xhair/dot_s.png", "mips smooth" )

local fmlookup = {
	[1] = "SEMI",
	[math.huge] = "AUTO",
}

local function QuickDrawBar( BARWIDE, BARTALL, RealTeamID, TeamID, way )

	local faction_info = FACTIONS[ TEAMS[RealTeamID].factionid ]
	hCol( faction_info.COLOR_DARK )
	hRect( 0, 0, BARWIDE, BARTALL )
	hCol( faction_info.COLOR_MAIN )
	hORect( 1, 1, BARWIDE-2, BARTALL-2, 1 )

	local count = 6

	local Score_Current = BennyGame:GetScoreForTeam( RealTeamID )
	local Score_ToWin = BennyGame:GetScoreLimit()

	local perc = Score_Current/Score_ToWin
	local width = math.ceil( (BARWIDE-6)*perc )
	if way then
		hRect( BARWIDE - 3 - width, 3, width, BARTALL-6 )
	else
		hRect( 3, 3, width, BARTALL-6 )
	end

	for i=1, count-1 do
		local bleh
		if way then
			bleh = (i/count)<(1-perc)
		else
			bleh = (i/count)>perc
		end
		hCol( bleh and faction_info.COLOR_MAIN or faction_info.COLOR_DARK )
		hRect( 3 + (BARWIDE-7)*(i/count), 4, 1, BARTALL-8 )
	end

	if way then
		local x, y = hXY( BARWIDE - 5, 0 )
		qt( faction_info.CHARNAME, "HUD_36", x, y, faction_info.COLOR_DARK, TEXT_ALIGN_RIGHT, nil, faction_info.COLOR_MAIN )
		
		local x, y = hXY( BARWIDE, BARTALL )
		qt( Score_Current .. " / " .. Score_ToWin, "HUD_24", x, y, faction_info.COLOR_MAIN, TEXT_ALIGN_RIGHT, nil, faction_info.COLOR_DARK )
	else
		local x, y = hXY( 5, 0 )
		qt( faction_info.CHARNAME, "HUD_36", x, y, faction_info.COLOR_DARK, nil, nil, faction_info.COLOR_MAIN )

		local x, y = hXY( 0, BARTALL )
		qt( Score_Current .. " / " .. Score_ToWin, "HUD_24", x, y, faction_info.COLOR_MAIN, nil, nil, faction_info.COLOR_DARK )
	end

	-- Players alive
	if false then
		for i=1, 6 do
			local o = i-1
			local lol = i>=3
			if way then
				S_Push( BARWIDE - i*(16+2), BARTALL + 2 )
			else
				S_Push( o*(16+2), BARTALL + 2 )
			end
				hCol( lol and faction_info.COLOR_DARK or faction_info.COLOR_MAIN )
				hRect( 0, 0, 16, 16 )
				hCol( lol and faction_info.COLOR_MAIN or faction_info.COLOR_DARK )
				hORect( 1, 1, 16-2, 16-2, 1 )
			S_Pop()
		end
	end
end

-- Drawing
function GM:HUDPaint()
	local p = LocalPlayer()
	local w, h = ScrW(), ScrH()
	local handler = p:HandlerCheck()
	stack = util.Stack()

	local myteam = p:Team()
	local CURRCHAR
	if BennyGame:GetType() == BG_GTYPE_CAMPAIGN then
		CURRCHAR		= "benny"
	else
		CURRCHAR		= TEAMS[myteam].factionid
	end
	local COLOR_MAIN	= FACTIONS[CURRCHAR].COLOR_MAIN
	local COLOR_DARK	= FACTIONS[CURRCHAR].COLOR_DARK
	local CHARNAME		= FACTIONS[CURRCHAR].CHARNAME

	local MP = BennyGame:GetType() == BG_GTYPE_MP

	-- S_Push( math.random( -4, 4 ), math.random( -4, 4 ) )

		S_Push( 20, h - 20 - 65 )
			hCol( COLOR_DARK )
			hRect( 0, 0, 328, 65 )

			local x, y = hXY( 10, 4 )
			qt( CHARNAME, "HUD_48", x, y, COLOR_DARK, nil, nil, COLOR_MAIN )

			local HEALTHPER = p:GetHealth_Blood()/1000
			--HEALTHPER = 11/100
			
			hCol( COLOR_MAIN )
			hRect( 8, 8, (320-4-4) * HEALTHPER, 41-4-4 )
			hORect( 8, 8, (320-4-4), 41-4-4, 1 )
			hCol( COLOR_DARK )
			hORect( 8+1, 8+1, (320-4-4)-2, 41-4-4-2, 1 )
			
			hCol( COLOR_MAIN )
			hScis( 8, 8, (320-4-4) * HEALTHPER, 41-4-4 )
				local x, y = hXY( 10, 4 )
				draw.SimpleText( CHARNAME, "HUD_48", x, y, COLOR_DARK )
			hScisoff()

			local slen = (320-4-4-4-4-4)
			hCol( COLOR_MAIN )
			hRect( 8,					45, slen*0.25, 12 )
			hRect( 8 + (slen*0.25+4),	45, slen*0.25, 12 )
			hRect( 8 + (slen*0.25+4)*2,	45, slen*0.25, 12 )
			hRect( 8 + (slen*0.25+4)*3,	45, slen*0.25, 12 )

			hCol( COLOR_DARK )
			hORect( 8+1,						45+1, slen*0.25 - 2, 12-2, 1 )
			hORect( 8+1 + (slen*0.25+4),		45+1, slen*0.25 - 2, 12-2, 1 )
			hORect( 8+1 + (slen*0.25+4)*2,		45+1, slen*0.25 - 2, 12-2, 1 )
			hORect( 8+1 + (slen*0.25+4)*3,		45+1, slen*0.25 - 2, 12-2, 1 )

			if MP then -- MP
				S_Push( 0, -8 - 2 )
					local targetlength = 328
					local segments = 10
					local gap = 2
					targetlength = targetlength - gap*(segments-1)

					local chunk = 1/segments
					for i=1, segments do
						local z = i-1
						local chunk0, chunk1 = chunk*z, chunk*i
						local filled = math.Remap( p:GetLevel_XP()/15000, chunk0, chunk1, 0, 1 )
						filled = math.Clamp( filled, 0, 1 )	
						local a1, a2, a3, a4 = ( (targetlength/segments) * z ) + (gap*z), 0, (targetlength/segments), 8
						if i == segments then a3 = math.ceil(a3) end
						if filled == 1 then
							hCol( COLOR_MAIN )
							hRect( a1, a2, a3, a4 )
							hCol( COLOR_DARK )
							hORect( a1, a2, a3, a4, 1 )
						elseif filled == 0 then
							hCol( COLOR_DARK )
							hRect( a1, a2, a3, a4 )
						else
							hCol( COLOR_DARK )
							hRect( a1, a2, a3, a4 )
							hCol( COLOR_MAIN )
							hRect( a1, a2, a3*filled, a4 )
							hCol( COLOR_DARK )
							hORect( a1, a2, a3, a4, 1 )
						end
					end

					local x, y = hXY( 0, -14 )
					qt( p:GetLevel_XP() .. " / 15000", "HUD_16", x, y, COLOR_MAIN, nil, nil, COLOR_DARK )
					--qt( "", "HUD_24", x+328, y, COLOR_MAIN, TEXT_ALIGN_RIGHT, nil, COLOR_DARK )

				S_Pop()
			end
		S_Pop()

		if handler then
			-- Inventory
			S_Push( 20, 20 )
				local x, y = hXY( 5, 65+16*0 )
				draw.SimpleText( "SelectedNumber: " .. (p.SelectedNumber or 0), "HUD_16", x, y, COLOR_MAIN )
				local x, y = hXY( 5, 65+16*1 )
				draw.SimpleText( "DesireR: " .. tostring(handler:GetDesireR()), "HUD_16", x, y, COLOR_MAIN )
				local x, y = hXY( 5, 65+16*2 )
				draw.SimpleText( "ActiveR: " .. tostring(handler:GetActiveR()), "HUD_16", x, y, COLOR_MAIN )
				local x, y = hXY( 5, 65+16*3 )
				draw.SimpleText( "DesireL: " .. tostring(handler:GetDesireL()), "HUD_16", x, y, COLOR_MAIN )
				local x, y = hXY( 5, 65+16*4 )
				draw.SimpleText( "ActiveL: " .. tostring(handler:GetActiveL()), "HUD_16", x, y, COLOR_MAIN )

				for i, v in ipairs( p:GetInventory():GetWeighted() ) do
					hCol( v == handler:GetActiveR() and COLOR_BRIGHT or COLOR_DARK )
					hRect( (i-1)*(120+10), 0, 120, 60 )
					local x, y = hXY( (i-1)*(120+10), 0 )
					draw.SimpleText( l8( v.Class.PrintName ), "HUD_24", x + 120/2, y + 60/2 - (10), COLOR_MAIN, TEXT_ALIGN_CENTER, TEXT_ALIGN_CENTER )
					if v.GetClip2 then
						draw.SimpleText( v:GetClip2() .. "/" .. v.Class.ClipSize2, "HUD_16", x + 10, y + 60/2 + (4), COLOR_MAIN, TEXT_ALIGN_LEFT, TEXT_ALIGN_CENTER )
					end


					if v.GetClip then
						local drawer = ""

						drawer = drawer .. v:GetClip()
						drawer = drawer .. "/"
						drawer = drawer .. v.Class.ClipSize
						draw.SimpleText( drawer, "HUD_16", x + 10, y + 60/2 + (16), COLOR_MAIN, TEXT_ALIGN_LEFT, TEXT_ALIGN_CENTER )
						draw.SimpleText( v:GetFiremode(), "HUD_16", x + 120 - 10, y + 60/2 + (16), COLOR_MAIN, TEXT_ALIGN_RIGHT, TEXT_ALIGN_CENTER )
					end
				end
			S_Pop()

			local wep = handler:GetActiveR()
			if wep and wep.GetClip then
				local Bw, Bh = 8+(8+2)*30-2+8, 160
				S_Push( w - 20 - Bw, h - 20 - Bh )
					hCol( COLOR_DARK )
					hRect( 0, 0, Bw, Bh )

					S_Push( 0, 0 )
						hCol( COLOR_MAIN )
						local leng = Bw-8-8
						hRect( 8, 8, leng-70, 26 )
						hRect( 8 + leng - 70 + 4, 8, leng-(leng-70)-4, 26 )
						local x, y = hXY( 12, 6 )
						draw.SimpleText( l8( wep.Class.PrintName ), "HUD_36", x, y, COLOR_DARK )
						local x, y = hXY( 10 + (leng - 70) + 70/2, 11 )
						local bc = wep.Class.BurstCount
						draw.SimpleText( fmlookup[bc] or bc .. "RND", "HUD_24", x, y, COLOR_DARK, TEXT_ALIGN_CENTER )
					S_Pop()

					S_Push( Bw - 8 - 8, Bh - 18 - 8 )
						for i=0, wep.Class.ClipSize-1 do
							if wep:GetClip() >= (i+1) then
								hCol( COLOR_MAIN )
								hRect( (0 - 8 - 2)*i, 0, 8, 18 )
								hCol( COLOR_DARK )
								hRect( (0 - 8 - 2)*i, 14, 8, 2 )
							else
								hCol( COLOR_BRIGHT )
								hORect( (0 - 8 - 2)*i, 0, 8, 18 )
							--hORect( (0 - 8 - 2)*i+1, 1, 8-2, 18-2 )
							end
						end
					S_Pop()
				S_Pop()
			end
		end

		if MP then S_Push( w/2, 20 )
			local BARWIDE, BARTALL, GAP = 240, 30, 100

			-- Score
			local count = 1
			if BennyGame.RTeamID[myteam] then  -- My team
				local o = count-1
				S_Push( count%2==1 and (-BARWIDE - 1 - GAP) or (0 + 1 + GAP), (BARTALL+2+16+2)*math.floor(o/2) )
					QuickDrawBar( BARWIDE, BARTALL, myteam, BennyGame.RTeamID[myteam], count%2==0 )
				S_Pop()
				count = count + 1
			end
			-- Every other team
			for TeamID, RealTeamID in ipairs( BennyGame.TeamsInPlay ) do
				if RealTeamID == myteam then continue end
				local o = count-1
				S_Push( count%2==1 and (-BARWIDE - 1 - GAP) or (0 + 1 + GAP), (BARTALL+2+16+2)*math.floor(o/2) )
					QuickDrawBar( BARWIDE, BARTALL, RealTeamID, TeamID, count%2==0 )
				S_Pop()
				count = count + 1
			end

			-- Timer
			local DISPLAYWIDE, DISPLAYTALL = 150, 48
			S_Push( -DISPLAYWIDE/2, 0 )
				hCol( COLOR_DARK )
				hRect( 0, 0, DISPLAYWIDE, DISPLAYTALL )
				hCol( COLOR_MAIN )
				hORect( 2, 2, DISPLAYWIDE-4, DISPLAYTALL-4, 1 )

				local stupidtime = CurTime()
				if BennyGame:GetState() == BG_STATE_ACTIVE then
					stupidtime = BennyGame:GetRoundStartedAt() + BennyGame:GetTimeLimit() - CurTime()
				elseif BennyGame:GetState() == BG_STATE_PRE then
					stupidtime = BennyGame:GetPregameStartedAt() + BennyGame:GetPregameTime() - CurTime()
				elseif BennyGame:GetState() == BG_STATE_POST then
					stupidtime = BennyGame:GetRoundFinishedAt() + BennyGame:GetPostgameTime() - CurTime()
				end

				if BennyGame:GetState() != BG_STATE_WAITINGFORPLAYERS then
					local d1, d2
					local tt = string.FormattedTime( math.max( stupidtime, 0 ) )
					if tt.m > 0 then
						d1 = string.format( "%01i:%02i", tt.m, tt.s )
						d2 = false--tt.s
						if tt.h > 0 then
							d1 = tt.h .. ":" .. d1
						end
					else
						d1 = string.format( "%02i", tt.s )
						d2 = string.format( ".%02i", tt.ms )
					end
					
					surface.SetFont("HUD_48")
					local twid = surface.GetTextSize(d1)
					if d2 then
						surface.SetFont("HUD_36")
						twid = twid + surface.GetTextSize(".00")
					end

					local x, y = hXY( DISPLAYWIDE/2 + 0 - twid/2, 4 )
					draw.SimpleText( d1, "HUD_48", x, y, COLOR_MAIN )
					local twid2 = surface.GetTextSize(d1)
					if d2 then
						local x, y = hXY( DISPLAYWIDE/2 + twid2 - twid/2, 11 )
						draw.SimpleText( d2, "HUD_36", x, y, COLOR_MAIN )
					end
				end

				local x, y = hXY( DISPLAYWIDE/2, -16 )
				local TITLE
				if BennyGame:GetState() == BG_STATE_PRE then
					TITLE = "PREGAME"
				elseif BennyGame:GetState() == BG_STATE_POST then
					TITLE = "POSTGAME"
				elseif BennyGame:GetState() == BG_STATE_WAITINGFORPLAYERS then
					TITLE = "WAITING FOR PLAYERS"
				end
				if TITLE then
					qt( TITLE, "HUD_16", x, y, COLOR_MAIN, TEXT_ALIGN_CENTER, nil, COLOR_DARK )
				end

				if false then
					local myteamwins = 2
					local enemywins = 3
					local count = 7
					-- Round counter
					local wideness = (20+2)*count-2
					for i=1, count do
						local o = i-1
						S_Push( DISPLAYWIDE/2 - wideness/2 + o*(20+2), DISPLAYTALL+4 )
							local COLOR_DARK = COLOR_DARK
							local COLOR_MAIN = COLOR_MAIN
							local filled = false
							if i<=myteamwins then
								filled = true
							elseif (count-o)<=enemywins then
								COLOR_DARK = E_COLOR_DARK
								COLOR_MAIN = E_COLOR_MAIN
								filled = true
							else
								COLOR_DARK = Color( 040, 040, 040 )
								COLOR_MAIN = Color( 080, 080, 080 )
								filled = true
							end
							hCol( filled and COLOR_MAIN or COLOR_DARK )
							hRect( 0, 0, 20, 8 )
							hCol( filled and COLOR_DARK or COLOR_MAIN )
							hORect( 1, 1, 20-2, 8-2, 1 )
						S_Pop()
					end
				end

				-- Domination flag status
				if true then
					local AllFlags = ents.FindByClass("benny_domflag")
					S_Push( 0, 0 )
						local count = #AllFlags

						local wideness = (48+2)*count-2
						for i, ent in ipairs( AllFlags ) do--for i=1, count do
							local o = i-1

							local faction_name = TEAMS[ent:GetTeamOwned()].factionid
							local faction_info = FACTIONS[faction_name]

							local taking_faction_name = TEAMS[ent:GetTeamTaking()].factionid
							local taking_faction_info = FACTIONS[taking_faction_name]

							local capturepercent = ent:GetCapturePercent()--math.Remap( CurTime()%4, 0, 3, 0, 1 )
							--capturepercent = math.Clamp(capturepercent, 0, 1)

							local mine, enemy = false, true

							--if i==3 then mine = !mine enemy = !enemy end

							if (capturepercent>=1) then
								mine = !mine
								enemy = !enemy
							end

							S_Push( DISPLAYWIDE/2 - wideness/2 + o*(48+2), DISPLAYTALL+4 )
								hCol( faction_info.COLOR_DARK )
								hRect( 0, 0, 48, 48 )
								hCol( faction_info.COLOR_MAIN )
								hRect( 1, 1, 48-2, 48-2, 1 )

								if capturepercent<1 then
									hCol( taking_faction_info.COLOR_MAIN )
									hORect( 1, 1, 48-2, 48-2, math.floor(23 * capturepercent) )
								end

								local x, y = hXY( 48/2, 9 )
								qt( alphabet[i] or i, "HUD_36", x, y, faction_info.COLOR_MAIN, TEXT_ALIGN_CENTER, nil, faction_info.COLOR_DARK )
							S_Pop()
						end
					S_Pop()
				end
			S_Pop()

			do
				local AllFlags = ents.FindByClass("benny_domflag")
				local AllFlagFlip = table.Flip(AllFlags)

				-- Current Objective
				local obj = p:GetTouchedObjective()
				if obj:IsValid() then
					S_Push( 0, 200 )
						
						local TITLE = "CAPTURING"
						local PERCENT = obj:GetCapturePercent()
						if obj:GetContested() then
							TITLE = "CONTESTED"
						elseif obj:GetTeamOwned() == myteam then
							if obj:GetCapturePercent() > 0 then
								TITLE = "CLEARING"
							else
								TITLE = "SECURE"
								PERCENT = 1
							end
						elseif obj:GetTeamOwned() == 0 and obj:GetTeamTaking() != myteam then
							TITLE = "CLEARING"
						end

						local BARCOLOR = FACTIONS[ TEAMS[obj:GetTeamOwned()].factionid ]
						local TAKCOLOR = FACTIONS[ TEAMS[obj:GetTeamTaking()].factionid ]
						local CONTOLER = FACTIONS[ "unassigned" ]

						BARCOLOR_MAIN = BARCOLOR.COLOR_MAIN
						BARCOLOR_DARK = BARCOLOR.COLOR_DARK

						TAKCOLOR_MAIN = TAKCOLOR.COLOR_MAIN
						TAKCOLOR_DARK = TAKCOLOR.COLOR_DARK

						CONTOLER_MAIN = CONTOLER.COLOR_MAIN
						CONTOLER_DARK = CONTOLER.COLOR_DARK

						local BWIDE, BTALL = 180, 16

						hCol( BARCOLOR_DARK )
						hRect( -80, 0, 160, 38 )
						hCol( BARCOLOR_DARK )
						hRect( -100, 35, 200, 76 )
						hCol( BARCOLOR_MAIN )
						hORect( -100+1, 35+1, 200-2, 76-2 )
						hCol( BARCOLOR_MAIN )
						hORect( -80+1, 1, 160-2, 38-2, 1 )
						local x, y = hXY( 0, 4 )
						qt( "POINT " .. (alphabet[ AllFlagFlip[obj] ] or AllFlagFlip[obj]), "HUD_36", x, y, BARCOLOR_MAIN, TEXT_ALIGN_CENTER, nil, BARCOLOR_DARK )


						local x, y = hXY( 0, TITLE=="SECURE" and 62 or 40 )
						qt( TITLE, "HUD_24", x, y, obj:GetContested() and CONTOLER_MAIN or COLOR_MAIN, TEXT_ALIGN_CENTER, nil, COLOR_DARK )

						if TITLE!="SECURE" then
							S_Push( -BWIDE/2, 62 )
								hCol( TAKCOLOR_DARK )
								hRect( 0, 0, 180, BTALL )
								hCol( TAKCOLOR_MAIN )
								hORect( 1, 1, 180-2, BTALL-2 )
								hCol( TAKCOLOR_MAIN )
								hRect( 3, 3, math.floor((BWIDE-6) * PERCENT), BTALL-6 )
							S_Pop()
							local x, y = hXY( 0, 78 )
							qt( math.floor(PERCENT*100) .. "%", "HUD_36", x, y, obj:GetContested() and CONTOLER_MAIN or COLOR_MAIN, TEXT_ALIGN_CENTER, nil, obj:GetContested() and CONTOLER_DARK or COLOR_DARK )
						end
					S_Pop()
				end
			end
		S_Pop() end

		--local itemcheck = handler:ItemCheckTrace()

		-- Hints
		if true then
			S_Push( w - 20, 20 )

			local hints = {}

			table.insert( hints, { "[SHIFT]", "DIVE" } )
			table.insert( hints, { "", "INTO PRONE", "HOLD" } )
			if handler:ItemR() then
				table.insert( hints, { "", "- - - - - - - - - - - -" } )
				table.insert( hints, { "[M1]", "FIRE" } )
				table.insert( hints, { "[C]", "FIREMODE" } )
				table.insert( hints, { "[E]", "THROW" } )
				table.insert( hints, { "[R]", "RELOAD" } )
				table.insert( hints, { "", "RETAIN MAG", "HOLD" } )
			--elseif itemcheck.Entity:IsValid() and itemcheck.Entity.BennyItem then
			--	table.insert( hints, { "", "- - - - - - - - - - - -" } )
			--	table.insert( hints, { "[E]", "PICK UP" } )
			end

			local x, y = hXY( 0, 0 )
			for i, v in ipairs( hints ) do
				draw.SimpleText( v[1],		"HUD_24", x - 150 + 1,		y + (24*(i-1)) + 1,		COLOR_DARK, TEXT_ALIGN_CENTER )
				draw.SimpleText( v[2],		"HUD_24", x + 1,			y + (24*(i-1)) + 1,		COLOR_DARK, TEXT_ALIGN_RIGHT )
				if v[3] then
					draw.SimpleText( v[3],	"HUD_16", x - 150 + 1,		y+3 + (24*(i-1)) + 1,	COLOR_DARK, TEXT_ALIGN_CENTER )
				end
			end
			for i, v in ipairs( hints ) do
				draw.SimpleText( v[1],		"HUD_24", x - 150,			y + (24*(i-1)),			COLOR_MAIN, TEXT_ALIGN_CENTER )
				draw.SimpleText( v[2],		"HUD_24", x,				y + (24*(i-1)),			COLOR_MAIN, TEXT_ALIGN_RIGHT )
				if v[3] then
					draw.SimpleText( v[3],	"HUD_16", x - 150,			y+3 + (24*(i-1)),		COLOR_MAIN, TEXT_ALIGN_CENTER )
				end
			end

			S_Pop()
		end

	-- S_Pop()

		--local trac = p:GetEyeTrace().HitPos:ToScreen()
		local trac = util.TraceLine( {
			start = p:GetPos() + Vector( 0, 0, 52 ),
			endpos = p:GetPos() + Vector( 0, 0, 52 ) + p:EyeAngles():Forward()*(2^31),
			filter = p,
		} ).HitPos
		local trac2 = util.TraceLine( {
			start = CamSpot(),
			endpos = CamSpot() + TPSOverride:Forward()*(2^31),
			filter = p,
		} ).HitPos

		local tol = false
		if trac:IsEqualTol( trac2, 2 ) then -- within two inches
			trac2 = trac2:ToScreen()
			trac = trac2
			tol = true
		else
			trac = trac:ToScreen()
			trac2 = trac2:ToScreen()
		end

		for i=1, 2 do
			local shadowtime = i==1
			local traac = shadowtime and trac2 or trac
			local cx, cy = math.Round(traac.x), math.Round(traac.y)
			local gap = 4
			local length = 4
			S_Push( cx, cy )
				local lol = shadowtime and 0 or 255
				local lol2 = shadowtime and 127 or 255
				local Shadow_Gap = shadowtime and 1 or 0
				local Shadow_Thickness = shadowtime and 2 or 0
				surface.SetDrawColor( lol, lol, lol, lol2 )
				--surface.SetMaterial( shadowtime and xhair_dot_shadow or xhair_dot )
				hRect( -1 - Shadow_Gap, gap - Shadow_Gap, 2 + Shadow_Thickness, length + Shadow_Thickness )
				hRect( gap - Shadow_Gap, -1 - Shadow_Gap, length + Shadow_Thickness, 2 + Shadow_Thickness )

				-- top and left
				hRect( -1 - Shadow_Gap, -length - gap - Shadow_Gap, 2 + Shadow_Thickness, length + Shadow_Thickness )
				hRect( -length - gap - Shadow_Gap, -1 - Shadow_Gap, length + Shadow_Thickness, 2 + Shadow_Thickness )

				if !shadowtime and !tol then
					surface.SetDrawColor( 255, 0, 0 )
					hRect( -1, -1, 2, 2 )
				end
			S_Pop()
		end

	if stack:Size() != 0 then print("Stack unfinished.") end
	return
end


-- Not drawing
local hide = {
	["CHudHealth"]			= true,
	["CHudBattery"]			= true,
	["CHudAmmo"]			= true,
	["CHudSecondaryAmmo"]	= true,
	["CHudDamageIndicator"]	= true,
	["CHudCloseCaption"]	= true,
	["CHudCrosshair"]		= true,
	["CHudSuitPower"]		= true,
	["CHUDQuickInfo"]		= true,
	["CHudZoom"]			= true,
}

function GM:HUDShouldDraw( name )
	if hide[ name ] then
		return false
	else
		return true
	end
end