Files
bdot1andClaude Opus 5.5 3f20d28044 M1, M2: Learn saves only usable mobs, and Make packs keeps packs you changed
M1: a mob is only saved when its position was read (an old entry without
one is tried again), at most 1500 per zone, and /wdi marks learn clear
forgets a zone's noted mobs (Make packs says so).
M2: each learned pack remembers what it looked like when it was made; one
you changed by hand is kept as your own pack on the next Make packs, its
mobs are left out of the new packs, and new names skip the ones it has.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-07 07:09:17 +01:00

285 lines
11 KiB
Lua

--[[--------------------------------------------------------------------
WhoDidIt - learn packs (Auto Marker)
Builds raid packs from what you see in game, so WhoDidIt has packs of
its own: no data from anyone else.
1. Learn on (Auto Marker tab, or /wdi marks learn on): while you're in
a raid instance, every hostile mob that comes into view is noted
with where it stands (SuperWoW's UnitPosition, read while it's out
of combat, so it's its spawn spot), its name, whether it uses mana,
and its health. Bosses and critters are skipped.
2. Make packs (or /wdi marks build [yards]): mobs standing within 12
yards of each other (chained) become one pack, in the order you met
them. Marks follow WhoDidIt's own priority: mana users (healers,
casters) first, then the toughest; skull, cross, square, moon,
triangle, diamond, circle, star. They're saved as your own packs
("Learned 01 - Molten Giant x2"), replacing earlier learned ones.
Change any mark by hand as usual.
3. Export (/wdi marks export) writes them, with any packs you saved
yourself, to CustomData\WhoDidIt_StdPacks.lua - the maintainer ships
that as DefaultPacks.lua, the packs everyone gets with the download.
Raw sightings are kept in WhoDidItDB.marks.learned, so packs can be
rebuilt with a different gap without walking the raid again.
----------------------------------------------------------------------]]
local W = WhoDidIt
local M = W.Marks
local L = {}
M.Learn = L
local getn, tinsert = table.getn, table.insert
local floor = math.floor
local MARKS = { 8, 7, 6, 5, 4, 3, 2, 1 } -- skull first
local GAP = 12 -- yards between mobs of one pack
local MAX_NOTED = 1500 -- mobs noted per zone, at most
local PREFIX = "Learned "
local function db() return WhoDidItDB and WhoDidItDB.marks end
local function isMob(guid) return type(guid) == "string" and string.sub(guid, 3, 3) == "F" end
local function store(zone)
local d = db()
d.learned = d.learned or {}
d.learned[zone] = d.learned[zone] or {}
return d.learned[zone]
end
function L:On() return db() and db().opts.learn and true or false end
function L:Set(on)
db().opts.learn = on and true or nil
if on then
W.Print("Learning packs: |cff33ff33on|r. Walk through a raid (a normal clear does it) - every mob you see is noted with where it stands. Then click |cffffd100Make packs|r on the Auto Marker tab.")
if not UnitPosition then W.Print("|cffff9933SuperWoW's UnitPosition isn't there, so positions can't be read and packs can't be built.|r") end
else
W.Print("Learning packs: off. What's noted so far is kept.")
end
end
-- how many mobs are noted for a zone (with a position)
function L:Count(zone)
local n, s = 0, db() and db().learned and db().learned[zone]
for _, r in pairs(s or {}) do if r.x then n = n + 1 end end
return n
end
-- forget what was noted in a zone (the packs made from it stay)
function L:Clear(zone)
local d = db()
if d and d.learned then d.learned[zone] = nil end
W.Print("Forgot the mobs noted in " .. zone .. ". Packs you already made are kept.")
end
local seq = 0
local function round(v) return v and floor(v * 10 + 0.5) / 10 end
-- note a mob where it stands (out of combat, so it's where it spawned)
function L:Note(guid)
if not L:On() or not isMob(guid) or not UnitExists(guid) then return end
local inInst, typ = IsInInstance()
if not inInst or typ ~= "raid" then return end
if UnitIsDead(guid) or not UnitCanAttack("player", guid) or UnitAffectingCombat(guid) then return end
local cls = UnitClassification(guid)
if cls == "worldboss" or UnitCreatureType(guid) == "Critter" then return end
local s = store(GetRealZoneText())
if s[guid] then
if s[guid].x then return end
s[guid] = nil -- saved without a position by an older version
end
local x, y, z
if UnitPosition then
local ok, a, b, c = pcall(UnitPosition, guid)
if ok then x, y, z = a, b, c end
-- by GUID didn't answer: the same mob as target / mouseover does
if not x then
for _, unit in ipairs({ "target", "mouseover" }) do
local e, g = UnitExists(unit)
if e and g == guid then
ok, a, b, c = pcall(UnitPosition, unit)
if ok and a then x, y, z = a, b, c; break end
end
end
end
end
-- no position, no use: nothing is saved (it's tried again next time it's seen)
if not x then return end
if L:Count(GetRealZoneText()) >= MAX_NOTED then return end
seq = seq + 1
s[guid] = {
n = UnitName(guid), x = round(x), y = round(y), z = round(z),
m = ((UnitPowerType(guid) == 0) and (UnitManaMax(guid) or 0) > 0) and 1 or nil,
hp = UnitHealthMax(guid), t = time() * 1000 + math.mod(seq, 1000),
}
end
-- what a learned pack looked like when it was made: if it differs now, it was changed by hand
function L.Sig(p)
local l = {}
for g, mark in pairs(p.mobs or {}) do tinsert(l, g .. "=" .. tostring(mark)) end
table.sort(l)
return table.concat(l, ",")
end
-- group the noted mobs of a zone into packs and save them as yours
function L:Build(zone, gap)
zone = zone or GetRealZoneText()
gap = tonumber(gap) or GAP
local s = db() and db().learned and db().learned[zone]
local list = {}
for g, r in pairs(s or {}) do if r.x then tinsert(list, { g = g, r = r }) end end
local n = getn(list)
if n == 0 then
W.Print("No mobs noted in " .. zone .. " yet. Switch Learn on and walk through the raid first.")
return 0
end
-- learned packs you changed by hand are yours now: kept as they are, and
-- their mobs left out of the new packs
local d = db()
d.packs[zone] = d.packs[zone] or {}
local kept, used = {}, {}
for name, p in pairs(d.packs[zone]) do
if p.learned then
if p.sig and p.sig ~= L.Sig(p) then
p.learned, p.sig = nil, nil
kept[name] = true
for g in pairs(p.mobs or {}) do used[g] = true end
else
d.packs[zone][name] = nil
end
end
end
for i = getn(list), 1, -1 do
if used[list[i].g] then tremove(list, i) end
end
n = getn(list)
table.sort(list, function(a, b) return a.r.t < b.r.t end) -- the order you met them
-- chain mobs within "gap" yards of each other into one pack
local g2, pack, packs = gap * gap, {}, {}
for i = 1, n do
if not pack[i] then
local members, queue, qi = { i }, { i }, 1
pack[i] = true
while queue[qi] do
local a = list[queue[qi]].r
qi = qi + 1
for j = 1, n do
if not pack[j] then
local b = list[j].r
local dx, dy, dz = a.x - b.x, a.y - b.y, (a.z or 0) - (b.z or 0)
if dx * dx + dy * dy + dz * dz <= g2 then
pack[j] = true
tinsert(queue, j)
tinsert(members, j)
end
end
end
end
tinsert(packs, members)
end
end
-- the learned packs of this zone were replaced above; everything else of yours stays
local num = 0
for k = 1, getn(packs) do
local mobs = {}
for i = 1, getn(packs[k]) do tinsert(mobs, list[packs[k][i]]) end
-- healers / casters first, then the toughest
table.sort(mobs, function(a, b)
if (a.r.m or 0) ~= (b.r.m or 0) then return (a.r.m or 0) > (b.r.m or 0) end
return (a.r.hp or 0) > (b.r.hp or 0)
end)
-- named after its most common mob
local count, top, topN = {}, nil, 0
for i = 1, getn(mobs) do
local nm = mobs[i].r.n or "?"
count[nm] = (count[nm] or 0) + 1
if count[nm] > topN then top, topN = nm, count[nm] end
end
-- numbered in the order you met them, skipping names a kept pack has
local name
repeat
num = num + 1
name = PREFIX .. string.format("%02d", num) .. " - " .. (top or "?") .. ((getn(mobs) > 1) and (" x" .. getn(mobs)) or "")
until not d.packs[zone][name]
local p = { mobs = {}, names = {}, learned = true }
for i = 1, getn(mobs) do
p.mobs[mobs[i].g] = MARKS[i] or 0
p.names[mobs[i].g] = mobs[i].r.n
end
p.sig = L.Sig(p)
d.packs[zone][name] = p
end
if M.Changed then M:Changed() end
local nk = 0
for _ in pairs(kept) do nk = nk + 1 end
W.Print("Made " .. getn(packs) .. " packs from " .. n .. " mobs in " .. zone .. " (" .. gap .. " yard gap)"
.. ((nk > 0) and (", and kept " .. nk .. " learned pack" .. ((nk == 1) and "" or "s") .. " you changed by hand") or "")
.. ". They're saved as your own packs - change any mark by hand; a changed pack is kept when you make packs again."
.. " Done with this raid? /wdi marks learn clear forgets the noted mobs.")
return getn(packs)
end
-- a Lua string literal
local function q(s) return string.format("%q", s or "") end
-- write your own packs (learned and saved) to CustomData\WhoDidIt_StdPacks.lua,
-- the file the maintainer ships as DefaultPacks.lua
function L:Export()
if not WriteCustomFile then W.Print("Exporting needs Nampower's file access.") return end
local d = db()
local fromAutoMarker = {}
local amd = WDI_MARKDATA and WDI_MARKDATA.packs or {}
for i = 1, getn(amd) do fromAutoMarker[amd[i][1] .. "|" .. amd[i][2]] = true end
local out = {
"-- WhoDidIt's standard raid packs: learned and saved in game by the WhoDidIt maintainer",
"-- (/wdi marks learn, build, export). Generated - do not edit; your own packs are saved in game.",
"WDI_STDPACKS = { date = " .. q(date("%Y-%m-%d")) .. ", packs = {",
}
local packs, mobs, skipped = 0, 0, 0
local zones = {}
for zone in pairs(d.packs) do tinsert(zones, zone) end
table.sort(zones)
for z = 1, getn(zones) do
local zone = zones[z]
local names = {}
for name in pairs(d.packs[zone]) do tinsert(names, name) end
table.sort(names)
for i = 1, getn(names) do
local name, p = names[i], d.packs[zone][names[i]]
-- an edited copy of an AutoMarker pack is theirs, not ours to ship
if fromAutoMarker[zone .. "|" .. name] then
skipped = skipped + 1
elseif p.mobs and next(p.mobs) then
local flat = {}
for g, mark in pairs(p.mobs) do
tinsert(flat, q(g) .. ", " .. (tonumber(mark) or 0) .. ", " .. q(p.names and p.names[g] or ""))
mobs = mobs + 1
end
tinsert(out, "\t{ " .. q(zone) .. ", " .. q(name) .. ", { " .. table.concat(flat, ", ") .. " } },")
packs = packs + 1
end
end
end
tinsert(out, "} }")
local ok, err = pcall(WriteCustomFile, "WhoDidIt_StdPacks.lua", table.concat(out, "\n") .. "\n", "w")
if not ok then W.Print("Couldn't write the file: " .. tostring(err)) return end
W.Print("Exported " .. packs .. " packs (" .. mobs .. " mobs) to CustomData\\WhoDidIt_StdPacks.lua"
.. ((skipped > 0) and (" - left out " .. skipped .. " edited AutoMarker pack" .. ((skipped == 1) and "" or "s")) or "") .. ".")
end
-- see mobs as they come into view, under the mouse, or targeted
local npMajor, npMinor = 0, 0
if GetNampowerVersion then npMajor, npMinor = GetNampowerVersion() end
if (npMajor or 0) > 2 or ((npMajor or 0) == 2 and (npMinor or 0) >= 39) then
W:On("UNIT_MODEL_CHANGED_GUID", function(guid) L:Note(guid) end)
else
W:On("UNIT_MODEL_CHANGED", function(guid) L:Note(guid) end)
end
local function noteUnit(unit)
local ok, g = UnitExists(unit)
if ok and type(g) == "string" then L:Note(g) end
end
W:On("UPDATE_MOUSEOVER_UNIT", function() noteUnit("mouseover") end)
W:On("PLAYER_TARGET_CHANGED", function() noteUnit("target") end)