forked from Not/srb2k-leaderboard
530 lines
11 KiB
Lua
530 lines
11 KiB
Lua
-- Leaderboards written by Not
|
|
|
|
local FILENAME = "leaderboard.txt"
|
|
local lb = {}
|
|
local timeFinished = 0
|
|
local disable = true
|
|
local prevLap = 0
|
|
local splits = {}
|
|
local PATCH = nil
|
|
local help = true
|
|
|
|
local Flags = 0
|
|
|
|
-- SPB flags with the least significance first
|
|
local F_SPBATK = 0x1
|
|
local F_SPBJUS = 0x2
|
|
local F_SPBBIG = 0x4
|
|
local F_SPBEXP = 0x8
|
|
|
|
local clearcheats = false
|
|
|
|
local startTime = 6 * TICRATE + (3 * TICRATE / 4)
|
|
|
|
-- patch caching function
|
|
local cachePatches
|
|
|
|
local function lbID(map, flags)
|
|
local id = tostring(map)
|
|
if flags & F_SPBATK then
|
|
id = id + "S"
|
|
end
|
|
|
|
return id
|
|
end
|
|
|
|
local function score_t(map, name, skin, color, time, splits, flags)
|
|
return {
|
|
["map"] = map,
|
|
["name"] = name,
|
|
["skin"] = skin,
|
|
["color"] = color,
|
|
["time"] = time,
|
|
["splits"] = splits,
|
|
["flags"] = flags
|
|
}
|
|
end
|
|
|
|
-- Read the leaderboard
|
|
local f = io.open(FILENAME, "r")
|
|
if f then
|
|
for l in f:lines() do
|
|
-- Leaderboard is stored in the following tab separated format
|
|
-- name, skin, color, time, splits, flags
|
|
local t = {}
|
|
for word in (l+"\t"):gmatch("(.-)\t") do
|
|
table.insert(t, word)
|
|
end
|
|
|
|
local flags = 0
|
|
if t[7] != nil then
|
|
flags = tonumber(t[7])
|
|
end
|
|
|
|
local lbt = lb[lbID(t[1], flags)]
|
|
if lbt == nil then
|
|
lbt = {}
|
|
end
|
|
|
|
local spl = {}
|
|
if t[6] != nil then
|
|
for str in t[6]:gmatch("([^ ]+)") do
|
|
table.insert(spl, tonumber(str))
|
|
end
|
|
end
|
|
|
|
table.insert(
|
|
lbt,
|
|
score_t(
|
|
t[1],
|
|
t[2],
|
|
t[3],
|
|
t[4],
|
|
tonumber(t[5]),
|
|
spl,
|
|
flags
|
|
)
|
|
)
|
|
lb[lbID(t[1], flags)] = lbt
|
|
end
|
|
f:close()
|
|
else
|
|
print("Failed to open file: ", FILENAME)
|
|
end
|
|
|
|
local function initLeaderboard(player)
|
|
local ingame = 0
|
|
for p in players.iterate do
|
|
if p.valid and not p.spectator then
|
|
ingame = ingame + 1
|
|
end
|
|
end
|
|
|
|
disable = ingame > 1
|
|
|
|
if disable or ingame == 0 then
|
|
-- Print the help message next time someone is alone
|
|
help = true
|
|
return
|
|
end
|
|
end
|
|
addHook("PlayerSpawn", initLeaderboard)
|
|
|
|
local function doyoudare(player)
|
|
if disable or player.spectator then
|
|
CONS_Printf(player, "How dare you")
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
|
|
local function retry(player, ...)
|
|
if doyoudare(player) then
|
|
COM_BufInsertText(server, "map " + G_BuildMapName(gamemap))
|
|
end
|
|
end
|
|
COM_AddCommand("retry", retry)
|
|
|
|
local function exitlevel(player, ...)
|
|
if doyoudare(player) then
|
|
G_ExitLevel()
|
|
end
|
|
end
|
|
COM_AddCommand("exit", exitlevel)
|
|
|
|
local function mapNotExists(player, map)
|
|
CONS_Printf(player, string.format("Map doesn't exist: %s", map:upper()))
|
|
end
|
|
|
|
local ALPH = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
|
|
local function changelevel(player, ...)
|
|
if not doyoudare(player) then
|
|
return
|
|
end
|
|
|
|
local map = ...
|
|
if map == nil then
|
|
CONS_Printf(player, "Usage: changelevel MAPXX")
|
|
return
|
|
end
|
|
|
|
local p, q = map:upper():match("MAP(%w)(%w)$", 1)
|
|
if not (p and q) then
|
|
CONS_Printf(player, string.format("Invalid map name: %s", map))
|
|
return
|
|
end
|
|
|
|
local mapnum = 0
|
|
if tonumber(p) != nil then
|
|
-- Non extended map numbers
|
|
if tonumber(q) == nil then
|
|
mapNotExists(player, map)
|
|
return
|
|
end
|
|
mapnum = tonumber(p) * 10 + tonumber(q)
|
|
else
|
|
--Extended map numbers
|
|
p = ALPH:find(p) - 1
|
|
q = (tonumber(q) or ALPH:find(q) + 9)
|
|
mapnum = 36 * p + q + 100
|
|
end
|
|
|
|
if mapheaderinfo[mapnum] == nil then
|
|
mapNotExists(player, map)
|
|
return
|
|
end
|
|
|
|
COM_BufInsertText(server, "map " + (G_BuildMapName(mapnum)))
|
|
end
|
|
COM_AddCommand("changelevel", changelevel)
|
|
|
|
local function clearcheats(player)
|
|
if not player.spectator then
|
|
clearcheats = true
|
|
CONS_Printf(player, "SPB Attack cheats will be cleared on next round")
|
|
end
|
|
end
|
|
COM_AddCommand("spba_clearcheats", clearcheats)
|
|
|
|
--DEBUGGING
|
|
--local function printTable(tb)
|
|
-- for k, v in pairs(tb) do
|
|
-- for i = 1, #v do
|
|
-- print("TABLE: " + k, tb[k])
|
|
-- if v[i] != nil then
|
|
-- print(
|
|
-- v[i]["name"],
|
|
-- v[i]["skin"],
|
|
-- v[i]["color"],
|
|
-- v[i]["time"],
|
|
-- table.concat(v[i]["splits"]),
|
|
-- v[i]["flags"],
|
|
-- ","
|
|
-- )
|
|
--
|
|
-- end
|
|
-- end
|
|
-- end
|
|
--end
|
|
|
|
addHook("MapLoad", function()
|
|
timeFinished = 0
|
|
splits = {}
|
|
prevLap = 0
|
|
--printTable(lb)
|
|
end
|
|
)
|
|
|
|
local function ticsToTime(tics)
|
|
return string.format(
|
|
"%d:%02d:%02d",
|
|
G_TicsToMinutes(tics),
|
|
G_TicsToSeconds(tics),
|
|
G_TicsToCentiseconds(tics)
|
|
)
|
|
end
|
|
|
|
-- Item patches have the amazing property of being displaced 12x 13y pixels
|
|
local iXoffset = 13 * FRACUNIT
|
|
local iYoffset = 12 * FRACUNIT
|
|
local function drawitem(v, x, y, scale, itempatch, vflags)
|
|
v.drawScaled(
|
|
x * FRACUNIT - FixedMul(iXoffset, scale),
|
|
y * FRACUNIT - FixedMul(iYoffset, scale),
|
|
scale,
|
|
itempatch,
|
|
vflags
|
|
)
|
|
end
|
|
|
|
local function marquee(text, maxwidth)
|
|
if #text <= maxwidth then
|
|
return text
|
|
end
|
|
|
|
local shift = 16
|
|
local pos = ((leveltime / 16) % (#text - maxwidth + shift * 2)) + 1 - shift
|
|
pos = min(max(pos, 1), #text - maxwidth + 1)
|
|
return text:sub(pos, pos + maxwidth - 1)
|
|
end
|
|
|
|
local bodium = {V_YELLOWMAP, V_GRAYMAP, V_BROWNMAP, 0}
|
|
local splitColor = {[true]=V_SKYMAP, [false]=V_REDMAP}
|
|
local splitSymbol = {[true]="-", [false]="+"}
|
|
|
|
local showSplit = 0
|
|
local function drawScoreboard(v, player)
|
|
if disable then return end
|
|
if player != displayplayers[0] then return end
|
|
|
|
cachePatches(v)
|
|
|
|
local m = lb[lbID(gamemap, Flags)]
|
|
if m == nil then
|
|
return
|
|
end
|
|
|
|
for i, score in ipairs(m) do
|
|
local name = score["name"]
|
|
local skin = skins[score["skin"]]
|
|
if skin == nil then
|
|
skin = skins["sonic"]
|
|
end
|
|
local skinPatch = PATCH["FACERANK"][skin.name]
|
|
|
|
-- | OFFSET | + | PADDING | * |INDEX|
|
|
local h = ((200 / 4) + 4) + (skinPatch.height + 4) * (i - 1)
|
|
|
|
v.draw(4, h, skinPatch, V_HUDTRANS, v.getColormap("sonic", score["color"]))
|
|
if player.name == name then
|
|
v.draw(4, h, PATCH["CHILI"][(leveltime / 4) % 8], V_HUDTRANS)
|
|
end
|
|
|
|
-- SPB
|
|
if score["flags"] & F_SPBATK then
|
|
local scale = FRACUNIT / 4
|
|
drawitem(
|
|
v,
|
|
4 - 2,
|
|
h - 2,
|
|
scale,
|
|
PATCH["SPB"],
|
|
V_HUDTRANS
|
|
)
|
|
if score["flags"] & F_SPBEXP then
|
|
drawitem(
|
|
v,
|
|
skinPatch.width,
|
|
h - 2,
|
|
scale,
|
|
PATCH["INV"][(leveltime / 4) % 6],
|
|
V_HUDTRANS
|
|
)
|
|
end
|
|
if score["flags"] & F_SPBBIG then
|
|
drawitem(
|
|
v,
|
|
4 - 2,
|
|
h + skinPatch.height - 4,
|
|
scale,
|
|
PATCH["BIG"],
|
|
V_HUDTRANS
|
|
)
|
|
end
|
|
if score["flags"] & F_SPBJUS then
|
|
drawitem(
|
|
v,
|
|
skinPatch.width,
|
|
h + skinPatch.height - 4,
|
|
scale,
|
|
PATCH["HYUD"],
|
|
V_HUDTRANS
|
|
)
|
|
end
|
|
end
|
|
|
|
-- Shorten long names
|
|
local stralign = "left"
|
|
local MAXWIDTH = 70
|
|
local px = 6
|
|
local py = 0
|
|
if v.stringWidth(name) > MAXWIDTH then
|
|
stralign = "thin"
|
|
py = -1
|
|
if v.stringWidth(name, 0, "thin") > MAXWIDTH then
|
|
stralign = "small"
|
|
py = 2
|
|
if v.stringWidth(name, 0, "small") > MAXWIDTH then
|
|
name = marquee(name, 15)
|
|
end
|
|
end
|
|
end
|
|
|
|
v.drawString(px + skinPatch.width, h + py, name, V_HUDTRANSHALF | V_ALLOWLOWERCASE, stralign)
|
|
|
|
-- Draw splits
|
|
if showSplit > 0 and score["splits"][prevLap] != nil then
|
|
local split = splits[prevLap] - score["splits"][prevLap]
|
|
v.drawString(px + skinPatch.width, h + 8, splitSymbol[split < 0] + ticsToTime(abs(split)), V_HUDTRANSHALF | splitColor[split < 0])
|
|
else
|
|
v.drawString(px + skinPatch.width, h + 8, ticsToTime(score["time"]), V_HUDTRANSHALF | bodium[min(i, 4)])
|
|
end
|
|
end
|
|
end
|
|
hud.add(drawScoreboard, "game")
|
|
|
|
function cachePatches(v)
|
|
if PATCH == nil then
|
|
PATCH = {}
|
|
|
|
PATCH["CHILI"] = {}
|
|
for i = 1, 8 do
|
|
PATCH["CHILI"][i-1] = v.cachePatch("K_CHILI" + i)
|
|
end
|
|
|
|
PATCH["FACERANK"] = {}
|
|
for skin in skins.iterate do
|
|
PATCH["FACERANK"][skin.name] = v.cachePatch(skin.facerank)
|
|
end
|
|
|
|
PATCH["SPB"] = v.cachePatch("K_ISSPB")
|
|
PATCH["INV"] = {}
|
|
for i = 1, 6 do
|
|
PATCH["INV"][i - 1] = v.cachePatch("K_ISINV" + i)
|
|
end
|
|
PATCH["BIG"] = v.cachePatch("K_ISGROW")
|
|
PATCH["HYUD"] = v.cachePatch("K_ISHYUD")
|
|
end
|
|
end
|
|
|
|
-- True if a is better than b
|
|
local function lbComp(a, b)
|
|
-- Calculates the difficulty, harder has higher priority
|
|
-- if s is positive then a is harder
|
|
-- if s is negative then b is harder
|
|
-- if s is 0 then compare time
|
|
local s = (a["flags"] & (F_SPBEXP | F_SPBBIG)) - (b["flags"] & (F_SPBEXP | F_SPBBIG))
|
|
return s > 0 or not(s < 0 or a["time"] > b["time"])
|
|
end
|
|
|
|
local function saveTime(player)
|
|
local m = lb[lbID(gamemap, Flags)]
|
|
if m == nil then
|
|
m = {}
|
|
end
|
|
local newscore = score_t(
|
|
gamemap,
|
|
player.name,
|
|
player.mo.skin,
|
|
player.skincolor,
|
|
timeFinished,
|
|
splits,
|
|
Flags
|
|
)
|
|
|
|
-- Check if you beat your previous best
|
|
for i = 1, #m do
|
|
if m[i]["name"] == player.name then
|
|
if lbComp(newscore, m[i]) then
|
|
table.remove(m, i)
|
|
S_StartSound(nil, 130)
|
|
break
|
|
else
|
|
-- You suck lol
|
|
S_StartSound(nil, 201)
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
print("Saving score")
|
|
table.insert(
|
|
m,
|
|
newscore
|
|
)
|
|
|
|
table.sort(m, lbComp)
|
|
while #m > 5 do
|
|
table.remove(m)
|
|
end
|
|
|
|
lb[lbID(gamemap, Flags)] = m
|
|
|
|
local f = assert(io.open(FILENAME, "w"))
|
|
if f == nil then
|
|
print("Failed to open file for writing: " + FILENAME)
|
|
return
|
|
end
|
|
|
|
for k, v in pairs(lb) do
|
|
for i = 1, #v do
|
|
local s = v[i]
|
|
f:write(
|
|
s["map"], "\t",
|
|
s["name"], "\t",
|
|
s["skin"], "\t",
|
|
s["color"], "\t",
|
|
s["time"], "\t",
|
|
table.concat(s["splits"], " "), "\t",
|
|
s["flags"], "\n"
|
|
)
|
|
end
|
|
end
|
|
|
|
f:close()
|
|
end
|
|
|
|
-- DEBUGGING
|
|
--local function saveLeaderboard(player, ...)
|
|
-- timeFinished = player.realtime
|
|
-- splits = {1000, 2000, 3000}
|
|
-- saveTime(player)
|
|
--end
|
|
--COM_AddCommand("save", saveLeaderboard)
|
|
|
|
local function regLap(player)
|
|
if player.laps > prevLap and timeFinished == 0 then
|
|
prevLap = player.laps
|
|
table.insert(splits, player.realtime)
|
|
showSplit = 5 * TICRATE
|
|
end
|
|
end
|
|
|
|
local function think()
|
|
if disable then
|
|
return
|
|
end
|
|
if showSplit > 0 then
|
|
showSplit = showSplit - 1
|
|
end
|
|
|
|
if leveltime < startTime then
|
|
-- Help message
|
|
if help and leveltime == startTime - TICRATE * 3 then
|
|
help = false
|
|
chatprint("\x89Leaderboard Commands:\nretry exit findmap changelevel spba_clearcheats", true)
|
|
end
|
|
|
|
Flags = $ & !(F_SPBATK | F_SPBEXP | F_SPBBIG | F_SPBJUS)
|
|
if leveltime > startTime - (3 * TICRATE) / 2 and server.SPBArunning then
|
|
Flags = $ | F_SPBATK
|
|
if server.SPBAexpert then
|
|
Flags = $ | F_SPBEXP
|
|
end
|
|
if clearcheats then
|
|
clearcheats = false
|
|
for p in players.iterate do
|
|
p.SPBAKARTBIG = false
|
|
p.SPBAjustice = false
|
|
p.SPBAshutup = false
|
|
end
|
|
end
|
|
for p in players.iterate do
|
|
if not p.spectator then
|
|
if p.SPBAKARTBIG then
|
|
Flags = $ | F_SPBBIG
|
|
end
|
|
if p.SPBAjustice then
|
|
Flags = $ | F_SPBJUS
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
for p in players.iterate do
|
|
if p.laps >= mapheaderinfo[gamemap].numlaps and timeFinished == 0 then
|
|
timeFinished = p.realtime
|
|
saveTime(p)
|
|
end
|
|
regLap(p)
|
|
end
|
|
end
|
|
addHook("ThinkFrame", think)
|
|
|
|
local function netvars(net)
|
|
lb = net($)
|
|
end
|
|
addHook("NetVars", netvars)
|