582 lines
22 KiB
Lua
582 lines
22 KiB
Lua
-- Freewood-OctoWoW-Codex: Verfuegbarkeit von Quests (noch nicht annehmbar) und Voraussetzungen lernen
|
|
--
|
|
-- Der Server verraet nicht, welche Quests man jetzt annehmen koennte oder welche Vorquest fehlt. Das Spiel liefert nur:
|
|
-- * die Angebotsliste eines NPCs oder Objekts, waehrend man mit ihm spricht (GOSSIP_SHOW, QUEST_GREETING, QUEST_DETAIL)
|
|
-- * welche Quests der Charakter erledigt hat (IsQuestFlaggedCompleted / GetAllCompletedQuestIDs)
|
|
-- Daraus entsteht ein Vergleich zweier Zeitpunkte:
|
|
-- Negativ-Beobachtung: Eine Quest sollte hier angeboten werden, wird es aber nicht (oder der Spieler markiert sie als "noch nicht
|
|
-- moeglich"). Gemerkt werden Stufe und die Menge der erledigten Quests.
|
|
-- Positiv-Beobachtung: Spaeter wird sie angeboten oder angenommen. Die Vorquest muss unter den seither erledigten Quests liegen,
|
|
-- und hat sich nur die Stufe geaendert, ist das die Mindeststufe.
|
|
-- Die Markierung "noch nicht moeglich" gilt je Charakter (db.avail[Charakter]). Die gelernten Angaben stehen in den Quest-Daten
|
|
-- und werden geteilt: pi (Kandidat -> Anzahl), po (Beobachtungen), mi (Stufenbereich lo/hi/n). Als Vorquest gilt ein Kandidat, der in
|
|
-- allen Beobachtungen vorkam: fuer den eigenen Charakter sofort, fuer andere erst ab zwei Beobachtungen.
|
|
|
|
local ADDON, NS = ...
|
|
|
|
local FW = _G.Freewood
|
|
local Codex = NS and NS.Codex
|
|
if not FW or not Codex then
|
|
return
|
|
end
|
|
|
|
local Avail = { probe = nil }
|
|
Codex.Avail = Avail
|
|
NS.Avail = Avail
|
|
|
|
local MAX_DELTA = 6 -- mehr neu erledigte Quests sind keine brauchbare Beobachtung
|
|
local MAX_PI = 8
|
|
local NEG_KEEP = 60 * 24 * 3600
|
|
local function Now() return _G.time and _G.time() or 0 end
|
|
|
|
local function SelfKey()
|
|
return Codex.Trust and Codex.Trust.SelfKey and Codex.Trust.SelfKey() or nil
|
|
end
|
|
|
|
local function Char(create)
|
|
local db = Codex.db
|
|
if not db then return nil end
|
|
local key = SelfKey()
|
|
if not key then return nil end
|
|
db.avail = db.avail or {}
|
|
local c = db.avail[key]
|
|
if not c and create then
|
|
c = { blocked = {}, neg = {} }
|
|
db.avail[key] = c
|
|
end
|
|
return c
|
|
end
|
|
|
|
local function PlayerLevel()
|
|
local lv = _G.UnitLevel and _G.UnitLevel("player")
|
|
return tonumber(lv) or 1
|
|
end
|
|
|
|
------------------------------------------------------------------------
|
|
-- Erledigte Quests
|
|
------------------------------------------------------------------------
|
|
|
|
-- Menge der erledigten Quest-IDs des Charakters; Ersatz: bekannte IDs einzeln abfragen
|
|
function Avail.Completed()
|
|
local set = {}
|
|
local QL = _G.C_QuestLog
|
|
if QL and QL.GetAllCompletedQuestIDs then
|
|
local ok, list = pcall(QL.GetAllCompletedQuestIDs)
|
|
if ok and type(list) == "table" then
|
|
for _, id in pairs(list) do set[id] = true end
|
|
if next(set) ~= nil then return set, true end
|
|
end
|
|
end
|
|
for id in pairs(Codex.V().quests) do
|
|
if Codex.QuestStatus(id) == "done" then set[id] = true end
|
|
end
|
|
local c = Char(false)
|
|
for id in pairs(c and c.neg or {}) do
|
|
if Codex.QuestStatus(id) == "done" then set[id] = true end
|
|
end
|
|
return set, false
|
|
end
|
|
|
|
local function ToList(set)
|
|
local out = {}
|
|
for id in pairs(set) do out[#out + 1] = id end
|
|
table.sort(out)
|
|
return out
|
|
end
|
|
|
|
------------------------------------------------------------------------
|
|
-- Markieren
|
|
------------------------------------------------------------------------
|
|
|
|
-- Eine Quest als "noch nicht annehmbar" merken (src: "manual" oder "scan"). Rueckgabe: true, wenn neu
|
|
function Avail.Block(id, src)
|
|
id = tonumber(id)
|
|
local c = Char(true)
|
|
if not id or not c then return false end
|
|
if Codex.QuestStatus(id) ~= nil then return false end
|
|
local fresh = c.blocked[id] == nil
|
|
local lv = PlayerLevel()
|
|
local done = Avail.Completed()
|
|
c.blocked[id] = { lv = lv, t = Now(), n = #ToList(done), src = src or "manual" }
|
|
-- Schnappschuss fuer die spaetere Auswertung; die juengste Negativ-Beobachtung gilt (sie grenzt am engsten ein)
|
|
c.neg[id] = { lv = lv, t = Now(), done = ToList(done) }
|
|
FW:Fire("CODEX_AVAIL_CHANGED", id)
|
|
return fresh
|
|
end
|
|
|
|
function Avail.Unblock(id)
|
|
local c = Char(false)
|
|
if c and c.blocked[id] then
|
|
c.blocked[id] = nil
|
|
FW:Fire("CODEX_AVAIL_CHANGED", id)
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
function Avail.IsBlocked(id)
|
|
local c = Char(false)
|
|
return c ~= nil and c.blocked[id] ~= nil
|
|
end
|
|
|
|
function Avail.BlockedCount()
|
|
local c = Char(false)
|
|
local n = 0
|
|
for _ in pairs(c and c.blocked or {}) do n = n + 1 end
|
|
return n
|
|
end
|
|
|
|
-- Liste { id, lv, t, src, title }, sortiert nach Titel
|
|
function Avail.List()
|
|
local out = {}
|
|
local c = Char(false)
|
|
local V = Codex.V()
|
|
for id, b in pairs(c and c.blocked or {}) do
|
|
out[#out + 1] = { id = id, lv = b.lv, t = b.t, src = b.src, title = Codex.QuestTitle(V.quests[id], id) }
|
|
end
|
|
table.sort(out, function(a, b)
|
|
if a.title ~= b.title then return a.title < b.title end
|
|
return a.id < b.id
|
|
end)
|
|
return out
|
|
end
|
|
|
|
function Avail.Count()
|
|
local c = Char(false)
|
|
local n = 0
|
|
for _ in pairs(c and c.blocked or {}) do n = n + 1 end
|
|
return n
|
|
end
|
|
|
|
function Avail.ClearAll()
|
|
local c = Char(false)
|
|
if c then c.blocked = {} FW:Fire("CODEX_AVAIL_CHANGED") end
|
|
end
|
|
|
|
-- Aenderung am Charakter (Stufe, abgegebene Quest): markierte Quests koennten jetzt frei sein und kommen zurueck
|
|
function Avail.Release()
|
|
local c = Char(false)
|
|
if not c or next(c.blocked) == nil then return 0 end
|
|
local lv = PlayerLevel()
|
|
local count = #ToList(Avail.Completed())
|
|
local freed = 0
|
|
for id, b in pairs(c.blocked) do
|
|
if lv > (b.lv or 0) or count > (b.n or 0) or Codex.QuestStatus(id) ~= nil then
|
|
c.blocked[id] = nil
|
|
freed = freed + 1
|
|
end
|
|
end
|
|
if freed > 0 then FW:Fire("CODEX_AVAIL_CHANGED") end
|
|
return freed
|
|
end
|
|
|
|
------------------------------------------------------------------------
|
|
-- Auswerten (Positiv-Beobachtung)
|
|
------------------------------------------------------------------------
|
|
|
|
local function Bracket(q, lo, hi)
|
|
local mi = q.mi
|
|
if type(mi) == "table" and mi.lo and mi.hi then
|
|
local nlo, nhi = math.max(mi.lo, lo), math.min(mi.hi, hi)
|
|
if nhi > nlo then
|
|
q.mi = { lo = nlo, hi = nhi, n = (mi.n or 1) + 1 }
|
|
return
|
|
end
|
|
end
|
|
q.mi = { lo = lo, hi = hi, n = 1 }
|
|
end
|
|
|
|
-- Die Quest ist jetzt verfuegbar (angeboten oder angenommen): Unterschied zum Zeitpunkt der Negativ-Beobachtung auswerten
|
|
function Avail.Observed(id)
|
|
local c = Char(false)
|
|
local neg = c and c.neg[id]
|
|
if not neg then return false end
|
|
c.neg[id] = nil
|
|
local V = Codex.V()
|
|
local q = Codex.db.quests[id]
|
|
if not q then
|
|
local title = V.quests[id] and V.quests[id].t
|
|
if not title then return false end -- ohne bekannten Titel laesst sich der Datensatz nicht teilen
|
|
q = Codex:Quest(id, true)
|
|
q.t = title
|
|
end
|
|
local now = Avail.Completed()
|
|
local before = {}
|
|
for _, p in ipairs(neg.done or {}) do before[p] = true end
|
|
local delta = {}
|
|
for p in pairs(now) do
|
|
if not before[p] and p ~= id then delta[#delta + 1] = p end
|
|
end
|
|
table.sort(delta)
|
|
local lv = PlayerLevel()
|
|
local changed = false
|
|
if #delta == 0 then
|
|
if lv > (neg.lv or lv) then
|
|
Bracket(q, neg.lv, lv)
|
|
changed = true
|
|
end
|
|
elseif #delta <= MAX_DELTA then
|
|
q.pi = q.pi or {}
|
|
q.po = (q.po or 0) + 1
|
|
local n = 0
|
|
for _ in pairs(q.pi) do n = n + 1 end
|
|
for _, p in ipairs(delta) do
|
|
if q.pi[p] or n < MAX_PI then
|
|
if not q.pi[p] then n = n + 1 end
|
|
q.pi[p] = (q.pi[p] or 0) + 1
|
|
end
|
|
end
|
|
changed = true
|
|
end
|
|
if changed then
|
|
Codex.chainRev = (Codex.chainRev or 0) + 1
|
|
FW:Fire("CODEX_CHANGED", "quest", id)
|
|
end
|
|
Avail.Unblock(id)
|
|
return changed
|
|
end
|
|
|
|
-- Vorquests, die sich aus den Beobachtungen ergeben: Kandidaten, die in allen Beobachtungen vorkamen.
|
|
-- Fuer die eigene Beobachtung gilt schon eine, sonst braucht es zwei (own = true, wenn der Datensatz eigene Beobachtungen traegt)
|
|
function Avail.InferredPre(q, own)
|
|
local out = {}
|
|
if type(q) ~= "table" or type(q.pi) ~= "table" then return out end
|
|
local po = q.po or 0
|
|
if po < (own and 1 or 2) then return out end
|
|
for p, n in pairs(q.pi) do
|
|
if n >= po then out[#out + 1] = p end
|
|
end
|
|
table.sort(out)
|
|
return out
|
|
end
|
|
|
|
-- Mindeststufe aus den Beobachtungen: nur wenn der Bereich genau eine Stufe breit ist (und zwei Beobachtungen oder eigene)
|
|
function Avail.InferredMin(q, own)
|
|
local mi = type(q) == "table" and q.mi or nil
|
|
if type(mi) ~= "table" or not mi.lo or not mi.hi then return nil end
|
|
if mi.hi - mi.lo ~= 1 then return nil end
|
|
if (mi.n or 1) < (own and 1 or 2) then return nil end
|
|
return mi.hi
|
|
end
|
|
|
|
------------------------------------------------------------------------
|
|
-- Scan beim Geber
|
|
------------------------------------------------------------------------
|
|
|
|
-- Angebotene Quests des gerade angesprochenen NPCs oder Objekts: Menge von IDs und Menge von Titeln
|
|
local function ReadOffers()
|
|
local ids, titles = {}, {}
|
|
local any = false
|
|
local G = _G.C_GossipInfo
|
|
if G and G.GetAvailableQuests then
|
|
local ok, list = pcall(G.GetAvailableQuests)
|
|
if ok and type(list) == "table" then
|
|
any = true
|
|
for _, e in ipairs(list) do
|
|
if type(e) == "table" then
|
|
if type(e.questID) == "number" then ids[e.questID] = true end
|
|
if type(e.title) == "string" then titles[e.title] = true end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- Quest-Begruessung (alte Form): nur Titel
|
|
if _G.GetNumAvailableQuests and _G.GetAvailableTitle then
|
|
local ok, n = pcall(_G.GetNumAvailableQuests)
|
|
if ok and type(n) == "number" and n > 0 then
|
|
any = true
|
|
for i = 1, n do
|
|
local ok2, t = pcall(_G.GetAvailableTitle, i)
|
|
if ok2 and type(t) == "string" then titles[t] = true end
|
|
end
|
|
end
|
|
end
|
|
return ids, titles, any
|
|
end
|
|
Avail.ReadOffers = ReadOffers
|
|
|
|
-- Wer wird gerade angesprochen: kind ("npc"/"object"), id oder nil
|
|
local function Interaction()
|
|
local guid = _G.UnitGUID and _G.UnitGUID("npc")
|
|
if guid == nil then return nil end
|
|
local ok, kind, id = pcall(Codex.ParseGUID, guid)
|
|
if ok and kind then return kind, id end
|
|
return nil
|
|
end
|
|
|
|
local function Probe(text)
|
|
if Avail.probe and Now() < Avail.probe then FW:Print("Probe: " .. text) end
|
|
end
|
|
|
|
-- Angebotsliste ausgewertet: ids/titles = was angeboten wird
|
|
function Avail.ScanOffers(kind, npcID, ids, titles)
|
|
local V = Codex.V()
|
|
local scanned, blocked, seen = 0, 0, 0
|
|
-- Positiv: angebotene Quests mit Negativ-Beobachtung
|
|
for id in pairs(ids) do
|
|
seen = seen + 1
|
|
Avail.Observed(id)
|
|
Avail.Unblock(id)
|
|
end
|
|
-- Negativ: Quests dieses Gebers, die nach den Daten annehmbar waeren, aber nicht angeboten werden
|
|
if kind and npcID then
|
|
for id, q in pairs(V.quests) do
|
|
local g = q.give
|
|
if type(g) == "table" and g.id == npcID and g.k == kind then
|
|
scanned = scanned + 1
|
|
local title = Codex.QuestTitle(q, id)
|
|
if not ids[id] and not titles[title] and Codex.QuestStatus(id) == nil
|
|
and not Avail.IsBlocked(id) and Codex.QuestAvailable(id) then
|
|
if Avail.Block(id, "scan") then blocked = blocked + 1 end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return seen, scanned, blocked
|
|
end
|
|
|
|
function Avail:OnGossip()
|
|
local ok, err = pcall(function()
|
|
local kind, id = Interaction()
|
|
local ids, titles, any = ReadOffers()
|
|
if not any then
|
|
Probe("Gossip: keine Angebotsliste lesbar")
|
|
return
|
|
end
|
|
local n = 0
|
|
for _ in pairs(ids) do n = n + 1 end
|
|
local t = 0
|
|
for _ in pairs(titles) do t = t + 1 end
|
|
local seen, scanned, blocked = Avail.ScanOffers(kind, id, ids, titles)
|
|
Probe(string.format("Gossip: %s %s, angeboten %d (IDs) / %d (Titel), Quests dieses Gebers in den Daten %d, neu als 'noch nicht moeglich' %d",
|
|
tostring(kind), tostring(id), n, t, scanned, blocked))
|
|
end)
|
|
if not ok then Probe("Fehler: " .. tostring(err)) end
|
|
end
|
|
|
|
function Avail:OnQuestDetail()
|
|
pcall(function()
|
|
local id = tonumber(_G.GetQuestID and _G.GetQuestID())
|
|
if id then
|
|
Avail.Observed(id)
|
|
Avail.Unblock(id)
|
|
Probe("Quest-Angebot " .. id)
|
|
end
|
|
end)
|
|
end
|
|
|
|
function Avail:OnQuestAccepted(a, b)
|
|
pcall(function()
|
|
local id = tonumber(b) or tonumber(a)
|
|
if id then
|
|
Avail.Observed(id)
|
|
Avail.Unblock(id)
|
|
end
|
|
end)
|
|
end
|
|
|
|
function Avail:OnChange()
|
|
pcall(Avail.Release)
|
|
end
|
|
|
|
function Avail.Prune()
|
|
local c = Char(false)
|
|
if not c then return end
|
|
local now = Now()
|
|
for id, neg in pairs(c.neg) do
|
|
if now - (neg.t or 0) > NEG_KEEP then c.neg[id] = nil end
|
|
end
|
|
end
|
|
|
|
function Avail:Start()
|
|
FW:RegisterEvent("GOSSIP_SHOW", self.OnGossip, self)
|
|
FW:RegisterEvent("QUEST_GREETING", self.OnGossip, self)
|
|
FW:RegisterEvent("QUEST_DETAIL", self.OnQuestDetail, self)
|
|
FW:RegisterEvent("QUEST_ACCEPTED", self.OnQuestAccepted, self)
|
|
FW:RegisterEvent("PLAYER_LEVEL_UP", self.OnChange, self)
|
|
FW:RegisterEvent("QUEST_TURNED_IN", self.OnChange, self)
|
|
C_Timer.After(6, function() Avail.Prune() Avail.Release() end)
|
|
-- Antworten auf RequestLoadQuestByID zaehlen (nur fuer den Titel-Test; Ereignis kann fehlen)
|
|
pcall(FW.RegisterEvent, FW, "QUEST_DATA_LOAD_RESULT", function() Avail.loadEvents = (Avail.loadEvents or 0) + 1 end, Avail)
|
|
end
|
|
|
|
------------------------------------------------------------------------
|
|
-- Test-Befehl: /fwquestprobe [QuestID] zeigt, was Forever liefert
|
|
------------------------------------------------------------------------
|
|
|
|
function Avail.RunProbe(id)
|
|
local function Say(t) FW:Print("Probe: " .. t) end
|
|
id = tonumber(id) or 96652
|
|
local G, QL = _G.C_GossipInfo, _G.C_QuestLog
|
|
Say("C_GossipInfo.GetAvailableQuests: " .. tostring(G and G.GetAvailableQuests ~= nil))
|
|
Say("GetNumAvailableQuests / GetAvailableTitle (Begruessung): " .. tostring(_G.GetNumAvailableQuests ~= nil) .. " / " .. tostring(_G.GetAvailableTitle ~= nil))
|
|
Say("C_QuestLog.GetAllCompletedQuestIDs: " .. tostring(QL and QL.GetAllCompletedQuestIDs ~= nil))
|
|
if QL and QL.GetAllCompletedQuestIDs then
|
|
local ok, list = pcall(QL.GetAllCompletedQuestIDs)
|
|
Say(" erledigte Quests laut Spiel: " .. (ok and type(list) == "table" and #list or ("Fehler " .. tostring(list))))
|
|
end
|
|
Say("C_QuestLog.RequestLoadQuestByID: " .. tostring(QL and QL.RequestLoadQuestByID ~= nil) .. ", GetTitleForQuestID: " .. tostring(QL and QL.GetTitleForQuestID ~= nil))
|
|
if QL and QL.GetTitleForQuestID then
|
|
local ok, t = pcall(QL.GetTitleForQuestID, id)
|
|
Say(" Titel zu " .. id .. " sofort: " .. tostring(ok and t))
|
|
end
|
|
if QL and QL.RequestLoadQuestByID then
|
|
local ok, err = pcall(QL.RequestLoadQuestByID, id)
|
|
Say(" RequestLoadQuestByID(" .. id .. "): " .. (ok and "aufgerufen" or tostring(err)))
|
|
C_Timer.After(2, function()
|
|
local ok2, t2 = pcall(QL.GetTitleForQuestID, id)
|
|
Say(" Titel zu " .. id .. " nach 2 s: " .. tostring(ok2 and t2))
|
|
end)
|
|
end
|
|
-- Was verraet das Spiel ueber eine geladene Quest-ID ausser dem Titel? Bekannte Abfragen einzeln versuchen.
|
|
C_Timer.After(3, function()
|
|
local found = 0
|
|
local calls = {
|
|
{ "C_QuestLog", "GetQuestDifficultyLevel" }, { "C_QuestLog", "GetQuestTagInfo" }, { "C_QuestLog", "GetQuestType" },
|
|
{ "C_QuestLog", "GetSuggestedGroupSize" }, { "C_QuestLog", "IsQuestFlaggedCompleted" }, { "C_QuestLog", "GetQuestObjectives" },
|
|
{ "C_QuestLog", "GetLogIndexForQuestID" }, { "C_QuestLog", "IsOnQuest" }, { "C_QuestLog", "IsQuestReplayable" },
|
|
{ "C_QuestLog", "GetQuestInfo" }, { "C_QuestLog", "GetZoneStoryInfo" }, { "C_QuestLog", "GetQuestLogRewardMoney" },
|
|
{ "C_QuestLog", "GetRequiredMoney" }, { "C_QuestLog", "IsFailed" }, { "C_QuestLog", "ReadyForTurnIn" },
|
|
{ "C_QuestLog", "GetQuestDetailsTheme" }, { "C_QuestLog", "IsQuestCalling" }, { "C_QuestLog", "IsQuestTrivial" },
|
|
{ "C_QuestLog", "GetQuestLevel" }, { "C_QuestLog", "GetMinLevel" }, { "C_QuestLog", "GetMaxLevel" },
|
|
}
|
|
for _, c in ipairs(calls) do
|
|
local tbl = _G[c[1]]
|
|
local fn = tbl and tbl[c[2]]
|
|
if type(fn) == "function" then
|
|
local ok, a, b = pcall(fn, id)
|
|
local function Str(v)
|
|
if type(v) == "table" then
|
|
local parts, n = {}, 0
|
|
for k, x in pairs(v) do
|
|
n = n + 1
|
|
if n > 6 then parts[#parts + 1] = "..." break end
|
|
parts[#parts + 1] = tostring(k) .. "=" .. tostring(x)
|
|
end
|
|
return "{" .. table.concat(parts, ", ") .. "}"
|
|
end
|
|
return tostring(v)
|
|
end
|
|
if ok and a ~= nil then
|
|
found = found + 1
|
|
Say(" " .. c[2] .. "(" .. id .. ") = " .. Str(a) .. (b ~= nil and (", " .. Str(b)) or ""))
|
|
elseif not ok then
|
|
Say(" " .. c[2] .. " Fehler: " .. tostring(a))
|
|
end
|
|
end
|
|
end
|
|
Say(" weitere Angaben zur Quest " .. id .. ": " .. found .. " Abfragen mit Ergebnis")
|
|
end)
|
|
Avail.probe = Now() + 300
|
|
Say("Die naechsten 5 Minuten wird bei jedem Gespraech mit einem NPC oder Objekt die Angebotsliste gemeldet.")
|
|
local kind, nid = Interaction()
|
|
if kind then Avail:OnGossip() end
|
|
end
|
|
|
|
------------------------------------------------------------------------
|
|
-- Titel-Test: /fwquesttitles [von] [bis] fragt Quest-Titel beim Server ab (gedrosselt, nur Anzeige, nichts wird gespeichert)
|
|
------------------------------------------------------------------------
|
|
|
|
local SCAN_MAX = 500 -- IDs je Lauf
|
|
local SCAN_BATCH = 20 -- Anfragen je Schub
|
|
local SCAN_PAUSE = 0.5 -- Sekunden zwischen den Schueben
|
|
|
|
-- Rueckgabe: Liste { id, title } der gefundenen Titel (nach dem Lauf an callback(list, requested, events))
|
|
function Avail.TitleScan(lo, hi, callback)
|
|
local QL = _G.C_QuestLog
|
|
if not (QL and QL.RequestLoadQuestByID and QL.GetTitleForQuestID) then return false, "api" end
|
|
lo, hi = tonumber(lo), tonumber(hi)
|
|
if not (lo and hi) or lo < 1 then return false, "range" end
|
|
if hi < lo then lo, hi = hi, lo end
|
|
if hi - lo + 1 > SCAN_MAX then hi = lo + SCAN_MAX - 1 end
|
|
if Avail.scanning then return false, "busy" end
|
|
Avail.scanning = true
|
|
local events0 = Avail.loadEvents or 0
|
|
local before = {}
|
|
for id = lo, hi do
|
|
local ok, t = pcall(QL.GetTitleForQuestID, id)
|
|
if ok and type(t) == "string" and t ~= "" then before[id] = true end
|
|
end
|
|
local nextID, requested = lo, 0
|
|
local function Step()
|
|
local stop = math.min(nextID + SCAN_BATCH - 1, hi)
|
|
for id = nextID, stop do
|
|
if pcall(QL.RequestLoadQuestByID, id) then requested = requested + 1 end
|
|
end
|
|
nextID = stop + 1
|
|
if nextID <= hi then
|
|
C_Timer.After(SCAN_PAUSE, Step)
|
|
else
|
|
C_Timer.After(3, function()
|
|
local list = {}
|
|
for id = lo, hi do
|
|
local ok, t = pcall(QL.GetTitleForQuestID, id)
|
|
if ok and type(t) == "string" and t ~= "" then list[#list + 1] = { id = id, title = t, cached = before[id] or nil } end
|
|
end
|
|
Avail.scanning = false
|
|
Avail.lastScan = { lo = lo, hi = hi, list = list }
|
|
if callback then callback(list, requested, (Avail.loadEvents or 0) - events0, lo, hi) end
|
|
end)
|
|
end
|
|
end
|
|
Step()
|
|
return true, lo, hi
|
|
end
|
|
|
|
SLASH_FREEWOODQUESTTITLES1 = "/fwquesttitles"
|
|
SlashCmdList["FREEWOODQUESTTITLES"] = function(msg)
|
|
local a, b = (msg or ""):match("(%d+)%D+(%d+)")
|
|
a, b = tonumber(a), tonumber(b)
|
|
if not a then
|
|
a = tonumber((msg or ""):match("%d+")) or 96600
|
|
b = a + 99
|
|
end
|
|
local ok, lo, hi = Avail.TitleScan(a, b, function(list, requested, events, l, h)
|
|
local V = Codex.V()
|
|
local known, new = 0, 0
|
|
for _, e in ipairs(list) do
|
|
if V.quests[e.id] then known = known + 1 else new = new + 1 end
|
|
end
|
|
FW:Print(string.format("Titel-Test %d-%d: %d Anfragen, %d Antworten (Ereignis %d), davon %d dem Codex schon bekannt, %d neu",
|
|
l, h, requested, #list, events, known, new))
|
|
for i = 1, math.min(#list, 12) do
|
|
local e = list[i]
|
|
FW:Print(string.format(" #%d %s%s", e.id, e.title, V.quests[e.id] and "" or " (neu)"))
|
|
end
|
|
if #list > 12 then FW:Print(" ... und " .. (#list - 12) .. " weitere") end
|
|
end)
|
|
if not ok then
|
|
FW:Print("Titel-Test nicht moeglich: " .. tostring(lo))
|
|
else
|
|
FW:Print(string.format("Titel-Test %d-%d laeuft (gedrosselt, dauert etwa %d s) ...", lo, hi, math.ceil((hi - lo + 1) / SCAN_BATCH * SCAN_PAUSE) + 3))
|
|
end
|
|
end
|
|
|
|
SLASH_FREEWOODQUESTPROBE1 = "/fwquestprobe"
|
|
SlashCmdList["FREEWOODQUESTPROBE"] = function(msg)
|
|
Avail.RunProbe((msg or ""):match("%d+"))
|
|
end
|
|
|
|
-- Markierungen verwalten: /fwblock (Liste), /fwblock <ID> (aufheben), /fwblock alle (alle aufheben)
|
|
SLASH_FREEWOODBLOCK1 = "/fwblock"
|
|
SlashCmdList["FREEWOODBLOCK"] = function(msg)
|
|
msg = (msg or ""):lower():gsub("^%s+", ""):gsub("%s+$", "")
|
|
local L = FW.L
|
|
if msg == "alle" or msg == "all" then
|
|
Avail.ClearAll()
|
|
FW:Print(L.CODEX_AVAIL_CLEARED)
|
|
return
|
|
end
|
|
local id = tonumber(msg:match("%d+"))
|
|
if id then
|
|
Avail.Unblock(id)
|
|
FW:Print(string.format(L.CODEX_AVAIL_UNBLOCKED, id))
|
|
return
|
|
end
|
|
local list = Avail.List()
|
|
FW:Print(string.format(L.CODEX_AVAIL_LIST, #list))
|
|
for _, e in ipairs(list) do
|
|
FW:Print(string.format(" %s (#%d, Stufe %s)", e.title, e.id, tostring(e.lv)))
|
|
end
|
|
end
|