514 lines
13 KiB
Lua
514 lines
13 KiB
Lua
|
|
---------------------
|
|
-- Your Name is Benny
|
|
---------------------
|
|
|
|
-- Stack related
|
|
local function xy( x, y )
|
|
return {x, y}
|
|
end
|
|
|
|
local 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
|
|
|
|
local function S_Push( x, y )
|
|
stack:Push( xy( x, y ) )
|
|
end
|
|
|
|
local function S_Pop( x, y )
|
|
stack:Pop()
|
|
end
|
|
|
|
|
|
local function hCol( r, g, b, a )
|
|
return surface.SetDrawColor( r, g, b, a )
|
|
end
|
|
|
|
local 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
|
|
|
|
local 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
|
|
|
|
local 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
|
|
|
|
local 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
|
|
|
|
local 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
|
|
|
|
local 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
|
|
|
|
local function hScisoff()
|
|
render.SetScissorRect( 0, 0, 0, 0, false )
|
|
end
|
|
|
|
local 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()
|
|
|
|
local 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( 228, 228, 245 ),
|
|
COLOR_DARK = Color( 25, 23, 47 ),
|
|
CHARNAME = "CIA",
|
|
},
|
|
["mp_plasof"] = {
|
|
COLOR_MAIN = Color( 255, 153, 153 ),
|
|
COLOR_DARK = Color( 45, 10, 10 ),
|
|
CHARNAME = "PLASOF",
|
|
},
|
|
["mp_militia"] = {
|
|
COLOR_MAIN = Color( 255, 219, 153 ),
|
|
COLOR_DARK = Color( 33, 18, 18 ),
|
|
CHARNAME = "MILITIA",
|
|
},
|
|
["mp_arng"] = {
|
|
COLOR_MAIN = Color( 198, 255, 192 ),
|
|
COLOR_DARK = Color( 23, 32, 23 ),
|
|
CHARNAME = "NATGUARD",
|
|
},
|
|
["mp_viper"] = {
|
|
COLOR_MAIN = Color( 255, 230, 245 ),
|
|
COLOR_DARK = Color( 40, 20, 30 ),
|
|
CHARNAME = "VIPER",
|
|
},
|
|
["mp_halo"] = {
|
|
COLOR_MAIN = Color( 200, 255, 246 ),
|
|
COLOR_DARK = Color( 30, 40, 38 ),
|
|
CHARNAME = "HALO",
|
|
},
|
|
}
|
|
|
|
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 )
|
|
|
|
--[[
|
|
BENNY
|
|
Color( 255, 238, 169 )
|
|
Color( 54, 44, 39 )
|
|
NIKKI
|
|
Color( 255, 174, 210 )
|
|
Color(37, 12, 40 )
|
|
IGOR
|
|
Color( 253, 208, 207 )
|
|
Color( 32, 14, 12 )
|
|
YANG-HAO
|
|
Color( 157, 187, 253 )
|
|
Color( 19, 21, 28 )
|
|
|
|
CIA
|
|
Color( 93, 118, 215 )
|
|
Color( 25, 23, 47 )
|
|
PLASOF
|
|
Color( 255, 103, 103 )
|
|
Color( 35, 25, 20 )
|
|
MILITIA
|
|
Color( 255, 199, 133 )
|
|
Color( 33, 18, 18 )
|
|
ARNG
|
|
Color( 208, 226, 132 )
|
|
Color( 23, 25, 23 )
|
|
VIPER
|
|
Color( 255, 230, 245 )
|
|
Color( 40, 30, 30 )
|
|
HALO
|
|
Color( 200, 255, 246 )
|
|
Color( 30, 40, 38 )
|
|
]]
|
|
|
|
local show_letters = {
|
|
{ "q", "w", "e", "r", "t", "y" },
|
|
{ "a", "s", "d", "f", "g", "h" },
|
|
{ "shift", "z", "x", "c", "v", "b", "n" },
|
|
{ "ctrl", "alt", "space" },
|
|
}
|
|
|
|
local translate_letters = {
|
|
["e"] = "weapon 1",
|
|
["q"] = "weapon 2",
|
|
["c"] = "grenade 1",
|
|
["z"] = "grenade 2",
|
|
["r"] = "alt 1",
|
|
["t"] = "alt 2",
|
|
["x"] = "bullrush",
|
|
["shift"] = "speed",
|
|
}
|
|
|
|
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 function commoncode( set )
|
|
for index, letter in ipairs( set ) do
|
|
local lettercode = input.GetKeyCode( letter )
|
|
local keydown = input.IsKeyDown( lettercode )
|
|
local thecolor = keydown and COLOR_MAIN or COLOR_DARK
|
|
|
|
local fakecolor = ColorAlpha( COLOR_BRIGHT, 60 )
|
|
hCol( fakecolor )
|
|
hRect( (index-1)*(60+4), 0, 60, 40, 2 )
|
|
|
|
hCol( thecolor )
|
|
hORect( (index-1)*(60+4), 0, 60, 40, 2 )
|
|
local x, y = hXY( (index-1)*(60+4) + 30, 20+3 )
|
|
draw.SimpleText( letter:upper(), "HUD_36", x, y, thecolor, TEXT_ALIGN_CENTER, TEXT_ALIGN_CENTER )
|
|
|
|
local tlated = translate_letters[letter]
|
|
if tlated then
|
|
local x, y = hXY( (index-1)*(60+4) + 30, 20 + 6 )
|
|
draw.SimpleText( tlated, "HUD_16", x, y, thecolor, TEXT_ALIGN_CENTER )
|
|
end
|
|
end
|
|
end
|
|
|
|
local fmlookup = {
|
|
[1] = "SEMI",
|
|
[math.huge] = "AUTO",
|
|
}
|
|
|
|
-- Drawing
|
|
function GM:HUDPaint()
|
|
local p = LocalPlayer()
|
|
local w, h = ScrW(), ScrH()
|
|
local handler = p:HandlerCheck()
|
|
stack = util.Stack()
|
|
|
|
-- 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 true 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( 0.727, 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( "10000 / 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
|
|
S_Push( 20, 20 )
|
|
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 = 328, 160
|
|
S_Push( w - 20 - Bw, h - 20 - Bh )
|
|
hCol( COLOR_DARK )
|
|
hRect( 0, 0, Bw, Bh )
|
|
|
|
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_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 false then
|
|
S_Push( 20, h - (20 + 40 + 4 + 40 + 4 + 40) )
|
|
S_Push( 0, 0 )
|
|
commoncode( show_letters[1] )
|
|
S_Pop()
|
|
S_Push( 18, 40+4 )
|
|
commoncode( show_letters[2] )
|
|
S_Pop()
|
|
S_Push( 18+24 - (40+24), 40+4+40+4 )
|
|
commoncode( show_letters[3] )
|
|
S_Pop()
|
|
S_Push( 0, 40+4+40+4+40+4 )
|
|
commoncode( show_letters[4] )
|
|
S_Pop()
|
|
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 trac2 = util.TraceLine( {
|
|
start = CamSpot(),
|
|
endpos = CamSpot() + TPSOverride:Forward()*(2^16),
|
|
filter = p,
|
|
} ).HitPos:ToScreen()
|
|
|
|
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)
|
|
S_Push( cx, cy )
|
|
local lol = shadowtime and 0 or 255
|
|
surface.SetDrawColor( lol, lol, lol )
|
|
surface.SetMaterial( shadowtime and xhair_dot_shadow or xhair_dot )
|
|
hTrRect( 0, 0, 64, 64, 0 )
|
|
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 |