RaidTimes.lua is checked out with Windows line ends, and its text was split on newlines alone, so every line kept a carriage return on its last field. On a raid's boss list (L lines) that broke the last kill: a real saved Molten Core run showed 11 bosses, without Ragnaros. Chronicle slugs at the end of C / K lines got the same character. Every place that splits raid-time text into lines now splits on CR and LF: LoadChronicle, SeedSnapshot, NoteMasterLines, buildStream and R:Seed. The lines already saved in the feed are cleaned once (f.crFixed). Checked on the real saved line: 12 bosses, Ragnaros last. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
820 lines
31 KiB
Lua
820 lines
31 KiB
Lua
--[[--------------------------------------------------------------------
|
|
WhoDidIt - 5-man dungeon runs: timing, group names, the 5-man boards
|
|
|
|
A run is timed from the group's first combat inside the dungeon to the
|
|
death of its final boss (Data.lua D.DUNGEONS). Every boss on the way is a
|
|
split; deaths are counted. When the final boss dies, every WhoDidIt user
|
|
in the group says so on a hidden addon channel (WDI5, party / raid only):
|
|
C~key~optout~secs~leader~group name
|
|
Six seconds later each of them works out the same answer:
|
|
- anyone opted out (/wdi 5man off): the run stays on their own PCs only
|
|
- the time is the longest anyone timed (the earliest first pull)
|
|
- the sharer is the group leader if they have WhoDidIt, else the first
|
|
name alphabetically. The sharer names the group (once; the name is
|
|
remembered for the same five players) and tells the group:
|
|
N~key~secs~group name
|
|
The sharer then puts the run on the realm's hidden WhoDidIt channel
|
|
(Board.lua's sender), so does every other member with sharing on once the
|
|
sharer has named it, and members share their group's bests again when
|
|
someone asks (Q), so the boards fill up across the realm:
|
|
WDIB1~D~key~group name~secs~date~deaths~faction~Name:Cl,...~i=secs;...~named
|
|
A run is only taken from someone who was in it, and is sanity-checked.
|
|
Group names and player names come from other players: they're checked and
|
|
only ever shown in your own window, never posted to chat automatically.
|
|
----------------------------------------------------------------------]]
|
|
|
|
local W = WhoDidIt
|
|
local R = {}
|
|
W.Runs = R
|
|
|
|
local getn = table.getn
|
|
local floor = math.floor
|
|
|
|
local ADDON = "WDI5"
|
|
local VOTE_WAIT = 6 -- seconds to hear from the rest of the group
|
|
local NAME_WAIT = 90 -- seconds the sharer has to name the group
|
|
local FINAL_WAIT = 120 -- others: seconds to wait for the sharer's name
|
|
local MAX_GROUPS = 60 -- groups kept per dungeon per realm (yours always stay)
|
|
local MAX_MINE = 40 -- your own run history
|
|
local MAX_NAMES = 100 -- remembered group names
|
|
local MAX_FROM = 40 -- runs taken from one sender per session
|
|
|
|
-- class tokens in two letters (a run message has to fit in one chat line)
|
|
local CLASS = { WARRIOR = "Wa", PALADIN = "Pa", HUNTER = "Hu", ROGUE = "Ro", PRIEST = "Pr",
|
|
SHAMAN = "Sh", MAGE = "Ma", WARLOCK = "Wl", DRUID = "Dr" }
|
|
local CLASS_OF = {}
|
|
for k, v in pairs(CLASS) do CLASS_OF[v] = k end
|
|
R.CLASS_OF = CLASS_OF
|
|
|
|
local function D() return W.Data end
|
|
local function me() return UnitName("player") or "?" end
|
|
local function realm() return W.Board and W.Board.Realm() or (GetRealmName() or "Unknown") end
|
|
local function faction() return UnitFactionGroup("player") or "Neutral" end
|
|
|
|
-- sharing 5-man runs (the default; /wdi 5man off)
|
|
function R.On() return WhoDidItDB and WhoDidItDB.opts and not WhoDidItDB.opts.no5man and true or false end
|
|
|
|
------------------------------------------------------------------ formatting / checks
|
|
|
|
-- 12:34 or 1:02:03
|
|
function R.Fmt(secs)
|
|
if not secs then return "-" end
|
|
secs = floor(secs + 0.5)
|
|
if secs >= 3600 then
|
|
return string.format("%d:%02d:%02d", floor(secs / 3600), floor(math.mod(secs, 3600) / 60), math.mod(secs, 60))
|
|
end
|
|
return string.format("%d:%02d", floor(secs / 60), math.mod(secs, 60))
|
|
end
|
|
|
|
local function trim(s)
|
|
local _, _, v = string.find(s or "", "^%s*(.-)%s*$")
|
|
return v or ""
|
|
end
|
|
|
|
-- a group name: 2-24 characters, no colour codes / links and none of the
|
|
-- characters the messages use as separators
|
|
function R.OkName(s)
|
|
return type(s) == "string" and string.len(s) >= 2 and string.len(s) <= 24
|
|
and not string.find(s, "[%c|~;,=:]") and string.find(s, "[^%s]") and true or false
|
|
end
|
|
function R.CleanName(s)
|
|
s = trim(string.gsub(s or "", "[%c|~;,=:]", ""))
|
|
s = string.gsub(s, "%s+", " ")
|
|
if string.len(s) > 24 then s = trim(string.sub(s, 1, 24)) end
|
|
return s
|
|
end
|
|
|
|
-- a character name (WoW allows accented letters: those bytes pass)
|
|
local function okPlayer(n)
|
|
return type(n) == "string" and string.len(n) >= 2 and string.len(n) <= 24 and not string.find(n, "[%c%d%p%s]") and true or false
|
|
end
|
|
|
|
-- "Name:Wa,Name:Pr" -> { { n = "Name", c = "WARRIOR" }, ... }, the same text sorted,
|
|
-- and the group's key (the names sorted). nil if anything is off.
|
|
function R.Members(m)
|
|
if type(m) ~= "string" or m == "" or string.len(m) > 200 then return nil end
|
|
local list, seen = {}, {}
|
|
for part in string.gfind(m .. ",", "([^,]*),") do
|
|
local _, _, n, c = string.find(part, "^(.-):(%a%a)$")
|
|
if not n or not okPlayer(n) or not CLASS_OF[c] or seen[n] then return nil end
|
|
seen[n] = true
|
|
tinsert(list, { n = n, c = CLASS_OF[c], code = c })
|
|
end
|
|
if getn(list) == 0 or getn(list) > 10 then return nil end
|
|
table.sort(list, function(a, b) return a.n < b.n end)
|
|
local txt, names = {}, {}
|
|
for i = 1, getn(list) do
|
|
tinsert(txt, list[i].n .. ":" .. list[i].code)
|
|
tinsert(names, list[i].n)
|
|
end
|
|
return list, table.concat(txt, ","), table.concat(names, ",")
|
|
end
|
|
|
|
-- is this character in the run?
|
|
function R.HasMember(rec, name)
|
|
return rec and rec.m and string.find("," .. rec.m, "," .. (name or me()) .. ":", 1, true) and true or false
|
|
end
|
|
|
|
-- rec.ok = "Name,Name": the members this PC saw share the group's runs themselves (their
|
|
-- own vote, or the run sent by them on the realm channel), so they have WhoDidIt with
|
|
-- sharing on. Only their names may go into the published download and the website
|
|
-- export. Never taken from what a message claims. true if the name was new.
|
|
local function addOk(rec, name)
|
|
if not rec or not name or not R.HasMember(rec, name) then return false end
|
|
if string.find("," .. (rec.ok or "") .. ",", "," .. name .. ",", 1, true) then return false end
|
|
rec.ok = (rec.ok and rec.ok ~= "") and (rec.ok .. "," .. name) or name
|
|
return true
|
|
end
|
|
|
|
-- "3=125;7=610" (boss number = seconds into the run) -> checked text, or ""
|
|
local function okSplits(s, dg, t)
|
|
if type(s) ~= "string" or s == "" then return "" end
|
|
local out = {}
|
|
for part in string.gfind(s .. ";", "([^;]*);") do
|
|
local _, _, i, at = string.find(part, "^(%d+)=(%d+)$")
|
|
i, at = tonumber(i), tonumber(at)
|
|
if i and at and dg.bosses[i] and at <= (t or 0) then tinsert(out, i .. "=" .. at) end
|
|
end
|
|
return table.concat(out, ";")
|
|
end
|
|
|
|
-- a run's splits: { { name, at }, ... } in the order they died
|
|
function R.Splits(rec, key)
|
|
local dg = D().DUNGEON[key]
|
|
local out = {}
|
|
if not dg or not rec or not rec.s then return out end
|
|
for part in string.gfind(rec.s .. ";", "([^;]*);") do
|
|
local _, _, i, at = string.find(part, "^(%d+)=(%d+)$")
|
|
i, at = tonumber(i), tonumber(at)
|
|
if i and dg.bosses[i] then tinsert(out, { name = dg.bosses[i], at = at }) end
|
|
end
|
|
table.sort(out, function(a, b) return a.at < b.at end)
|
|
return out
|
|
end
|
|
|
|
------------------------------------------------------------------ storage
|
|
-- WhoDidItDB.dungeons[realm][key][group key] = { g = group name, t = secs,
|
|
-- d = date, x = deaths, f = faction, n = size, m = members, s = splits,
|
|
-- nt = when it was named, by = who shared it, net = from the channel,
|
|
-- priv = never shared (someone in the group opted out), ok = members seen sharing it }
|
|
-- WhoDidItDB.myRuns = your runs, newest first (every one, not only bests)
|
|
-- WhoDidItDB.groupNames[group key] = { n = name, at = when }
|
|
|
|
function R:DB(rlm)
|
|
if type(WhoDidItDB.dungeons) ~= "table" then WhoDidItDB.dungeons = {} end
|
|
rlm = rlm or realm()
|
|
local r = WhoDidItDB.dungeons[rlm]
|
|
if not r then
|
|
r = {}
|
|
WhoDidItDB.dungeons[rlm] = r
|
|
end
|
|
return r
|
|
end
|
|
|
|
function R:MyRuns()
|
|
if type(WhoDidItDB.myRuns) ~= "table" then WhoDidItDB.myRuns = {} end
|
|
return WhoDidItDB.myRuns
|
|
end
|
|
|
|
function R:GroupName(gk)
|
|
local g = type(WhoDidItDB.groupNames) == "table" and WhoDidItDB.groupNames[gk]
|
|
return g and g.n
|
|
end
|
|
|
|
local function rememberName(gk, name)
|
|
if type(WhoDidItDB.groupNames) ~= "table" then WhoDidItDB.groupNames = {} end
|
|
local t = WhoDidItDB.groupNames
|
|
t[gk] = { n = name, at = time() }
|
|
local n, oldest, oldAt = 0, nil, nil
|
|
for k, v in pairs(t) do
|
|
n = n + 1
|
|
if not oldAt or (v.at or 0) < oldAt then oldest, oldAt = k, v.at or 0 end
|
|
end
|
|
if n > MAX_NAMES and oldest then t[oldest] = nil end
|
|
end
|
|
|
|
-- keep a run if it's that group's best there (or the same time, newly named);
|
|
-- true if it changed the board
|
|
function R:Merge(rlm, key, gk, rec)
|
|
local r = R:DB(rlm)
|
|
local list = r[key]
|
|
if not list then
|
|
list = {}
|
|
r[key] = list
|
|
end
|
|
local old = list[gk]
|
|
if old and (rec.t > old.t or (rec.t == old.t and (rec.nt or 0) <= (old.nt or 0))) then return false end
|
|
if old and old.priv and rec.t == old.t then rec.priv = true end
|
|
-- (the same players: who's been seen sharing stays known)
|
|
if old and old.ok then
|
|
for n in string.gfind(old.ok, "[^,]+") do addOk(rec, n) end
|
|
end
|
|
list[gk] = rec
|
|
-- the 60 fastest groups per dungeon; groups you were in always stay
|
|
local n, slowest, slowT = 0, nil, -1
|
|
for k, r2 in pairs(list) do
|
|
n = n + 1
|
|
if r2.t > slowT and not R.HasMember(r2) then slowest, slowT = k, r2.t end
|
|
end
|
|
if n > MAX_GROUPS and slowest then
|
|
list[slowest] = nil
|
|
if slowest == gk then return false end
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- realms with 5-man data (yours first)
|
|
function R:Realms()
|
|
local list, have = { realm() }, {}
|
|
have[list[1]] = true
|
|
for rl in pairs(WhoDidItDB.dungeons or {}) do
|
|
if not have[rl] then tinsert(list, rl); have[rl] = true end
|
|
end
|
|
return list
|
|
end
|
|
|
|
-- sorted { gk, rec, realm } for one dungeon. rlm may be W.Board.ALL;
|
|
-- fac "All" or a faction
|
|
function R:Board(rlm, key, fac)
|
|
local realms = (W.Board and rlm == W.Board.ALL) and R:Realms() or { rlm or realm() }
|
|
local out = {}
|
|
for i = 1, getn(realms) do
|
|
local r = WhoDidItDB.dungeons and WhoDidItDB.dungeons[realms[i]]
|
|
for gk, rec in pairs(r and r[key] or {}) do
|
|
if fac == "All" or not fac or rec.f == fac then tinsert(out, { gk, rec, realms[i] }) end
|
|
end
|
|
end
|
|
table.sort(out, function(a, b) return a[2].t < b[2].t end)
|
|
return out
|
|
end
|
|
|
|
-- your best run in a dungeon (any group you were in), from your history or the board
|
|
function R:MyBest(key)
|
|
local best
|
|
local mine = R:MyRuns()
|
|
for i = 1, getn(mine) do
|
|
local e = mine[i]
|
|
if e.k == key and (not best or e.t < best.t) then best = e end
|
|
end
|
|
return best
|
|
end
|
|
|
|
-- where a time ranks on a dungeon's board
|
|
function R:Place(rlm, key, secs, fac)
|
|
local list = R:Board(rlm, key, fac or "All")
|
|
local place = 1
|
|
for i = 1, getn(list) do
|
|
if list[i][2].t < secs then place = place + 1 end
|
|
end
|
|
return place, getn(list)
|
|
end
|
|
|
|
-- one chat line: a dungeon's three fastest groups (posted only through W:ConfirmSend)
|
|
function R:TopLine(key, rlm, fac)
|
|
local dg = key and D().DUNGEON[key]
|
|
if not dg then return nil end
|
|
local list = R:Board(rlm, key, fac or "All")
|
|
if getn(list) == 0 then return nil end
|
|
local all = W.Board and rlm == W.Board.ALL
|
|
local parts = {}
|
|
for i = 1, math.min(3, getn(list)) do
|
|
tinsert(parts, "#" .. i .. " " .. list[i][2].g .. (all and (" (" .. list[i][3] .. ")") or "") .. " " .. R.Fmt(list[i][2].t))
|
|
end
|
|
local where = all and "every realm" or (W.Board and W.Board.RealmLabel(rlm) or rlm)
|
|
return "[WhoDidIt] fastest " .. dg.title .. " groups on " .. where .. ": " .. table.concat(parts, ", ")
|
|
end
|
|
|
|
------------------------------------------------------------------ the group
|
|
|
|
local function groupUnits()
|
|
local out = {}
|
|
local nr = GetNumRaidMembers()
|
|
if nr > 0 then
|
|
for i = 1, nr do tinsert(out, "raid" .. i) end
|
|
else
|
|
tinsert(out, "player")
|
|
for i = 1, GetNumPartyMembers() do tinsert(out, "party" .. i) end
|
|
end
|
|
return out
|
|
end
|
|
|
|
-- the group right now: members text ("Name:Cl,..." sorted), group key, size
|
|
function R.Group()
|
|
local parts = {}
|
|
local units = groupUnits()
|
|
for i = 1, getn(units) do
|
|
local u = units[i]
|
|
local n = UnitExists(u) and UnitName(u)
|
|
local _, c = UnitClass(u)
|
|
if n and n ~= UNKNOWNOBJECT and CLASS[c or ""] then tinsert(parts, n .. ":" .. CLASS[c]) end
|
|
end
|
|
local list, m, gk = R.Members(table.concat(parts, ","))
|
|
return m, gk, list and getn(list) or 0
|
|
end
|
|
|
|
local function groupChannel()
|
|
if GetNumRaidMembers() > 0 then return "RAID" end
|
|
if GetNumPartyMembers() > 0 then return "PARTY" end
|
|
end
|
|
|
|
local function amLeader()
|
|
if GetNumRaidMembers() > 0 then return IsRaidLeader() and true or false end
|
|
if GetNumPartyMembers() > 0 then return IsPartyLeader() and true or false end
|
|
return true
|
|
end
|
|
|
|
------------------------------------------------------------------ recording
|
|
|
|
local function charKey() return me() .. "-" .. realm() end
|
|
|
|
-- the run in progress (saved, so a /reload inside keeps it)
|
|
local function cur()
|
|
if type(WhoDidItDB.run5) ~= "table" then WhoDidItDB.run5 = {} end
|
|
local r = WhoDidItDB.run5[charKey()]
|
|
if r and time() - (r.at or 0) > D().RUN_MAX then
|
|
WhoDidItDB.run5[charKey()] = nil
|
|
return nil
|
|
end
|
|
return r
|
|
end
|
|
local function setCur(r)
|
|
if type(WhoDidItDB.run5) ~= "table" then WhoDidItDB.run5 = {} end
|
|
WhoDidItDB.run5[charKey()] = r
|
|
end
|
|
|
|
-- in a dungeon (any instance that isn't one of the timed raids or Karazhan's towers)
|
|
local function dungeonZone()
|
|
local inInst = IsInInstance()
|
|
if not inInst then return nil end
|
|
local zone = GetRealZoneText()
|
|
if not zone or zone == "" or W.Data.clears[zone] or W.Data.sharedZones[zone] then return nil end
|
|
return zone
|
|
end
|
|
|
|
function R:Current()
|
|
if not WhoDidItDB then return nil end
|
|
local r = cur()
|
|
if r and r.at then return r end
|
|
end
|
|
|
|
local armed -- the zone a fresh run starts in at the next pull
|
|
|
|
-- zoning in: a new run unless we're carrying on the same one (died and ran
|
|
-- back, a /reload). After a final boss, the next zone-in is a new run (Dire
|
|
-- Maul's wings, a reset instance).
|
|
-- (nothing is thrown away here, only at the next pull: the zone text can lag
|
|
-- behind on a loading screen, and the next zone event puts it right)
|
|
local function zoned()
|
|
if not WhoDidItDB then return end
|
|
local zone = dungeonZone()
|
|
local r = cur()
|
|
if not zone or (r and r.zone == zone and not r.fin) then armed = nil return end
|
|
armed = zone
|
|
end
|
|
W:On("PLAYER_ENTERING_WORLD", zoned)
|
|
W:On("ZONE_CHANGED_NEW_AREA", zoned)
|
|
|
|
W:On("PLAYER_REGEN_DISABLED", function()
|
|
if not WhoDidItDB then return end
|
|
local zone = dungeonZone()
|
|
local r = cur()
|
|
if not zone or (r and r.zone == zone and not r.fin) or zone ~= armed then return end
|
|
armed = nil
|
|
setCur({ zone = zone, at = time(), k = {}, x = 0 })
|
|
end)
|
|
|
|
local complete -- (below)
|
|
|
|
local function bossDied(name)
|
|
if not name or not D().DUNGEON_BOSS[name] then return end
|
|
local r = R:Current()
|
|
if not r or r.zone ~= dungeonZone() then return end
|
|
if r.k[name] then
|
|
-- the same boss twice: a new instance. The time starts again at the next zone-in.
|
|
setCur(nil)
|
|
W.Print("|cff33ccff5-man:|r " .. name .. " died twice - a new instance? The run timer starts again when you next zone in.")
|
|
return
|
|
end
|
|
r.k[name] = time() - r.at
|
|
local key = D().DUNGEON_FINAL[name]
|
|
if key and not (r.done and r.done[key]) then
|
|
r.done = r.done or {}
|
|
r.done[key] = true
|
|
r.fin = true
|
|
complete(key, r, name)
|
|
end
|
|
end
|
|
|
|
W:On("CHAT_MSG_COMBAT_HOSTILE_DEATH", function(msg)
|
|
if not msg then return end
|
|
local _, _, name = string.find(msg, "^(.+) dies%.$")
|
|
if not name then _, _, name = string.find(msg, "^You have slain (.+)!$") end
|
|
if not name then _, _, name = string.find(msg, "^(.+) is destroyed%.$") end
|
|
bossDied(name)
|
|
end)
|
|
|
|
W:On("CHAT_MSG_COMBAT_FRIENDLY_DEATH", function(msg)
|
|
if not msg or not WhoDidItDB then return end
|
|
local r = R:Current()
|
|
if not r or r.zone ~= dungeonZone() then return end
|
|
local _, _, name = string.find(msg, "^(.+) dies%.$")
|
|
if msg == UNITDIESSELF then name = me() end
|
|
if name and W.roster.byName[name] then r.x = (r.x or 0) + 1 end
|
|
end)
|
|
|
|
------------------------------------------------------------------ finishing a run
|
|
|
|
local pend -- the run being agreed on: { key, gk, m, n, s, x, secs, votes, t0, ... }
|
|
local early = {} -- votes heard before our own final-boss message: sender -> { key, ..., at }
|
|
|
|
local function say(text) W.Print("|cff33ccff5-man:|r " .. text) end
|
|
|
|
complete = function(key, r, boss)
|
|
local dg = D().DUNGEON[key]
|
|
local secs = r.k[boss] or (time() - r.at)
|
|
r.cs, r.key = secs, key -- (the run timer shows the final time)
|
|
local m, gk, n = R.Group()
|
|
local tail = " |cff888888(" .. boss .. " ended it)|r"
|
|
if not m then return end
|
|
if n > (dg.max or D().GROUP_MAX) then
|
|
say(dg.title .. " done in " .. R.Fmt(secs) .. " - not ranked: a group of " .. n .. tail)
|
|
return
|
|
end
|
|
if secs < D().RUN_MIN then
|
|
say(dg.title .. " done in " .. R.Fmt(secs) .. " - not ranked: the timer started mid-run (it starts at the first pull after zoning in)" .. tail)
|
|
return
|
|
end
|
|
local splits = {}
|
|
for i = 1, getn(dg.bosses) do
|
|
local at = r.k[dg.bosses[i]]
|
|
if at then tinsert(splits, i .. "=" .. at) end
|
|
end
|
|
pend = { key = key, gk = gk, m = m, n = n, s = table.concat(splits, ";"), x = r.x or 0,
|
|
secs = secs, votes = {}, t0 = GetTime(), boss = boss }
|
|
pend.votes[me()] = { opt = not R.On(), secs = secs, lead = amLeader(), name = R:GroupName(gk) }
|
|
local ch = groupChannel()
|
|
if ch then
|
|
for who, v in pairs(early) do
|
|
if v.key == key and GetTime() - v.at < 15 then pend.votes[who] = v end
|
|
end
|
|
early = {}
|
|
SendAddonMessage(ADDON, table.concat({ "C", key, R.On() and "0" or "1", tostring(secs), amLeader() and "1" or "0",
|
|
R:GroupName(gk) or "" }, "~"), ch)
|
|
say(dg.title .. " done in |cffffffff" .. R.Fmt(secs) .. "|r" .. tail .. " - checking with the group...")
|
|
else
|
|
pend.t0 = GetTime() - VOTE_WAIT -- on your own: nobody to wait for
|
|
say(dg.title .. " done in |cffffffff" .. R.Fmt(secs) .. "|r" .. tail)
|
|
end
|
|
end
|
|
|
|
-- a finished run goes on your boards and history; the sharer also sends it out
|
|
local function finish(name, secs, share)
|
|
local p = pend
|
|
pend = nil
|
|
if not p then return end
|
|
local dg = D().DUNGEON[p.key]
|
|
if not R.OkName(name) then name = me() .. "'s group" end
|
|
rememberName(p.gk, name)
|
|
local rec = { g = name, t = secs, d = time(), x = p.x, f = faction(), n = p.n, m = p.m, s = p.s, nt = time(),
|
|
by = me(), priv = p.priv or nil }
|
|
local rl = realm()
|
|
local old = R:Board(rl, p.key, "All")
|
|
local was
|
|
for i = 1, getn(old) do if old[i][1] == p.gk then was = old[i][2].t end end
|
|
local better = R:Merge(rl, p.key, p.gk, rec)
|
|
-- the members who said in their own vote that they share (sharing on)
|
|
local stored = R:DB(rl)[p.key] and R:DB(rl)[p.key][p.gk]
|
|
if stored and not p.priv then
|
|
for who, v in pairs(p.votes or {}) do
|
|
if not v.opt then addOk(stored, who) end
|
|
end
|
|
end
|
|
local mine = R:MyRuns()
|
|
tinsert(mine, 1, { k = p.key, gk = p.gk, realm = rl, g = name, t = secs, d = rec.d, x = rec.x, f = rec.f, n = rec.n, m = rec.m, s = rec.s })
|
|
while getn(mine) > MAX_MINE do tremove(mine) end
|
|
local place, of = R:Place(rl, p.key, secs)
|
|
say("|cffffd100" .. name .. "|r: " .. dg.title .. " in |cffffffff" .. R.Fmt(secs) .. "|r, " .. p.x .. " death" .. (p.x == 1 and "" or "s")
|
|
.. " - #" .. place .. " of " .. of .. " on " .. rl
|
|
.. ((was and better) and (" |cff33ff33(group best, was " .. R.Fmt(was) .. ")|r") or "")
|
|
.. (p.priv and " |cff888888(kept on your PC: someone in the group has 5-man sharing off)|r" or ""))
|
|
if share and better and not p.priv and R.On() then R:Share(p.key, rec) end
|
|
R.dirty = true
|
|
if W.UI and W.UI.mode == "rankings" then W.UI:Refresh() end
|
|
end
|
|
|
|
-- the sharer names the group (once: the name is remembered for these players)
|
|
StaticPopupDialogs["WHODIDIT_GROUPNAME"] = {
|
|
text = "%s",
|
|
button1 = ACCEPT, button2 = CANCEL,
|
|
hasEditBox = 1, maxLetters = 24,
|
|
OnShow = function()
|
|
local eb = getglobal(this:GetName() .. "EditBox")
|
|
eb:SetText(R.nameDefault or "")
|
|
eb:HighlightText()
|
|
eb:SetFocus()
|
|
R.namePopup = this
|
|
end,
|
|
OnAccept = function()
|
|
local eb = R.namePopup and getglobal(R.namePopup:GetName() .. "EditBox")
|
|
if eb then R:Named(eb:GetText()) end
|
|
end,
|
|
OnCancel = function() R:Named(nil) end,
|
|
EditBoxOnEnterPressed = function()
|
|
local text = this:GetText()
|
|
this:GetParent():Hide()
|
|
R:Named(text)
|
|
end,
|
|
EditBoxOnEscapePressed = function() this:GetParent():Hide() end,
|
|
timeout = 0, whileDead = 1, hideOnEscape = 1,
|
|
}
|
|
|
|
-- the sharer's name for the group (nil: the default)
|
|
function R:Named(text)
|
|
local p = pend
|
|
if not p or not p.naming then return end
|
|
p.naming = nil
|
|
local name = R.CleanName(text or "")
|
|
if not R.OkName(name) then name = R.nameDefault end
|
|
local ch = groupChannel()
|
|
if ch then SendAddonMessage(ADDON, table.concat({ "N", p.key, tostring(p.final), name }, "~"), ch) end
|
|
finish(name, p.final, true)
|
|
end
|
|
|
|
-- six seconds after the final boss: everyone works out the same answer
|
|
local function decide()
|
|
local p = pend
|
|
p.decided = true
|
|
local names, secs, opt, lead = {}, p.secs, false, nil
|
|
for who, v in pairs(p.votes) do
|
|
tinsert(names, who)
|
|
if v.opt then opt = true end
|
|
if v.secs and v.secs > secs and v.secs <= D().RUN_MAX then secs = v.secs end
|
|
if v.lead then lead = who end
|
|
end
|
|
table.sort(names)
|
|
p.final, p.priv = secs, opt or nil
|
|
p.sharer = lead or names[1]
|
|
if p.sharer ~= me() then
|
|
p.waitUntil = GetTime() + FINAL_WAIT
|
|
return
|
|
end
|
|
-- I'm the sharer: a name we already have, or ask
|
|
local name = R:GroupName(p.gk)
|
|
if not name then
|
|
for i = 1, getn(names) do
|
|
local v = p.votes[names[i]]
|
|
if v.name and R.OkName(v.name) then name = v.name break end
|
|
end
|
|
end
|
|
if name then
|
|
p.naming = true
|
|
R:Named(name)
|
|
return
|
|
end
|
|
p.naming = true
|
|
p.nameBy = GetTime() + NAME_WAIT
|
|
R.nameDefault = me() .. "'s group"
|
|
local dg = D().DUNGEON[p.key]
|
|
local list = R.Members(p.m) or {}
|
|
local who = {}
|
|
for i = 1, getn(list) do tinsert(who, W.CName(list[i].n, list[i].c)) end
|
|
StaticPopup_Show("WHODIDIT_GROUPNAME", "|cffffd100" .. dg.title .. "|r in |cffffffff" .. R.Fmt(secs) .. "|r\n" .. table.concat(who, ", ")
|
|
.. "\n\nName your group for the 5-man rankings:\n|cff888888(remembered for these players; rename it any time in Rankings > 5-mans)|r")
|
|
end
|
|
|
|
W:On("CHAT_MSG_ADDON", function(prefix, msg, channel, sender)
|
|
if prefix ~= ADDON or not msg or not sender or not WhoDidItDB then return end
|
|
if channel ~= "PARTY" and channel ~= "RAID" then return end
|
|
if sender == me() then return end
|
|
if not W.roster.byName[sender] then return end -- only from someone in the group
|
|
local p = {}
|
|
for part in string.gfind(msg .. "~", "([^~]*)~") do tinsert(p, part) end
|
|
if p[1] == "C" then
|
|
local v = { key = p[2], opt = (p[3] == "1"), secs = tonumber(p[4]), lead = (p[5] == "1"),
|
|
name = R.OkName(p[6]) and p[6] or nil, at = GetTime() }
|
|
if not D().DUNGEON[v.key or ""] then return end
|
|
if pend and pend.key == v.key and not pend.decided then pend.votes[sender] = v
|
|
elseif not pend then early[sender] = v end
|
|
elseif p[1] == "N" and pend and pend.decided and pend.key == p[2] and sender == pend.sharer then
|
|
local secs = tonumber(p[3])
|
|
if not secs or secs < D().RUN_MIN or secs > D().RUN_MAX then secs = pend.final end
|
|
-- every member with sharing on sends it too, so the maintainer's WhoDidIt hears from
|
|
-- each of them (only then can their name go into the published download)
|
|
finish(R.OkName(p[4]) and p[4] or (sender .. "'s group"), secs, true)
|
|
end
|
|
end)
|
|
|
|
W:Every(1, function()
|
|
local p = pend
|
|
if not p then return end
|
|
local now = GetTime()
|
|
if not p.decided then
|
|
if now - p.t0 >= VOTE_WAIT then decide() end
|
|
elseif p.naming and p.nameBy and now > p.nameBy then
|
|
StaticPopup_Hide("WHODIDIT_GROUPNAME")
|
|
if pend == p and p.naming then R:Named(nil) end
|
|
elseif p.waitUntil and now > p.waitUntil then
|
|
-- the sharer never said: keep it here with the name we know
|
|
finish(R:GroupName(p.gk) or (p.sharer .. "'s group"), p.final, false)
|
|
end
|
|
end)
|
|
|
|
------------------------------------------------------------------ renaming
|
|
|
|
-- rename a group you're in: every board, your history, and shared again
|
|
function R:Rename(gk, name)
|
|
name = R.CleanName(name)
|
|
if not R.OkName(name) then
|
|
W.Print("A group name is 2-24 characters, without | ~ ; , = or :")
|
|
return false
|
|
end
|
|
rememberName(gk, name)
|
|
local now = time()
|
|
for rl, r in pairs(WhoDidItDB.dungeons or {}) do
|
|
for key, list in pairs(r) do
|
|
local rec = list[gk]
|
|
if rec and R.HasMember(rec) then
|
|
rec.g, rec.nt = name, now
|
|
if rl == realm() and not rec.priv and R.On() then R:Share(key, rec) end
|
|
end
|
|
end
|
|
end
|
|
local mine = R:MyRuns()
|
|
for i = 1, getn(mine) do
|
|
if mine[i].gk == gk then mine[i].g = name end
|
|
end
|
|
R.dirty = true
|
|
W.Print("Your group is now called |cffffd100" .. name .. "|r.")
|
|
if W.UI then W.UI:Refresh() end
|
|
return true
|
|
end
|
|
|
|
------------------------------------------------------------------ the realm channel
|
|
|
|
local PROTO, SEP = "WDIB1", "~"
|
|
local seen, nSeen = {}, 0 -- "key~gk" -> GetTime() last seen on the channel (forgotten past 2000)
|
|
local from, nFrom = {}, 0 -- sender -> runs taken this session (forgotten past 500 senders)
|
|
local function saw(id)
|
|
if not seen[id] then
|
|
nSeen = nSeen + 1
|
|
if nSeen > 2000 then seen, nSeen = {}, 1 end
|
|
end
|
|
seen[id] = GetTime()
|
|
end
|
|
|
|
function R.Line(key, rec)
|
|
local parts = { PROTO, "D", key, rec.g, tostring(rec.t), tostring(rec.d), tostring(rec.x or 0), rec.f or "?", rec.m, rec.s or "", tostring(rec.nt or rec.d) }
|
|
local s = table.concat(parts, SEP)
|
|
if string.len(s) > 250 then
|
|
parts[10] = "" -- too long for one chat line: the splits stay home
|
|
s = table.concat(parts, SEP)
|
|
end
|
|
return s
|
|
end
|
|
|
|
function R:Share(key, rec)
|
|
if not R.On() or not W.Board or not W.Board.QueueOut or rec.priv then return end
|
|
local _, _, gk = R.Members(rec.m)
|
|
if not gk then return end
|
|
W.Board.QueueOut(R.Line(key, rec))
|
|
saw(key .. SEP .. gk)
|
|
end
|
|
|
|
-- someone asked (Q): our groups' bests, unless someone just sent them
|
|
function R:Answer()
|
|
if not R.On() then return end
|
|
local r = WhoDidItDB.dungeons and WhoDidItDB.dungeons[realm()]
|
|
local now, sent = GetTime(), 0
|
|
for key, list in pairs(r or {}) do
|
|
for gk, rec in pairs(list) do
|
|
local id = key .. SEP .. gk
|
|
if sent < 8 and not rec.priv and R.HasMember(rec) and not (seen[id] and now - seen[id] < 300) then
|
|
R:Share(key, rec)
|
|
sent = sent + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- a run from the channel (p = the message split on ~)
|
|
function R:Receive(p, sender)
|
|
if not sender or not WhoDidItDB then return end
|
|
local key, g, secs, d, x, fac, m, s, nt = p[3], p[4], tonumber(p[5]), tonumber(p[6]), tonumber(p[7]), p[8], p[9], p[10], tonumber(p[11])
|
|
local dg = key and D().DUNGEON[key]
|
|
if not dg or not R.OkName(g) or not secs or not d or not x then return end
|
|
if secs < D().RUN_MIN or secs > D().RUN_MAX or d > time() + 86400 or d < 1700000000 or x < 0 or x > 99 then return end
|
|
if fac ~= "Alliance" and fac ~= "Horde" then return end
|
|
local list, mt, gk = R.Members(m)
|
|
if not list or getn(list) > (dg.max or D().GROUP_MAX) then return end
|
|
-- only someone who was in the group can share its run
|
|
local inIt
|
|
for i = 1, getn(list) do if list[i].n == sender then inIt = true end end
|
|
if not inIt then return end
|
|
if not from[sender] then
|
|
nFrom = nFrom + 1
|
|
if nFrom > 500 then from, nFrom = {}, 1 end
|
|
end
|
|
from[sender] = (from[sender] or 0) + 1
|
|
if from[sender] > MAX_FROM then return end
|
|
if not nt or nt > time() + 86400 or nt < d then nt = d end
|
|
saw(key .. SEP .. gk)
|
|
local rec = { g = g, t = secs, d = d, x = x, f = fac, n = getn(list), m = mt, s = okSplits(s, dg, secs), nt = nt, by = sender, net = true }
|
|
if R:Merge(realm(), key, gk, rec) then
|
|
R.dirty = true
|
|
if W.UI and W.UI.mode == "rankings" then W.UI:Refresh() end
|
|
end
|
|
-- the sender shares this group's runs themselves (the server says who sent it)
|
|
local stored = R:DB(realm())[key]
|
|
stored = stored and stored[gk]
|
|
if stored and addOk(stored, sender) then R.dirty = true end
|
|
end
|
|
|
|
------------------------------------------------------------------ the download's runs, the master's file
|
|
-- RaidTimes.lua (the maintainer's publish) carries the realms' 5-man runs as
|
|
-- R5|realm|key|group|secs|date|deaths|faction|members|splits|named
|
|
-- and they go on the boards once per publish. The master's WhoDidIt writes its
|
|
-- boards to CustomData\WhoDidIt_Runs.txt, the same lines plus |ok (rec.ok: the
|
|
-- members it saw share the run themselves). Names are only published for those:
|
|
-- tools\Publish-RaidTimes.ps1 takes a run only when every member is in ok, and
|
|
-- tools\Website-Export.ps1 shows the others by class only.
|
|
|
|
local function splitBar(line)
|
|
local out = {}
|
|
for part in string.gfind(line .. "|", "([^|]*)|") do tinsert(out, part) end
|
|
return out
|
|
end
|
|
|
|
function R:Seed()
|
|
local s = WDI_RAIDTIMES
|
|
if type(s) ~= "table" or type(s.text) ~= "string" or not tonumber(s.synced) then return end
|
|
if (WhoDidItDB.runSeed or 0) >= s.synced then return end
|
|
WhoDidItDB.runSeed = s.synced
|
|
for line in string.gfind(s.text, "[^\r\n]+") do
|
|
if string.sub(line, 1, 3) == "R5|" then
|
|
local p = splitBar(line)
|
|
local dg = D().DUNGEON[p[3] or ""]
|
|
local list, mt, gk = R.Members(p[9])
|
|
local secs, d = tonumber(p[5]), tonumber(p[6])
|
|
if dg and list and getn(list) <= (dg.max or D().GROUP_MAX) and R.OkName(p[4]) and secs and d and p[2] ~= ""
|
|
and secs >= D().RUN_MIN and secs <= D().RUN_MAX and (p[8] == "Alliance" or p[8] == "Horde") then
|
|
R:Merge(p[2], p[3], gk, { g = p[4], t = secs, d = d, x = tonumber(p[7]) or 0, f = p[8], n = getn(list), m = mt,
|
|
s = okSplits(p[10], dg, secs), nt = tonumber(p[11]) or d, net = true, by = "the WhoDidIt download" })
|
|
-- the download only carries runs whose members were all seen sharing
|
|
local stored = R:DB(p[2])[p[3]]
|
|
stored = stored and stored[gk]
|
|
if stored then
|
|
for i = 1, getn(list) do addOk(stored, list[i].n) end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
W:On("PLAYER_ENTERING_WORLD", function() if WhoDidItDB then R:Seed() end end)
|
|
|
|
-- the master's boards, out to CustomData for the publish and the website export
|
|
function R:WriteFile()
|
|
if not WriteCustomFile or not (W.Board and W.Board.CanMaster and W.Board.CanMaster()) then return end
|
|
local out = { "WDIRUNS|1|" .. time() }
|
|
for rl, r in pairs(WhoDidItDB.dungeons or {}) do
|
|
for key, list in pairs(r) do
|
|
for _, rec in pairs(list) do
|
|
if not rec.priv and R.OkName(rec.g) and D().DUNGEON[key] then
|
|
tinsert(out, table.concat({ "R5", rl, key, rec.g, tostring(rec.t), tostring(rec.d), tostring(rec.x or 0),
|
|
rec.f or "?", rec.m or "", rec.s or "", tostring(rec.nt or rec.d), rec.ok or "" }, "|"))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
pcall(WriteCustomFile, "WhoDidIt_Runs.txt", table.concat(out, "\n") .. "\n", "w")
|
|
end
|
|
W:Every(300, function()
|
|
if R.dirty and WhoDidItDB and not UnitAffectingCombat("player") then
|
|
R.dirty = nil
|
|
R:WriteFile()
|
|
end
|
|
end)
|
|
|
|
------------------------------------------------------------------ /wdi 5man
|
|
|
|
function R:Slash(rest)
|
|
local _, _, sub, arg = string.find(rest or "", "^(%S*)%s*(.-)$")
|
|
sub = strlower(sub or "")
|
|
local o = WhoDidItDB.opts
|
|
if sub == "on" or sub == "off" then
|
|
o.no5man = (sub == "off") or nil
|
|
W.Print("Sharing your 5-man runs (group name, members and classes, time, deaths) with WhoDidIt users on the realm: "
|
|
.. (R.On() and "|cff33ff33on|r" or "|cffff9933off|r - and when you're in the group, nobody's WhoDidIt shares that run"))
|
|
if W.UI then W.UI:Refresh() end
|
|
elseif sub == "name" then
|
|
local _, gk, n = R.Group()
|
|
if not gk or n < 2 then W.Print("Be in a group to name it: /wdi 5man name <group name>") return end
|
|
R:Rename(gk, arg)
|
|
else
|
|
local r = R:Current()
|
|
W.Print("5-man runs: sharing " .. (R.On() and "|cff33ff33on|r" or "|cffff9933off|r")
|
|
.. (r and (" |cff33ccffrun in progress:|r " .. r.zone .. " " .. R.Fmt(time() - r.at)) or ""))
|
|
DEFAULT_CHAT_FRAME:AddMessage(" |cffffd100/wdi 5man on|off|r - share your group's runs |cffffd100/wdi 5man name <name>|r - name your current group")
|
|
if W.UI then W.UI.rk.five = true; W.UI:SetMode("rankings") end
|
|
end
|
|
end
|