765 lines
25 KiB
Lua
765 lines
25 KiB
Lua
-- Freewood-OctoWoW-Codex: Fundorte auf der Weltkarte
|
|
-- Zeichnet Punkte mit weissem Rand ueber Blizzards Kartenflaeche: schwarz fuer Kreaturen,
|
|
-- rot fuer Objekte, blau fuer Quest-Geber und -Abgabe. Fundorte werden gebuendelt (BIN Zellen je Punkt).
|
|
-- Quelle sind die Zellen, die Codex beim Spielen erfasst hat (Raster 200 x 200 je Karte).
|
|
|
|
local ADDON, NS = ...
|
|
|
|
local FW = _G.Freewood
|
|
local Codex = NS.Codex
|
|
if not FW or not Codex then
|
|
return
|
|
end
|
|
|
|
local UI = FW.UI
|
|
local GRID = Codex.GRID
|
|
local MAX_DOTS = 600
|
|
local BIN = 3 -- Zellen je Punkt (3 Zellen = 1,5 % der Kartenbreite)
|
|
local DOT_MIN = 9 -- Punktgroesse in Bildschirm-Pixeln (kleinster / groesster Punkt)
|
|
local DOT_MAX = 14
|
|
local RIM = 1.5 -- weisser Rand in Pixeln
|
|
local LAYER_LEVEL = 1500 -- weit ueber Blizzards Kartensymbolen, damit nichts die Punkte verdeckt
|
|
|
|
local COLORS = {
|
|
u = { 0, 0, 0 },
|
|
o = { 0.9, 0.1, 0.1 },
|
|
p = { 0.2, 0.55, 1 },
|
|
}
|
|
local ORDER = { u = 1, o = 2, p = 3 }
|
|
local MASK = "Interface\\CharacterFrame\\TempPortraitAlphaMask"
|
|
|
|
local Overlay = { points = nil, label = nil, hooked = false }
|
|
Codex.Map = Overlay
|
|
|
|
local layer, dots, infoButton, StartHover
|
|
local segDash = {} -- [Abschnitt] = { sig, tex = {...}, n }: Striche je Abschnitt, damit nur der veraenderte neu gesetzt wird
|
|
local DASH_LEN, DASH_GAP, DASH_THICK = 8, 6, 3 -- Pixel
|
|
local MAX_DASHES = 900
|
|
local atan2 = math.atan2 or function(y, x) return math.atan(y, x) end
|
|
|
|
-- Runder Punkt: weisse Scheibe mit schwarzer/roter/blauer Scheibe darauf. Rund wird er durch eine
|
|
-- Maske aus dem Spiel; fehlt sie, bleiben es Quadrate.
|
|
local function MaskAvailable()
|
|
if Codex.db and Codex.db.settings.squareDots then
|
|
return false
|
|
end
|
|
if type(GetFileIDFromPath) == "function" then
|
|
return GetFileIDFromPath(MASK) ~= nil
|
|
end
|
|
return true
|
|
end
|
|
|
|
local function NewDot(f)
|
|
local dot = {}
|
|
local useMask = MaskAvailable()
|
|
for _, name in ipairs({ "rim", "fill" }) do
|
|
local tex = f:CreateTexture(nil, name == "rim" and "ARTWORK" or "OVERLAY", nil, name == "rim" and 1 or 2)
|
|
tex:SetColorTexture(1, 1, 1, 1)
|
|
if useMask and f.CreateMaskTexture and tex.AddMaskTexture then
|
|
local ok, mask = pcall(f.CreateMaskTexture, f)
|
|
if ok and mask then
|
|
mask:SetTexture(MASK, "CLAMPTOBLACKADDITIVE", "CLAMPTOBLACKADDITIVE")
|
|
mask:SetAllPoints(tex)
|
|
tex:AddMaskTexture(mask)
|
|
tex.mask = mask
|
|
end
|
|
end
|
|
dot[name] = tex
|
|
end
|
|
return dot
|
|
end
|
|
|
|
local function HideDot(dot)
|
|
dot.rim:Hide()
|
|
dot.fill:Hide()
|
|
end
|
|
|
|
local API = Codex.MapAPI
|
|
|
|
local function Canvas()
|
|
return API.Canvas()
|
|
end
|
|
|
|
local function EnsureLayer()
|
|
if layer then
|
|
return layer
|
|
end
|
|
local canvas = Canvas()
|
|
if not canvas then
|
|
return nil
|
|
end
|
|
-- Die Ebene haengt am Kartenfenster selbst (nicht an der Kartenflaeche): dort ist sie sicher sichtbar.
|
|
-- Die Punkte werden an die Kartenflaeche geheftet und folgen ihr beim Verschieben und Zoomen.
|
|
local wm = _G.WorldMapFrame
|
|
if API.Classic() then
|
|
-- 1.12-Karte: Ebene direkt auf der Kartenflaeche, Anteile 0..1 gelten fuer die ganze Flaeche
|
|
layer = CreateFrame("Frame", nil, canvas)
|
|
layer:SetAllPoints(canvas)
|
|
layer:SetFrameLevel((canvas:GetFrameLevel() or 1) + 20)
|
|
if wm.GetFrameStrata then layer:SetFrameStrata(wm:GetFrameStrata()) end
|
|
else
|
|
layer = CreateFrame("Frame", nil, wm)
|
|
layer:SetAllPoints(wm.ScrollContainer or wm)
|
|
layer:SetFrameLevel((wm:GetFrameLevel() or 1) + LAYER_LEVEL)
|
|
if wm.GetFrameStrata then
|
|
layer:SetFrameStrata(wm:GetFrameStrata())
|
|
end
|
|
end
|
|
if layer.SetClipsChildren then
|
|
layer:SetClipsChildren(true)
|
|
end
|
|
layer:SetScript("OnSizeChanged", function(_, w)
|
|
if w and w > 1 and Overlay.points then
|
|
Overlay:Refresh()
|
|
end
|
|
end)
|
|
dots = {}
|
|
StartHover(layer)
|
|
return layer
|
|
end
|
|
|
|
local function EnsureInfoButton()
|
|
if infoButton then
|
|
return infoButton
|
|
end
|
|
local wm = _G.WorldMapFrame
|
|
if not wm then
|
|
return nil
|
|
end
|
|
infoButton = UI.CreateButton(wm, "", 300, 22, function()
|
|
Overlay:Clear()
|
|
end, "default")
|
|
if API.Classic() then
|
|
local canvas = Canvas() or wm
|
|
if wm.GetFrameStrata then infoButton:SetFrameStrata(wm:GetFrameStrata()) end
|
|
infoButton:SetFrameLevel((canvas:GetFrameLevel() or 1) + 40)
|
|
infoButton:SetPoint("TOPLEFT", canvas, "TOPLEFT", 12, -12)
|
|
else
|
|
infoButton:SetFrameStrata("HIGH")
|
|
infoButton:SetFrameLevel((wm:GetFrameLevel() or 1) + LAYER_LEVEL + 100)
|
|
local anchor = wm.ScrollContainer or wm
|
|
infoButton:SetPoint("TOPLEFT", anchor, "TOPLEFT", 12, -42)
|
|
end
|
|
infoButton:Hide()
|
|
return infoButton
|
|
end
|
|
|
|
local function CurrentMapID()
|
|
return API.CurrentMapID(function()
|
|
local list, seen = {}, {}
|
|
for _, p in ipairs(Overlay.points or {}) do
|
|
if p.m and not seen[p.m] then seen[p.m] = true; list[#list + 1] = p.m end
|
|
end
|
|
return list
|
|
end)
|
|
end
|
|
|
|
-- Faktor Kartenflaeche -> Bildschirm (aendert sich beim Zoomen)
|
|
function Overlay:CanvasScale()
|
|
local canvas = Canvas()
|
|
local s = 1
|
|
if canvas and canvas.GetEffectiveScale and _G.UIParent then
|
|
local a, b = canvas:GetEffectiveScale(), _G.UIParent:GetEffectiveScale()
|
|
if type(a) == "number" and type(b) == "number" and b > 0 and a > 0 then
|
|
s = a / b
|
|
end
|
|
end
|
|
return s
|
|
end
|
|
|
|
-- Skalierung der Punkte-Ebene relativ zur Oberflaeche
|
|
local function LayerScale()
|
|
local s = 1
|
|
if layer and layer.GetEffectiveScale and _G.UIParent then
|
|
local a, b = layer:GetEffectiveScale(), _G.UIParent:GetEffectiveScale()
|
|
if type(a) == "number" and type(b) == "number" and b > 0 and a > 0 then
|
|
s = a / b
|
|
end
|
|
end
|
|
return s
|
|
end
|
|
|
|
-- Punkte einer Karte zusammenfassen: je Klasse (u, o, p) und BIN x BIN Zellen ein Punkt
|
|
function Overlay:Bins(mapID)
|
|
local bins = {}
|
|
for _, p in ipairs(self.points or {}) do
|
|
if p.m == mapID then
|
|
local cls = p.pin and "p" or (p.k == "o" and "o" or "u")
|
|
local cx = math.min(GRID - 1, math.max(0, math.floor(p.x * GRID)))
|
|
local cy = math.min(GRID - 1, math.max(0, math.floor(p.y * GRID)))
|
|
local base = math.floor(cy / BIN) * 1000 + math.floor(cx / BIN)
|
|
local key = base .. cls
|
|
local b = bins[key]
|
|
if not b then
|
|
b = { sx = 0, sy = 0, n = 0, names = {}, cls = cls, base = base }
|
|
bins[key] = b
|
|
end
|
|
local w = p.n or 1
|
|
b.sx, b.sy, b.n = b.sx + p.x * w, b.sy + p.y * w, b.n + w
|
|
if p.name then
|
|
b.names[p.name] = (b.names[p.name] or 0) + w
|
|
end
|
|
end
|
|
end
|
|
local list, maxN, perBase = {}, 1, {}
|
|
for _, b in pairs(bins) do
|
|
b.x, b.y = b.sx / b.n, b.sy / b.n
|
|
list[#list + 1] = b
|
|
perBase[b.base] = (perBase[b.base] or 0) + 1
|
|
if b.n > maxN then
|
|
maxN = b.n
|
|
end
|
|
end
|
|
for _, b in ipairs(list) do
|
|
b.shared = perBase[b.base] > 1
|
|
end
|
|
-- Reihenfolge: Kreaturen zuerst, Quest-Punkte zuletzt (oben)
|
|
table.sort(list, function(a, b)
|
|
if ORDER[a.cls] ~= ORDER[b.cls] then return ORDER[a.cls] < ORDER[b.cls] end
|
|
if a.y ~= b.y then return a.y < b.y end
|
|
return a.x < b.x
|
|
end)
|
|
return list, maxN
|
|
end
|
|
|
|
-- Gestrichelte Linie durch die Wegpunkte (Luftlinie von Station zu Station).
|
|
-- Jeder Abschnitt merkt sich seine Lage: bleibt er gleich, werden die Striche nur wieder eingeblendet.
|
|
local function HideDashes(from)
|
|
for i = from or 1, #segDash do
|
|
local s = segDash[i]
|
|
for k = 1, s.n do s.tex[k]:Hide() end
|
|
s.n, s.sig = 0, nil
|
|
end
|
|
end
|
|
|
|
local function DrawPath(f, canvas, path, width, height, ratio, layerScale)
|
|
local total = 0
|
|
local len = DASH_LEN / layerScale
|
|
local step = (DASH_LEN + DASH_GAP) / layerScale
|
|
for i = 2, #path do
|
|
local s = segDash[i - 1]
|
|
if not s then s = { tex = {}, n = 0 }; segDash[i - 1] = s end
|
|
local x1, y1 = path[i - 1].x * width * ratio, -path[i - 1].y * height * ratio
|
|
local x2, y2 = path[i].x * width * ratio, -path[i].y * height * ratio
|
|
local sig = string.format("%.2f,%.2f,%.2f,%.2f,%.4f", x1, y1, x2, y2, layerScale)
|
|
if s.sig == sig then
|
|
for k = 1, s.n do s.tex[k]:Show() end
|
|
else
|
|
local dx, dy = x2 - x1, y2 - y1
|
|
local dist = math.sqrt(dx * dx + dy * dy)
|
|
local count = 0
|
|
if dist > 0 then
|
|
local ux, uy = dx / dist, dy / dist
|
|
local angle = atan2(dy, dx)
|
|
local t = len / 2
|
|
while t <= dist and total + count < MAX_DASHES do
|
|
count = count + 1
|
|
local tex = s.tex[count]
|
|
if not tex then
|
|
tex = f:CreateTexture(nil, "OVERLAY", nil, 0)
|
|
tex:SetColorTexture(1, 0.85, 0.2, 0.95)
|
|
s.tex[count] = tex
|
|
end
|
|
tex:ClearAllPoints()
|
|
tex:SetSize(len, DASH_THICK / layerScale)
|
|
tex:SetPoint("CENTER", canvas, "TOPLEFT", x1 + ux * t, y1 + uy * t)
|
|
if tex.SetRotation then tex:SetRotation(angle) end
|
|
tex:Show()
|
|
t = t + step
|
|
end
|
|
end
|
|
for k = count + 1, s.n do s.tex[k]:Hide() end
|
|
s.n, s.sig = count, sig
|
|
end
|
|
total = total + s.n
|
|
end
|
|
HideDashes(#path) -- Abschnitte, die es nicht mehr gibt
|
|
return total
|
|
end
|
|
|
|
function Overlay:Refresh()
|
|
local f = EnsureLayer()
|
|
if not f then
|
|
return
|
|
end
|
|
for _, d in ipairs(dots) do
|
|
HideDot(d)
|
|
end
|
|
if not (self.path and #self.path > 1 and self.points) then
|
|
HideDashes()
|
|
end
|
|
f:Show()
|
|
local btn = EnsureInfoButton()
|
|
if not self.points or #self.points == 0 then
|
|
if btn then
|
|
btn:Hide()
|
|
end
|
|
return
|
|
end
|
|
if btn then
|
|
btn:SetLabel(string.format(FW.L.CODEX_MAP_LABEL, self.label or ""))
|
|
btn:SetWidth(math.max(200, (btn.label:GetStringWidth() or 200) + 24))
|
|
btn:Show()
|
|
end
|
|
|
|
local mapID = CurrentMapID()
|
|
if not mapID then
|
|
return
|
|
end
|
|
local canvas = Canvas() or f
|
|
local width, height = canvas:GetWidth() or 1, canvas:GetHeight() or 1
|
|
if width < 2 or height < 2 then
|
|
if _G.C_Timer and not self.retrying then
|
|
self.retrying = true
|
|
_G.C_Timer.After(0.2, function()
|
|
Overlay.retrying = false
|
|
if Overlay.points then
|
|
Overlay:Refresh()
|
|
end
|
|
end)
|
|
end
|
|
return
|
|
end
|
|
|
|
local bins, maxN = self:Bins(mapID)
|
|
self.bins = bins
|
|
local scale = self:CanvasScale()
|
|
local layerScale = LayerScale()
|
|
local ratio = scale / layerScale -- Kartenflaeche-Einheiten -> Einheiten der Punkte-Ebene
|
|
self.lastScale = scale
|
|
self.drawnMap = mapID
|
|
self.hoverR = (DOT_MAX / 2 + 3) / scale / width -- Trefferradius als Anteil der Kartenbreite
|
|
self.hoverRY = (DOT_MAX / 2 + 3) / scale / height
|
|
self.lastDraw = { mapID = mapID, dots = #bins }
|
|
if self.path and #self.path > 1 and self.pathMap == mapID then
|
|
self.lastDraw.dashes = DrawPath(f, canvas, self.path, width, height, ratio, layerScale)
|
|
else
|
|
HideDashes()
|
|
end
|
|
|
|
for i, b in ipairs(bins) do
|
|
if i > MAX_DOTS then
|
|
break
|
|
end
|
|
local dot = dots[i]
|
|
if not dot then
|
|
dot = NewDot(f)
|
|
dots[i] = dot
|
|
end
|
|
local px = DOT_MIN + (DOT_MAX - DOT_MIN) * math.min(1, b.n / maxN)
|
|
local d = px / layerScale
|
|
local rim = (px + RIM * 2) / layerScale
|
|
local off, offY = 0, 0
|
|
if b.shared then
|
|
-- Kreatur links, Objekt rechts, Quest-Punkt darueber: nebeneinander statt uebereinander
|
|
local step = (px * 0.7) / layerScale
|
|
if b.cls == "u" then off = -step elseif b.cls == "o" then off = step else offY = step end
|
|
end
|
|
local x, y = b.x * width * ratio + off, -b.y * height * ratio + offY
|
|
local c = COLORS[b.cls]
|
|
dot.rim:ClearAllPoints()
|
|
dot.rim:SetSize(rim, rim)
|
|
dot.rim:SetPoint("CENTER", canvas, "TOPLEFT", x, y)
|
|
dot.rim:SetVertexColor(1, 1, 1, 1)
|
|
dot.rim:Show()
|
|
dot.fill:ClearAllPoints()
|
|
dot.fill:SetSize(d, d)
|
|
dot.fill:SetPoint("CENTER", canvas, "TOPLEFT", x, y)
|
|
dot.fill:SetVertexColor(c[1], c[2], c[3], 1)
|
|
dot.fill:Show()
|
|
end
|
|
end
|
|
|
|
-- Mouseover: Namen der Fundorte in der Naehe des Mauszeigers
|
|
local function MouseOverMap()
|
|
if API.Classic() then
|
|
return API.CursorNorm()
|
|
end
|
|
local wm = _G.WorldMapFrame
|
|
local sc = wm and wm.ScrollContainer
|
|
if type(sc) ~= "table" or type(sc.GetNormalizedCursorPosition) ~= "function" then
|
|
return nil
|
|
end
|
|
local focus
|
|
if GetMouseFoci then
|
|
focus = GetMouseFoci()
|
|
focus = focus and focus[1]
|
|
elseif GetMouseFocus then
|
|
focus = GetMouseFocus()
|
|
end
|
|
local f, ok = focus, (focus == nil)
|
|
local depth = 0
|
|
while f and depth < 12 do
|
|
if f == sc then
|
|
ok = true
|
|
break
|
|
end
|
|
f = f.GetParent and f:GetParent() or nil
|
|
depth = depth + 1
|
|
end
|
|
if not ok then
|
|
return nil
|
|
end
|
|
local x, y = sc:GetNormalizedCursorPosition()
|
|
if not x or x < 0 or x > 1 or y < 0 or y > 1 then
|
|
return nil
|
|
end
|
|
return x, y
|
|
end
|
|
|
|
function Overlay:HideHover()
|
|
self.hoverKey = nil
|
|
if self.hoverShown then
|
|
self.hoverShown = nil
|
|
local tip = _G.GameTooltip
|
|
if tip:GetOwner() == _G.WorldMapFrame then
|
|
tip:Hide()
|
|
end
|
|
end
|
|
end
|
|
|
|
function Overlay:UpdateHover()
|
|
if not self.points or not self.bins or not self.drawnMap then
|
|
return self:HideHover()
|
|
end
|
|
local x, y = MouseOverMap()
|
|
if not x then
|
|
return self:HideHover()
|
|
end
|
|
local key = math.floor(x * GRID) * 1000 + math.floor(y * GRID)
|
|
if key == self.hoverKey and self.hoverShown ~= nil then
|
|
return
|
|
end
|
|
self.hoverKey = key
|
|
local r, ry = self.hoverR or 0.02, self.hoverRY or 0.03
|
|
local names = {}
|
|
local hit = false
|
|
for i, b in ipairs(self.bins) do
|
|
if i > MAX_DOTS then
|
|
break
|
|
end
|
|
if math.abs(b.x - x) <= r and math.abs(b.y - y) <= ry then
|
|
hit = true
|
|
for name, n in pairs(b.names) do
|
|
names[name] = (names[name] or 0) + n
|
|
end
|
|
end
|
|
end
|
|
if not hit then
|
|
return self:HideHover()
|
|
end
|
|
local list = {}
|
|
for name, n in pairs(names) do
|
|
list[#list + 1] = { name = name, n = n }
|
|
end
|
|
table.sort(list, function(a, b)
|
|
if a.n ~= b.n then return a.n > b.n end
|
|
return a.name < b.name
|
|
end)
|
|
local tip = _G.GameTooltip
|
|
tip:SetOwner(_G.WorldMapFrame, "ANCHOR_CURSOR")
|
|
tip:AddLine(FW.L.CODEX_MAP_HOVER, 0.94, 0.75, 0.36)
|
|
for i, e in ipairs(list) do
|
|
if i > 10 then
|
|
tip:AddLine(string.format(FW.L.CODEX_MAP_MORE, #list - 10), 0.8, 0.8, 0.8)
|
|
break
|
|
end
|
|
tip:AddLine(e.name, 0.85, 0.85, 0.85)
|
|
end
|
|
tip:Show()
|
|
self.hoverShown = true
|
|
end
|
|
|
|
local hoverElapsed = 0
|
|
StartHover = function(f)
|
|
f:SetScript("OnUpdate", function(_, elapsed)
|
|
hoverElapsed = hoverElapsed + elapsed
|
|
if hoverElapsed < 0.08 then
|
|
return
|
|
end
|
|
hoverElapsed = 0
|
|
if Overlay.points then
|
|
local sig = API.Signature()
|
|
if sig ~= Overlay.lastSig then
|
|
Overlay.lastSig = sig
|
|
Overlay:Refresh()
|
|
end
|
|
local sc = Overlay:CanvasScale()
|
|
if Overlay.lastScale and math.abs(sc - Overlay.lastScale) > 0.01 then
|
|
Overlay:Refresh()
|
|
end
|
|
Overlay:UpdateHover()
|
|
end
|
|
end)
|
|
end
|
|
|
|
function Overlay:Hook()
|
|
if self.hooked then
|
|
return true
|
|
end
|
|
local wm = _G.WorldMapFrame
|
|
if not wm or not Canvas() then
|
|
return false
|
|
end
|
|
self.hooked = true
|
|
if wm.OnMapChanged then
|
|
pcall(hooksecurefunc, wm, "OnMapChanged", function()
|
|
Overlay:Refresh()
|
|
end)
|
|
end
|
|
if wm.HookScript then
|
|
wm:HookScript("OnShow", function()
|
|
Overlay:Refresh()
|
|
end)
|
|
end
|
|
if API.Classic() and _G.hooksecurefunc and _G.SetMapZoom then
|
|
pcall(hooksecurefunc, "SetMapZoom", function() Overlay:Refresh() end)
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Karte mit dem meisten Gewicht, bevorzugt die aktuelle, wenn sie Punkte hat
|
|
function Overlay:BestMap()
|
|
local weights = {}
|
|
for _, p in ipairs(self.points or {}) do
|
|
weights[p.m] = (weights[p.m] or 0) + (p.n or 1)
|
|
end
|
|
local current = CurrentMapID()
|
|
if current and weights[current] then
|
|
return current
|
|
end
|
|
local best, bestN
|
|
for m, n in pairs(weights) do
|
|
if not bestN or n > bestN or (n == bestN and m < best) then
|
|
best, bestN = m, n
|
|
end
|
|
end
|
|
return best
|
|
end
|
|
|
|
-- Weltkarte oeffnen und auf das passende Gebiet stellen
|
|
function Overlay:Focus()
|
|
local wm = _G.WorldMapFrame
|
|
if not wm or not self.points then
|
|
return
|
|
end
|
|
local target = self:BestMap()
|
|
if not wm:IsShown() then
|
|
if type(ToggleWorldMap) == "function" then
|
|
pcall(ToggleWorldMap)
|
|
else
|
|
pcall(wm.Show, wm)
|
|
end
|
|
end
|
|
if target and target ~= CurrentMapID() then
|
|
API.SetMap(target)
|
|
end
|
|
self:Refresh()
|
|
return target
|
|
end
|
|
|
|
-- points: Liste { m, x, y, n, name, pin }, label: Text fuers Knoepfchen auf der Karte
|
|
function Overlay:Show(points, label, path, pathMap)
|
|
if not points or #points == 0 then
|
|
FW:Print(FW.L.CODEX_MAP_NONE)
|
|
return false
|
|
end
|
|
self.route = nil -- eine andere Anzeige beendet die laufende Quest-Route
|
|
self.points = points
|
|
self.label = label
|
|
self.path = path
|
|
self.pathMap = pathMap
|
|
self:Hook()
|
|
self:Refresh()
|
|
self:Focus()
|
|
return true
|
|
end
|
|
|
|
function Overlay:Clear()
|
|
self.route = nil
|
|
self:HideHover()
|
|
self.points = nil
|
|
self.label = nil
|
|
self.path = nil
|
|
self.pathMap = nil
|
|
self.bins = nil
|
|
self:Refresh()
|
|
end
|
|
|
|
------------------------------------------------------------------------
|
|
-- Laufende Quest-Route: folgt dir, solange die Karte offen ist
|
|
------------------------------------------------------------------------
|
|
|
|
local ROUTE_MOVE = 0.005 -- Bewegung (Anteil der Kartenbreite), ab der neu gerechnet wird
|
|
local ROUTE_ARRIVE = 0.015 -- so nah dran gilt die Station als erreicht
|
|
local ROUTE_TICK = 1 -- Sekunden zwischen zwei Pruefungen
|
|
local routeGen = 0
|
|
|
|
-- Status der Stationen der aktuellen Route; aendert er sich (Quest angenommen), wird neu gerechnet
|
|
local function RouteSignature(points)
|
|
local t = {}
|
|
for i, p in ipairs(points or {}) do
|
|
t[i] = Codex.QuestStatus(p.id) and "x" or "o"
|
|
end
|
|
return table.concat(t)
|
|
end
|
|
|
|
local function PlayerLoc()
|
|
local loc = FW.Util.GetPlayerLocation()
|
|
if loc and loc.mapID and loc.x and loc.y then return loc end
|
|
return nil
|
|
end
|
|
|
|
-- Reihenfolge und Linie neu rechnen (billig: die Positionen der Quests stehen schon in r.cands).
|
|
-- Rueckgabe: false, wenn keine Station mehr uebrig ist
|
|
function Overlay:RouteRecompute(first)
|
|
local r = self.route
|
|
if not r then return false end
|
|
local loc = PlayerLoc()
|
|
local ax, ay = Codex.PlayerPosOn(r.mapID, loc)
|
|
if ax then
|
|
for _, p in ipairs(r.points or {}) do
|
|
if p.m == r.mapID and (p.x - ax) ^ 2 + (p.y - ay) ^ 2 < ROUTE_ARRIVE ^ 2 then
|
|
r.skip[p.id] = true
|
|
end
|
|
end
|
|
end
|
|
-- nur Quests, die noch offen sind (nicht angenommen, nicht abgegeben) und nicht schon erreicht wurden
|
|
local live = {}
|
|
for _, c in ipairs(r.cands) do
|
|
if not r.skip[c.id] and Codex.QuestStatus(c.id) == nil then live[#live + 1] = c end
|
|
end
|
|
r.cands = live
|
|
local points, mapID, path = Codex.QuestRouteOrder(live, loc)
|
|
if #points == 0 then
|
|
-- nichts mehr uebrig: Ende; sonst nur nichts in der Naehe (anderes Gebiet): alte Anzeige behalten
|
|
if #live == 0 then self:Clear() end
|
|
r.last = loc and { m = loc.mapID, x = loc.x, y = loc.y } or nil
|
|
return false
|
|
end
|
|
local mapChanged = r.mapID ~= mapID
|
|
self.points, self.path, self.pathMap = points, path, mapID
|
|
self.label = string.format(FW.L.CODEX_ROUTE_LABEL, #points)
|
|
self.bins = nil
|
|
r.points, r.mapID, r.sig = points, mapID, RouteSignature(points)
|
|
r.last = loc and { m = loc.mapID, x = loc.x, y = loc.y } or nil
|
|
local wm = _G.WorldMapFrame
|
|
if mapChanged and not first and wm and wm.IsShown and wm:IsShown() then
|
|
API.SetMap(mapID)
|
|
end
|
|
self:Refresh()
|
|
return true
|
|
end
|
|
|
|
-- Eine Pruefung: neu rechnen, wenn du dich bewegt hast oder sich eine Quest geaendert hat
|
|
function Overlay:RouteStep()
|
|
local r = self.route
|
|
if not r then return false end
|
|
local wm = _G.WorldMapFrame
|
|
if wm and wm.IsShown and not wm:IsShown() then return false end
|
|
local loc = PlayerLoc()
|
|
local changed = RouteSignature(r.points) ~= r.sig
|
|
if not changed and loc then
|
|
local last = r.last
|
|
changed = not last or last.m ~= loc.mapID or (loc.x - last.x) ^ 2 + (loc.y - last.y) ^ 2 > ROUTE_MOVE ^ 2
|
|
end
|
|
if changed then return self:RouteRecompute(false) end
|
|
return false
|
|
end
|
|
|
|
local function RouteTick(gen)
|
|
local r = Overlay.route
|
|
if not r or r.gen ~= gen then return end
|
|
Overlay:RouteStep()
|
|
if Overlay.route and Overlay.route.gen == gen and _G.C_Timer then
|
|
_G.C_Timer.After(ROUTE_TICK, function() RouteTick(gen) end)
|
|
end
|
|
end
|
|
|
|
-- ids: Quest-IDs der Liste. Zeigt die Route und haelt sie danach aktuell.
|
|
function Overlay:StartRoute(ids, opts)
|
|
local loc = PlayerLoc()
|
|
local cands = Codex.QuestRouteCandidates(ids, opts)
|
|
local points, mapID, path = Codex.QuestRouteOrder(cands, loc)
|
|
if #points == 0 then
|
|
FW:Print(FW.L.CODEX_ROUTE_NONE)
|
|
return false
|
|
end
|
|
self:Show(points, string.format(FW.L.CODEX_ROUTE_LABEL, #points), path, mapID)
|
|
routeGen = routeGen + 1
|
|
self.route = { cands = cands, skip = {}, points = points, mapID = mapID, gen = routeGen,
|
|
sig = RouteSignature(points), last = loc and { m = loc.mapID, x = loc.x, y = loc.y } or nil }
|
|
if _G.C_Timer then
|
|
_G.C_Timer.After(ROUTE_TICK, function() RouteTick(routeGen) end)
|
|
end
|
|
return true
|
|
end
|
|
|
|
FW:RegisterEvent("ADDON_LOADED", function(_, name)
|
|
if name == "Blizzard_WorldMap" then
|
|
Overlay:Hook()
|
|
Overlay:Refresh()
|
|
end
|
|
end, Overlay)
|
|
|
|
-- Diagnose: /fwcodex map
|
|
function Overlay:Debug()
|
|
local canvas = Canvas()
|
|
local d = self.lastDraw
|
|
FW:Print("Karte: " .. tostring(CurrentMapID()) .. ", Flaeche " .. tostring(canvas and canvas:GetWidth()) .. " x "
|
|
.. tostring(canvas and canvas:GetHeight()) .. ", Ebene " .. tostring(canvas and canvas:GetFrameLevel())
|
|
.. ", Overlay-Ebene " .. tostring(layer and layer:GetFrameLevel()))
|
|
FW:Print("Punkte geladen: " .. tostring(self.points and #self.points or 0) .. ", gezeichnet: " .. tostring(d and d.dots)
|
|
.. ", Maske: " .. tostring(MaskAvailable()) .. ", Skalierung: " .. string.format("%.2f", self:CanvasScale()))
|
|
local wm = _G.WorldMapFrame
|
|
FW:Print("Kartenfenster sichtbar: " .. tostring(wm and wm:IsShown()) .. ", Kartenflaeche sichtbar: " .. tostring(canvas and canvas:IsVisible())
|
|
.. ", Punkte-Ebene sichtbar: " .. tostring(layer and layer:IsVisible()) .. ", Ebenen-Skalierung: " .. string.format("%.2f", LayerScale()))
|
|
API.Debug()
|
|
local seen = {}
|
|
for _, p in ipairs(self.points or {}) do
|
|
if p.m and not seen[p.m] then
|
|
seen[p.m] = true
|
|
local c, z = API.Resolve(p.m)
|
|
FW:Print("Punkte-Karte " .. p.m .. " (" .. tostring(_G.C_Map and _G.C_Map.GetMapInfo and (_G.C_Map.GetMapInfo(p.m) or {}).name) .. ") -> Kontinent "
|
|
.. tostring(c) .. ", Zone " .. tostring(z))
|
|
end
|
|
end
|
|
local first = dots and dots[1]
|
|
if first then
|
|
FW:Print("Erster Punkt: sichtbar " .. tostring(first.fill:IsVisible()) .. ", Grösse " .. tostring(first.fill:GetWidth())
|
|
.. ", Ebene der Ebene sichtbar " .. tostring(layer and layer:IsVisible()))
|
|
end
|
|
end
|
|
|
|
-- Test: grosser roter Kasten in der Kartenmitte, zeigt ob ueberhaupt gezeichnet wird
|
|
function Overlay:Test()
|
|
local f = EnsureLayer()
|
|
if not f then
|
|
FW:Print("Weltkarte nicht gefunden.")
|
|
return
|
|
end
|
|
if not f.testTex then
|
|
f.testTex = f:CreateTexture(nil, "OVERLAY")
|
|
f.testTex:SetColorTexture(1, 0.1, 0.1, 0.6)
|
|
f.testTex:SetSize(160, 160)
|
|
f.testTex:SetPoint("CENTER", f, "CENTER", 0, 0)
|
|
end
|
|
if f.testTex:IsShown() then
|
|
f.testTex:Hide()
|
|
else
|
|
f.testTex:Show()
|
|
end
|
|
end
|
|
|
|
-- /fwcodex map square: Punkte als Quadrate (falls die runde Maske Probleme macht)
|
|
function Overlay:ToggleSquare()
|
|
local st = Codex.db.settings
|
|
st.squareDots = not st.squareDots
|
|
for _, d in ipairs(dots or {}) do
|
|
HideDot(d)
|
|
end
|
|
dots = {}
|
|
FW:Print("Codex-Karte: " .. (st.squareDots and "Quadrate" or "runde Punkte"))
|
|
self:Refresh()
|
|
end
|