Files
pfQuest/map.lua
T
rivi-s 4b287b4ac8 Support recolorable, routable party-quest pins (PFPARTY)
Rendering/routing support for pfQuest-turtle's new party quest map
pins (addon = "PFPARTY"), which deliberately carry no meta.texture.

- UpdateNode gives an untextured PFPARTY node the existing "fav" star
  texture instead of the default ring, tinted through the same
  str2rgb/pfQuest_colors path as any other untextured spawn dot, so
  it is recolorable via the same click as a normal spawn marker.
- Added a frame.updateAddon dirty-flag: a recycled pin frame moving
  from one addon's untextured node to another's could otherwise keep
  its previous shape if the two color keys happened to coincide.
- A PFPARTY node has no cluster pin the way the player's own quest
  objectives get (that only happens inside SearchQuestID, tied to the
  player's own quest log index), so it stays an ordinary un-clustered,
  untextured layer-1 node with the World Map both open and closed and
  would otherwise never satisfy any route-eligibility condition.
  Ported route.lua's SetRawObjectiveCandidates (already used by
  pfQuest-HDB for its own closed-map item objectives; the two route.lua
  files are otherwise near-identical) and added the matching PFPARTY-
  only raw-objective detection to both the closed- and open-map halves
  of UpdateNodes, plus a third scan of the closed-map path for PFPARTY
  nodes specifically -- the existing closed-map scan only ever visits
  PFQUEST nodes, so without this the arrow only reflected party
  progress for as long as the World Map happened to still be open.
  Scoped to addon == "PFPARTY" as a positive requirement (not an
  opt-out like pfQuest-HDB's version), so this cannot change how the
  player's own quest objectives already route.
- The three existing route-eligibility sites (NodeClick, and both
  UpdateNodes passes) and the generic world-unit mouseover tooltip
  watcher (pfMap.tooltip's OnShow) gate on the new
  showPartyQuestPinsRoutable config flag and skip PFPARTY respectively,
  the latter because pfQuest-turtle's own tooltip hook already adds a
  richer per-player breakdown to that same tooltip.
2026-09-26 07:42:17 -07:00

2256 lines
82 KiB
Lua

-- multi api compat
local compat = pfQuestCompat
-- Performance: cache frequently-used globals
local pairs, ipairs, next = pairs, ipairs, next
local strfind, strlower, strsub = strfind, strlower, strsub
local format = string.format
local min, max, abs = math.min, math.max, math.abs
local sqrt, sin, cos = sqrt or math.sqrt, sin or math.sin, cos or math.cos
local floor, ceil = floor or math.floor, ceil or math.ceil
local getn, insert = table.getn, table.insert
local tostring, tonumber, type, unpack = tostring, tonumber, type, unpack
local GetTime = GetTime
local MouseIsOver = MouseIsOver
-- fake the pfQuest minimap node names to Gatherer names,
-- if any minimap-breaking addon collector is found.
local nodename = "pfMiniMapPin"
local minimapbreakers = {
["ElvUI_MinimapButtons"] = true,
["MBB"] = true,
}
local compatnamefake = CreateFrame("Frame")
compatnamefake:RegisterEvent("PLAYER_ENTERING_WORLD")
compatnamefake:SetScript("OnEvent", function()
-- only run once on login
this:UnregisterAllEvents()
-- scan through all addons to identify button collectors
for i = 1, GetNumAddOns() do
local name, title, notes, enabled = GetAddOnInfo(i)
if enabled and minimapbreakers[name] then
nodename = "GatherNoteCompatFake"
end
end
end)
-- checking for control key is very time expensive in 1.12
-- this loop puts it into one place and only updates it every .2 seconds
-- it also only updates the key if the mouse is over a relevant frame
local controlkey = CreateFrame("Frame", "pfQuestControlKey", UIParent)
controlkey:SetScript("OnUpdate", function()
if (this.throttle or 0.2) > GetTime() then
return
else
this.throttle = GetTime() + 0.2
end
if WorldMapFrame:IsShown() and MouseIsOver(WorldMapFrame) or MouseIsOver(pfMap.drawlayer) then
controlkey.pressed = IsControlKeyDown()
end
end)
local validmaps = setmetatable({}, { __mode = "kv" })
local rgbcache = setmetatable({}, { __mode = "kv" })
local minimap_sizes = pfDB["minimap"]
local minimap_zoom = {
[0] = {
[0] = 300,
[1] = 240,
[2] = 180,
[3] = 120,
[4] = 80,
[5] = 50,
},
[1] = {
[0] = 466 + 2 / 3,
[1] = 400,
[2] = 333 + 1 / 3,
[3] = 266 + 2 / 6,
[4] = 200,
[5] = 133 + 1 / 3,
},
}
local unifiedcache = {}
-- used to store/cache combined meta data across nodes of
-- the same kind to avoid duplicating data for each pin
-- the objects here get directly attached to the pfMap nodes
local similar_nodes = {}
-- Coordinate parse cache (shared between UpdateNodes and UpdateMinimap)
local coord_cache = {}
local function IsEmpty(tabl)
for k, v in pairs(tabl) do
return false
end
return true
end
-- Ensure pfQuestConfig.path exists (fallback if config.lua failed)
local addon_path = (pfQuestConfig and pfQuestConfig.path) or "Interface\\AddOns\\pfQuest"
local layers = {
-- regular icons
[addon_path .. "\\img\\available"] = 1,
[addon_path .. "\\img\\available_c"] = 2,
[addon_path .. "\\img\\complete"] = 3,
[addon_path .. "\\img\\complete_c"] = 4,
[addon_path .. "\\img\\icon_vendor"] = 5,
[addon_path .. "\\img\\fav"] = 6,
-- cluster textures
[addon_path .. "\\img\\cluster_item"] = 9,
[addon_path .. "\\img\\cluster_mob"] = 9,
[addon_path .. "\\img\\cluster_misc"] = 9,
[addon_path .. "\\img\\cluster_mob_mono"] = 9,
[addon_path .. "\\img\\cluster_item_mono"] = 9,
[addon_path .. "\\img\\cluster_misc_mono"] = 9,
}
-- Pre-computed texture paths (avoid string concatenation in hot paths)
local TEX_NODECUT = addon_path .. "\\img\\nodecut"
local TEX_NODE = addon_path .. "\\img\\node"
-- Party-quest pins have no meta.texture of their own (that is what makes them
-- recolorable via the same click-to-recolor path as an ordinary spawn dot),
-- but they still get a distinct base shape so they read as "party" at a
-- glance: the existing star icon, tinted the same way TEX_NODE/TEX_NODECUT
-- are below instead of drawn with a fixed color.
local TEX_STAR = addon_path .. "\\img\\fav"
local function GetLayerByTexture(tex)
if layers[tex] then
return layers[tex]
else
return 1
end
end
local function minimap_indoor()
local tempzoom = 0
local state = 1
if GetCVar("minimapZoom") == GetCVar("minimapInsideZoom") then
if GetCVar("minimapInsideZoom") + 0 >= 3 then
pfMap.drawlayer:SetZoom(pfMap.drawlayer:GetZoom() - 1)
tempzoom = 1
else
pfMap.drawlayer:SetZoom(pfMap.drawlayer:GetZoom() + 1)
tempzoom = -1
end
end
if GetCVar("minimapInsideZoom") + 0 == pfMap.drawlayer:GetZoom() then
state = 0
end
pfMap.drawlayer:SetZoom(pfMap.drawlayer:GetZoom() + tempzoom)
return state
end
local function str2rgb(text)
if not text then
return 1, 1, 1
end
if pfQuest_colors[text] then
return unpack(pfQuest_colors[text])
end
if rgbcache[text] then
return unpack(rgbcache[text])
end
local counter = 1
local l = string.len(text)
for i = 1, l, 3 do
counter = compat.mod(counter * 8161, 4294967279)
+ (string.byte(text, i) * 16776193)
+ ((string.byte(text, i + 1) or (l - i + 256)) * 8372226)
+ ((string.byte(text, i + 2) or (l - i + 256)) * 3932164)
end
local hash = compat.mod(compat.mod(counter, 4294967291), 16777216)
local r = (hash - (compat.mod(hash, 65536))) / 65536
local g = ((hash - r * 65536) - (compat.mod((hash - r * 65536), 256))) / 256
local b = hash - r * 65536 - g * 256
rgbcache[text] = { r / 255, g / 255, b / 255 }
return unpack(rgbcache[text])
end
local fpsmod, step
local function NodeAnimate(self, zoom, alpha, fps)
local cur_zoom = self:GetWidth()
local cur_alpha = self:GetAlpha()
local change = nil
self:EnableMouse(true)
fpsmod = math.min(2 / fps, 2)
step = fpsmod / 10
-- update size
if math.abs(cur_zoom - zoom) < 3 then
self:SetWidth(zoom)
self:SetHeight(zoom)
elseif cur_zoom < zoom then
self:SetWidth(cur_zoom + fpsmod)
self:SetHeight(cur_zoom + fpsmod)
change = true
elseif cur_zoom > zoom then
self:SetWidth(cur_zoom - fpsmod)
self:SetHeight(cur_zoom - fpsmod)
change = true
end
-- update alpha
if math.abs(cur_alpha - alpha) < step then
self:SetAlpha(alpha)
-- disable mouse on hidden
if alpha < 0.1 then
self:EnableMouse(nil)
end
elseif cur_alpha < alpha then
self:SetAlpha(cur_alpha + step)
change = true
elseif cur_alpha > alpha then
self:SetAlpha(cur_alpha - step)
change = true
end
return change
end
-- put player position above everything on worldmap
for k, v in pairs({ WorldMapFrame:GetChildren() }) do
if v:IsObjectType("Model") and not v:GetName() then
if string.find(strlower(v:GetModel()), "interface\\minimap\\minimaparrow") then
v:SetFrameLevel(255)
break
end
end
end
pfMap = CreateFrame("Frame", "pfQuestMap", WorldFrame)
pfMap.str2rgb = str2rgb
pfMap.tooltips = {}
pfMap.nodes = {}
pfMap.pins = {}
pfMap.mpins = {}
-- Minimap frames are retained by their node-table identity. The old numeric
-- pool reassigned every following frame when a quest completion removed one
-- visible node, which made a small quest update rebuild a large marker set.
-- Weak keys allow deleted node tables to be collected normally.
pfMap.mpinNodeIndex = setmetatable({}, { __mode = "k" })
pfMap.drawlayer = Minimap
pfMap.unifiedcache = unifiedcache
-- Reverse indexes for O(1) DeleteNode lookups.
-- titleIndex[addon][title][map][coords] = true — set by AddNode
-- tooltipIndex[title][spawn] = true — set by AddNode
pfMap.titleIndex = {}
pfMap.tooltipIndex = {}
-- Set of node tables that have been modified since the last UpdateNodes call.
-- Keyed by node table reference so the node table itself stays clean.
-- AddNode/DeleteNode insert here; UpdateNodes reads and clears entries.
pfMap.dirtyNodes = {}
-- World-map rendering clears dirtyNodes. Keep minimap work separate so opening
-- the World Map cannot consume an objective refresh before the minimap sees it.
pfMap.dirtyMinimapNodes = {}
-- Set of map IDs that have at least one dirty node table.
-- Keyed by zone map ID (integer). Allows WORLD_MAP_UPDATE to cheaply check
-- whether the current zone has pending writes without scanning all dirtyNodes.
pfMap.dirtyMaps = {}
pfMap.minimap_indoor = minimap_indoor
pfMap.minimap_zoom = minimap_zoom
pfMap.minimap_sizes = minimap_sizes
pfMap.tooltip = CreateFrame("Frame", "pfMapTooltip", GameTooltip)
pfMap.tooltip:SetScript("OnShow", function()
local focus = GetMouseFocus()
-- abort on pfQuest nodes
if focus and focus.title then
return
end
-- abort on quest timers
if focus and focus.GetName and strsub((focus:GetName() or ""), 0, 10) == "QuestTimer" then
return
end
-- abort if tooltips are disabled
if pfQuest_config.showtooltips == "0" then
return
end
local name = getglobal("GameTooltipTextLeft1") and getglobal("GameTooltipTextLeft1"):GetText() or "__NONE__"
local zone = pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())
-- remove all colors from received tooltip text
name = string.gsub(name, "|c%x%x%x%x%x%x%x%x", "")
name = string.gsub(name, "|r", "")
if pfMap.tooltips[name] and pfMap.tooltips[name] then
for title, obj in pairs(pfMap.tooltips[name]) do
-- PFPARTY registers here too (it sets meta.spawn so its own map-pin
-- tooltip keeps a real name instead of "Unknown"), but it has its own
-- richer world-unit tooltip addition (HookGameTooltip in
-- pfQuest-partyprogress.lua, with per-player progress). Showing both
-- duplicated the "[!] QuestName" block on the same creature's tooltip.
if obj[zone] and obj[zone].addon ~= "PFPARTY" then
pfMap:ShowTooltip(obj[zone], GameTooltip)
GameTooltip:Show()
end
end
end
end)
-- dummy function that can be used by extensions
-- to avoid drawing the minimap at some locations
function pfMap:HasMinimap()
return true
end
function pfMap.tooltip:GetColor(min, max)
local max = max or 1
local min = min or max or 1
local perc = min / max
local r1, g1, b1, r2, g2, b2
if perc <= 0.5 then
perc = perc * 2
r1, g1, b1 = 1, 0, 0
r2, g2, b2 = 1, 1, 0
else
perc = perc * 2 - 1
r1, g1, b1 = 1, 1, 0
r2, g2, b2 = 0, 1, 0
end
r = r1 + (r2 - r1) * perc
g = g1 + (g2 - g1) * perc
b = b1 + (b2 - b1) * perc
return r, g, b
end
function pfMap:HexDifficultyColor(level, force)
-- Quest levels can include a suffix such as "19+". The color helper needs
-- a number, while callers still retain the original value for display.
local numericLevel = tonumber(level) or tonumber(string.match(tostring(level or ""), "%d+"))
if not numericLevel then return "|cffffffff" end
if force and UnitLevel("player") < numericLevel then
return "|cffff5555"
else
local c = pfQuestCompat.GetDifficultyColor(numericLevel)
return string.format("|cff%02x%02x%02x", c.r * 255, c.g * 255, c.b * 255)
end
end
local function ObjectiveNameMatches(spawn, objective)
spawn = string.lower(tostring(spawn or ""))
objective = string.lower(tostring(objective or ""))
if spawn == "" or objective == "" then return false end
if spawn == objective then return true end
-- Some quest-log rows pluralize a creature name even though the unit
-- database and tooltip use its singular form (Harvest Watcher/Watchers).
return objective == spawn .. "s" or spawn == objective .. "s"
or objective == spawn .. "es" or spawn == objective .. "es"
end
function pfMap:ShowTooltip(meta, tooltip)
local catch = nil
local catch_obj = nil
local tooltip = tooltip or GameTooltip
-- add quest data
if meta["quest"] then
-- scan all quest entries for matches
for qid = 1, GetNumQuestLogEntries() do
local qtitle, _, _, _, _, complete = compat.GetQuestLogTitle(qid)
if meta["quest"] == qtitle then
-- handle active quests
local objectives = GetNumQuestLeaderBoards(qid)
catch = true
local symbol = (complete or objectives == 0) and "|cff555555[|cffffcc00?|cff555555]|r "
or "|cff555555[|cffffcc00!|cff555555]|r "
tooltip:AddLine(symbol .. meta["quest"], 1, 1, 0)
if objectives then
for i = 1, objectives, 1 do
local text, type, finished = GetQuestLogLeaderBoard(i, qid)
if type == "monster" then
-- kill
local i, j, monsterName, objNum, objNeeded =
strfind(text, pfUI.api.SanitizePattern(QUEST_MONSTERS_KILLED))
if monsterName and ObjectiveNameMatches(meta["spawn"], monsterName) then
catch_obj = true
local r, g, b = pfMap.tooltip:GetColor(objNum, objNeeded)
tooltip:AddLine("|cffaaaaaa- |r" .. monsterName .. ": " .. objNum .. "/" .. objNeeded, r, g, b)
end
elseif meta["QTYPE"] == "OBJECT_OBJECTIVE" and (type == "object" or type == "item") then
-- Direct object objectives use the same localized progress
-- format as item objectives, but have no drop-rate item entry.
local _, _, objectName, objNum, objNeeded =
strfind(text, pfUI.api.SanitizePattern(QUEST_OBJECTS_FOUND))
if objectName and meta["spawn"] == objectName then
catch_obj = true
local r, g, b = pfMap.tooltip:GetColor(objNum, objNeeded)
tooltip:AddLine("|cffaaaaaa- |r" .. objectName .. ": " .. objNum .. "/" .. objNeeded, r, g, b)
end
elseif table.getn(meta["item"]) > 0 and type == "item" and meta["droprate"] then
-- loot
local i, j, itemName, objNum, objNeeded = strfind(text, pfUI.api.SanitizePattern(QUEST_OBJECTS_FOUND))
for mid, item in pairs(meta["item"]) do
if item == itemName then
catch_obj = true
local r, g, b = pfMap.tooltip:GetColor(objNum, objNeeded)
local dr, dg, db = pfMap.tooltip:GetColor(tonumber(meta["droprate"]), 100)
local lootcolor = string.format("%02x%02x%02x", dr * 255, dg * 255, db * 255)
tooltip:AddLine(
"|cffaaaaaa- |r"
.. itemName
.. ": "
.. objNum
.. "/"
.. objNeeded
.. " |cff555555[|cff"
.. lootcolor
.. meta["droprate"]
.. "%|cff555555]",
r,
g,
b
)
end
end
elseif table.getn(meta["item"]) > 0 and type == "item" and meta["sellcount"] then
-- vendor
local i, j, itemName, objNum, objNeeded = strfind(text, pfUI.api.SanitizePattern(QUEST_OBJECTS_FOUND))
for mid, item in pairs(meta["item"]) do
if item == itemName then
catch_obj = true
local r, g, b = pfMap.tooltip:GetColor(objNum, objNeeded)
local sellcount = tonumber(meta["sellcount"]) > 0
and " |cff555555[|cffcccccc" .. meta["sellcount"] .. "x" .. "|cff555555]"
or ""
tooltip:AddLine(
"|cffaaaaaa- |r"
.. pfQuest_Loc["Buy"]
.. ": "
.. itemName
.. ": "
.. objNum
.. "/"
.. objNeeded
.. sellcount,
r,
g,
b
)
end
end
end
end
end
end
end
if not catch then
tooltip:AddLine("|cff555555[|cffffcc00!|cff555555]|r " .. meta["quest"], 1, 1, 0.7)
end
if not catch_obj then
-- handle inactive quests
local catchFallback = nil
if meta["item"] and meta["item"][1] and meta["droprate"] then
for mid, item in pairs(meta["item"]) do
catchFallback = true
local dr, dg, db = pfMap.tooltip:GetColor(tonumber(meta["droprate"]), 100)
local lootcolor = string.format("%02x%02x%02x", dr * 255, dg * 255, db * 255)
tooltip:AddLine(
"|cffaaaaaa- |r" .. item .. " |cff555555[|cff" .. lootcolor .. meta["droprate"] .. "%|cff555555]",
0.7,
0.7,
0.7
)
end
end
if meta["item"] and meta["item"][1] and meta["sellcount"] then
for mid, item in pairs(meta["item"]) do
catchFallback = true
local sellcount = tonumber(meta["sellcount"]) > 0
and " |cff555555[|cffcccccc" .. meta["sellcount"] .. "x" .. "|cff555555]"
or ""
tooltip:AddLine("|cffaaaaaa- |r" .. pfQuest_Loc["Buy"] .. ": " .. item .. sellcount, 0.7, 0.7, 0.7)
end
end
if not catchFallback and meta["spawn"] and not meta["texture"] then
catchFallback = true
tooltip:AddLine(
"|cffaaaaaa- |r"
.. (meta["spawntype"] and meta["spawntype"] == "Trigger" and pfQuest_Loc["Explore"] or meta["spawn"]),
0.7,
0.7,
0.7
)
end
if not catchFallback and meta["texture"] and meta["qlvl"] then
local texts = meta["questid"] and pfDB["quests"]["loc"][meta["questid"]] or nil
local objective = meta["questObjective"]
if (not objective or objective == "") and texts then objective = texts["O"] end
if objective and objective ~= "" then
tooltip:AddLine(pfDatabase:FormatQuestText(objective), 1, 1, 0.9, true)
end
local qlvlstr = pfQuest_Loc["Level"] .. ": " .. pfMap:HexDifficultyColor(meta["qlvl"]) .. meta["qlvl"] .. "|r"
local qminstr = meta["qmin"]
and " / " .. pfQuest_Loc["Required"] .. ": " .. pfMap:HexDifficultyColor(meta["qmin"], true) .. meta["qmin"] .. "|r"
or ""
tooltip:AddLine("|cffaaaaaa- |r" .. qlvlstr .. qminstr, 0.8, 0.8, 0.8)
end
end
else
-- handle non-quest objects
if meta["item"][1] and meta["itemid"] and not meta["itemlink"] then
local _, _, itemQuality = GetItemInfo(meta["itemid"])
if itemQuality then
local itemColor = "|c"
.. string.format(
"%02x%02x%02x%02x",
255,
ITEM_QUALITY_COLORS[itemQuality].r * 255,
ITEM_QUALITY_COLORS[itemQuality].g * 255,
ITEM_QUALITY_COLORS[itemQuality].b * 255
)
meta["itemlink"] = itemColor .. "|Hitem:" .. meta["itemid"] .. ":0:0:0|h[" .. meta["item"][1] .. "]|h|r"
end
end
if meta["sellcount"] then
local item = meta["itemlink"] or "[" .. meta["item"][1] .. "]"
local sellcount = tonumber(meta["sellcount"]) > 0
and " |cff555555[|cffcccccc" .. meta["sellcount"] .. "x" .. "|cff555555]"
or ""
tooltip:AddLine(pfQuest_Loc["Vendor"] .. ": " .. item .. sellcount, 1, 1, 1)
elseif meta["item"][1] then
local item = meta["itemlink"] or "[" .. meta["item"][1] .. "]"
local r, g, b = pfMap.tooltip:GetColor(tonumber(meta["droprate"]), 100)
tooltip:AddLine(
"|cffffffff" .. pfQuest_Loc["Loot"] .. ": " .. item .. " |cff555555[|r" .. meta["droprate"] .. "%|cff555555]",
r,
g,
b
)
end
end
tooltip:Show()
end
function pfMap:GetMapNameByID(id)
id = tonumber(id)
return pfDB["zones"]["loc"][id] or nil
end
function pfMap:GetMapIDByName(search)
for id, name in pairs(pfDB["zones"]["loc"]) do
if name == search then
return id
end
end
end
function pfMap:ShowMapID(map)
if map then
local wasShown = WorldMapFrame:IsShown()
if ToggleWorldMap then
-- vanilla & tbc
if not wasShown then
ToggleWorldMap()
end
else
-- wotlk
WorldMapFrame:Show()
end
if wasShown then
pfMap:SetMapByID(map)
pfMap:UpdateNodes()
else
-- Blizzard's own World Map frame has not finished laying itself out on
-- the same frame it is first shown. Zooming immediately afterward can
-- read a nil GetCenter() from its positioning guide and error inside
-- Blizzard's FrameXML. Give it one frame to settle before zooming.
local deferFrame = CreateFrame("Frame")
deferFrame:SetScript("OnUpdate", function()
this:SetScript("OnUpdate", nil)
pfMap:SetMapByID(map)
pfMap:UpdateNodes()
end)
end
return true
end
return nil
end
function pfMap:SetMapByID(id)
local search = pfDB["zones"]["loc"][id]
for cid, cname in pairs({ GetMapContinents() }) do
for mid, mname in pairs({ GetMapZones(cid) }) do
if mname == search then
SetMapZoom(cid, mid)
return
end
end
end
end
local customids = {
["AlteracValley"] = 2597,
}
local map_zone_cache = {}
function pfMap:GetMapID(cid, mid)
cid = cid or GetCurrentMapContinent()
mid = mid or GetCurrentMapZone()
-- Capital maps are not listed by GetMapZones in the 1.12 client. Prefer
-- ClassicAPI's direct area ID when available, then use the database name as
-- a clean-client fallback.
local apiMapID = pfQuestCompat.GetCurrentMapAreaID and pfQuestCompat.GetCurrentMapAreaID()
if apiMapID then return apiMapID end
-- GetMapZones() should always return the same amount
-- of zones for each continent, so we can cache it to
-- avoid further creations of the same table.
if not map_zone_cache[cid] then
map_zone_cache[cid] = { GetMapZones(cid) }
end
local list = map_zone_cache[cid]
local name = list[mid]
local id = pfMap:GetMapIDByName(name)
id = id or pfMap:GetMapIDByName(GetMapInfo())
id = id or customids[GetMapInfo()]
return id
end
-- A map returned by GetMapZones is a normal world/zone surface. Browser
-- searches can find an NPC both outside an instance and just inside it; when
-- their source counts tie, opening the outdoor zone is the useful default.
local zoneMapCache = {}
function pfMap:IsZoneMapID(id)
id = tonumber(id)
if not id then return false end
if zoneMapCache[id] ~= nil then return zoneMapCache[id] end
for cid in pairs({ GetMapContinents() }) do
for _, name in pairs({ GetMapZones(cid) }) do
if pfMap:GetMapIDByName(name) == id then
zoneMapCache[id] = true
return true
end
end
end
zoneMapCache[id] = false
return false
end
function pfMap:AddNode(meta)
if not meta then
return
end
if not meta["zone"] then
return
end
if not meta["title"] then
return
end
-- only compute description if the caller hasn't already done it
-- (SearchMobID / SearchObjectID hoist this call outside their coord loops)
if meta["description"] == nil then
meta["description"] = pfDatabase:BuildQuestDescription(meta)
end
local addon = meta["addon"] or "PFDB"
local map = meta["zone"]
local coords = meta["x"] .. "|" .. meta["y"]
local title = meta["title"]
local layer = GetLayerByTexture(meta["texture"])
local spawn = meta["spawn"]
local item = meta["item"]
local sindex = string.format(
"%s:%s:%s:%s:%s:%s",
(addon or ""),
(map or ""),
(coords or ""),
(title or ""),
(layer or ""),
(spawn or ""),
(item or "")
)
-- use prioritized clusters
if layer >= 9 and meta["priority"] then
layer = layer + (10 - min(meta["priority"], 10))
end
if not pfMap.nodes[addon] then
pfMap.nodes[addon] = {}
end
if not pfMap.nodes[addon][map] then
pfMap.nodes[addon][map] = {}
end
if not pfMap.nodes[addon][map][coords] then
pfMap.nodes[addon][map][coords] = {}
end
-- skip early on existing nodes
if pfMap.nodes[addon][map][coords][title] then
if item and table.getn(pfMap.nodes[addon][map][coords][title].item) > 0 then
-- check if item already exists
for id, name in pairs(pfMap.nodes[addon][map][coords][title].item) do
if name == item then
-- Several creatures can share the exact same spawn coordinate and
-- quest-item node (for example Tunnel Rat Vermin and Scout). Keep
-- a tooltip alias for every matching creature even though the map
-- pin itself is intentionally merged into one node.
if spawn and title then
local existing = pfMap.nodes[addon][map][coords][title]
existing.sharedspawns = existing.sharedspawns or { [existing.spawn] = true }
existing.sharedspawns[spawn] = true
pfMap.tooltips[spawn] = pfMap.tooltips[spawn] or {}
pfMap.tooltips[spawn][title] = pfMap.tooltips[spawn][title] or {}
pfMap.tooltips[spawn][title][map] = existing
pfMap.tooltipIndex[title] = pfMap.tooltipIndex[title] or {}
pfMap.tooltipIndex[title][spawn] = true
-- The map pin stays visually merged, but its tooltip needs to
-- refresh so it can list every creature sharing this location.
pfMap.dirtyNodes[pfMap.nodes[addon][map][coords]] = true
pfMap.dirtyMinimapNodes[pfMap.nodes[addon][map][coords]] = true
pfMap.dirtyMaps[map] = true
end
return
end
end
-- add new item and refresh both map surfaces before exiting.
table.insert(pfMap.nodes[addon][map][coords][title].item, item)
pfMap.dirtyNodes[pfMap.nodes[addon][map][coords]] = true
pfMap.dirtyMinimapNodes[pfMap.nodes[addon][map][coords]] = true
pfMap.dirtyMaps[map] = true
return
end
if
pfMap.nodes[addon][map][coords][title]
and pfMap.nodes[addon][map][coords][title].layer
and layer
and pfMap.nodes[addon][map][coords][title].layer >= layer
then
-- identical node already exists, exit here
return
end
end
-- create new combined data node from given meta data
if not similar_nodes[sindex] then
similar_nodes[sindex] = {}
for key, val in pairs(meta) do
similar_nodes[sindex][key] = val
end
similar_nodes[sindex].item = { [1] = item }
end
-- set current node to combined node
pfMap.nodes[addon][map][coords][title] = similar_nodes[sindex]
-- mark this coord's node table dirty so UpdateNodes knows to reprocess it
pfMap.dirtyNodes[pfMap.nodes[addon][map][coords]] = true
pfMap.dirtyMinimapNodes[pfMap.nodes[addon][map][coords]] = true
pfMap.dirtyMaps[map] = true
-- maintain reverse title index for O(1) DeleteNode
if not pfMap.titleIndex[addon] then
pfMap.titleIndex[addon] = {}
end
if not pfMap.titleIndex[addon][title] then
pfMap.titleIndex[addon][title] = {}
end
if not pfMap.titleIndex[addon][title][map] then
pfMap.titleIndex[addon][title][map] = {}
end
pfMap.titleIndex[addon][title][map][coords] = true
-- add node to unified cluster cache
if not meta["cluster"] and not meta["texture"] then
local node_index = meta.item or meta.spawn or UNKNOWN
local x, y = tonumber(meta.x), tonumber(meta.y)
-- create prerequisite table structure
unifiedcache[title] = unifiedcache[title] or {}
unifiedcache[title][map] = unifiedcache[title][map] or {}
if not unifiedcache[title][map][node_index] then
-- create new unified node from given meta data
local unified_meta = {}
for key, val in pairs(meta) do
unified_meta[key] = val
end
-- save node to unified cache
unifiedcache[title][map][node_index] = { meta = unified_meta, coords = {} }
end
-- append new coords to unified cache unified cache
table.insert(unifiedcache[title][map][node_index].coords, { x, y })
end
-- add to gametooltips
if spawn and title then
pfMap.tooltips[spawn] = pfMap.tooltips[spawn] or {}
pfMap.tooltips[spawn][title] = pfMap.tooltips[spawn][title] or {}
pfMap.tooltips[spawn][title][map] = pfMap.tooltips[spawn][title][map] or similar_nodes[sindex]
-- maintain reverse tooltip index for O(1) DeleteNode
if not pfMap.tooltipIndex[title] then
pfMap.tooltipIndex[title] = {}
end
pfMap.tooltipIndex[title][spawn] = true
end
pfMap.queue_update = GetTime()
end
function pfMap:GetNodes(addon, title)
local nodes = {}
if title and pfMap.nodes[addon] then
for map, foo in pairs(pfMap.nodes[addon]) do
for coords, node in pairs(pfMap.nodes[addon][map]) do
if pfMap.nodes[addon][map][coords][title] then
table.insert(nodes, pfMap.nodes[addon][map][coords][title])
end
end
end
end
return nodes
end
function pfMap:DeleteNode(addon, title)
if not addon then
-- wipe everything
pfMap.tooltips = {}
pfMap.nodes = {}
pfMap.titleIndex = {}
pfMap.tooltipIndex = {}
pfMap.dirtyNodes = {}
pfMap.dirtyMinimapNodes = {}
pfMap.dirtyMaps = {}
elseif not title then
-- wipe all nodes for this addon; clean up both reverse indexes
if pfMap.titleIndex[addon] then
for t, maps in pairs(pfMap.titleIndex[addon]) do
-- clean tooltipIndex entries that belonged to this addon's titles
local spawns = pfMap.tooltipIndex[t]
if spawns then
for spawn in pairs(spawns) do
if pfMap.tooltips[spawn] then
pfMap.tooltips[spawn][t] = nil
if IsEmpty(pfMap.tooltips[spawn]) then
pfMap.tooltips[spawn] = nil
end
end
end
pfMap.tooltipIndex[t] = nil
end
end
pfMap.titleIndex[addon] = nil
end
pfMap.nodes[addon] = nil
elseif pfMap.titleIndex[addon] and pfMap.titleIndex[addon][title] then
-- fast path: use reverse index to find exactly which (map, coords) to clear
for map, coords_set in pairs(pfMap.titleIndex[addon][title]) do
if pfMap.nodes[addon] and pfMap.nodes[addon][map] then
for coords in pairs(coords_set) do
if pfMap.nodes[addon][map][coords] then
pfMap.nodes[addon][map][coords][title] = nil
if IsEmpty(pfMap.nodes[addon][map][coords]) then
pfMap.nodes[addon][map][coords] = nil
else
-- coord survives with remaining titles; reprocess on next UpdateNodes
pfMap.dirtyNodes[pfMap.nodes[addon][map][coords]] = true
pfMap.dirtyMinimapNodes[pfMap.nodes[addon][map][coords]] = true
pfMap.dirtyMaps[map] = true
end
end
end
end
end
pfMap.titleIndex[addon][title] = nil
-- clean up tooltip entries for this title using the reverse tooltip index
local spawns = pfMap.tooltipIndex[title]
if spawns then
for spawn in pairs(spawns) do
if pfMap.tooltips[spawn] then
pfMap.tooltips[spawn][title] = nil
if IsEmpty(pfMap.tooltips[spawn]) then
pfMap.tooltips[spawn] = nil
end
end
end
pfMap.tooltipIndex[title] = nil
end
end
pfMap.queue_update = GetTime()
end
function pfMap:NodeClick()
if IsShiftKeyDown() then
if this.questid and this.texture and this.layer < 5 then
-- mark questnode as done
pfQuest_history[this.questid] = { time(), UnitLevel("player") }
end
if this.node and this.title and this.node[this.title] then
-- delete node from map
pfMap:DeleteNode(this.node[this.title].addon, this.title)
end
pfQuest.updateQuestGivers = true
elseif
this.texture
and pfQuest.route
and (this.addon ~= "PFPARTY" or pfQuest_config["showPartyQuestPinsRoutable"] ~= "0")
and (
(pfQuest_config["routecluster"] == "1" and this.layer >= 9)
or (pfQuest_config["routeender"] == "1" and this.layer == 4)
or (pfQuest_config["routestarter"] == "1" and this.layer == 1)
or (pfQuest_config["routestarter"] == "1" and this.layer == 2)
)
then
-- set as arrow target priority
pfQuest.route.SetTarget((not pfQuest.route.IsTarget(this) and this))
pfMap.queue_update = GetTime()
else
-- switch color
pfQuest_colors[this.color] = { str2rgb(this.color .. GetTime()) }
-- Color keys are shared by every node for the quest (or spawn, when
-- spawn-color mode is enabled). A color change does not mutate any node
-- table, so invalidate all render tables and let each visible pin re-read
-- the shared saved color.
for _, addonData in pairs(pfMap.nodes or {}) do
for _, zoneNodes in pairs(addonData) do
for _, node in pairs(zoneNodes) do
pfMap.dirtyNodes[node] = true
pfMap.dirtyMinimapNodes[node] = true
end
end
end
pfMap.queue_update = GetTime()
end
end
function pfMap:NodeEnter()
-- wotlk: need to disable blop tooltips first
if compat.client >= 30300 then
WorldMapPOIFrame.allowBlobTooltip = false
end
local tooltip = this.worldmap and WorldMapTooltip or GameTooltip
tooltip:SetOwner(this, "ANCHOR_LEFT")
this.spawn = this.spawn or UNKNOWN
tooltip:SetText(
this.spawn .. (pfQuest_config.showids == "1" and " |cffcccccc(" .. this.spawnid .. ")|r" or ""),
0.3,
1,
0.8
)
tooltip:AddDoubleLine(pfQuest_Loc["Level"] .. ":", (this.level or UNKNOWN), 0.8, 0.8, 0.8, 1, 1, 1)
tooltip:AddDoubleLine(pfQuest_Loc["Type"] .. ":", (this.spawntype or UNKNOWN), 0.8, 0.8, 0.8, 1, 1, 1)
tooltip:AddDoubleLine(pfQuest_Loc["Respawn"] .. ":", (this.respawn or UNKNOWN), 0.8, 0.8, 0.8, 1, 1, 1)
for title, meta in pairs(this.node) do
pfMap:ShowTooltip(meta, tooltip)
end
-- add tooltip help if setting is enabled
if pfQuest_config["tooltiphelp"] == "1" then
local text = string.gsub(pfQuest_Loc["Use <Shift>-Click To Remove Nodes"], "^Use ", "")
local shifttext
if this.cluster then
text = pfQuest_Loc["Hold <Ctrl> To Hide Cluster"]
elseif tooltip == GameTooltip then
text = pfQuest_Loc["Hold <Ctrl> To Hide Minimap Nodes"]
shifttext = this.questid and this.texture and this.layer < 5
and string.gsub(pfQuest_Loc["Use <Shift>-Click To Mark Quest As Done"], "^Use ", "")
or string.gsub(pfQuest_Loc["Use <Shift>-Click To Remove Nodes"], "^Use ", "")
elseif not this.texture then
text = pfQuest_Loc["Click Node To Change Color"]
elseif this.questid and this.texture and this.layer < 5 then
text = string.gsub(pfQuest_Loc["Use <Shift>-Click To Mark Quest As Done"], "^Use ", "")
end
-- update tooltip and sizes
tooltip:AddLine(text, 0.6, 0.6, 0.6)
if shifttext then tooltip:AddLine(shifttext, 0.6, 0.6, 0.6) end
tooltip:Show()
end
pfMap.highlight = pfQuest_config["mouseover"] == "1" and this.title
end
function pfMap:NodeLeave()
-- wotlk: re-enable blop tooltips
if compat.client >= 30300 then
WorldMapPOIFrame.allowBlobTooltip = true
end
local tooltip = this.worldmap and WorldMapTooltip or GameTooltip
tooltip:Hide()
pfMap.highlight = nil
end
function pfMap:BuildNode(name, parent)
local f = CreateFrame("Button", name, parent)
f.worldmap = parent == WorldMapButton
if parent == WorldMapButton then
f.defalpha = tonumber(pfQuest_config["worldmaptransp"]) or 1
f.defsize = 14
else
f.defalpha = tonumber(pfQuest_config["minimaptransp"]) or 1
f.defsize = 14
f.minimap = true
end
f:SetWidth(f.defsize)
f:SetHeight(f.defsize)
f.Animate = NodeAnimate
f:SetScript("OnEnter", pfMap.NodeEnter)
f:SetScript("OnLeave", pfMap.NodeLeave)
f.tex = f:CreateTexture(nil, "BACKGROUND")
f.tex:SetAllPoints(f)
f.pic = f:CreateTexture(nil, "NORMAL")
f.pic:SetPoint("TOPLEFT", f, "TOPLEFT", 1, -1)
f.pic:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", -1, 1)
f.hl = f:CreateTexture(nil, "BORDER")
f.hl:SetTexture(pfQuestConfig.path .. "\\img\\track")
f.hl:SetPoint("TOPLEFT", f, "TOPLEFT", -5, 5)
f.hl:SetWidth(12)
f.hl:SetHeight(12)
return f
end
pfMap.highlightdb = {}
local function UpdateMinimapIconFade(frame, distance)
if not frame.pic:IsShown() then return end
local halfsize = pfMap.drawlayer:GetWidth() / 2
local fade_range = frame.fade_range or 8
local fade_in = halfsize / 100 * (fade_range - 4)
local fade_out = halfsize / 100 * (fade_range + 4)
local alpha = ((distance or fade_out) - fade_in) / (fade_out - fade_in)
frame.pic:SetAlpha(math.max(0, math.min(alpha, 1)))
end
function pfMap:UpdateNode(frame, node, color, obj, distance)
-- clear node to title association table
if pfMap.highlightdb[frame] then
for k, v in pairs(pfMap.highlightdb[frame]) do
pfMap.highlightdb[frame][k] = nil
end
else
pfMap.highlightdb[frame] = {}
end
-- reset layer
frame.layer = 0
for title, tab in pairs(node) do
pfMap.highlightdb[frame][title] = true
tab.layer = GetLayerByTexture(tab.texture)
-- use prioritized clusters
if tab.cluster and tab.priority then
tab.layer = tab.layer + (10 - min(tab.priority, 10))
end
if tab.spawn and (tab.layer > frame.layer or not frame.spawn) then
frame.updateTexture = (frame.texture ~= tab.texture)
frame.updateVertex = (frame.vertex ~= tab.vertex)
frame.updateColor = (frame.color ~= tab.color)
frame.updateLayer = (frame.layer ~= tab.layer)
-- A recycled pin frame can move from one addon's untextured node to
-- another's (e.g. a plain PFQUEST spawn dot to a PFPARTY star) without
-- updateTexture/updateColor changing, if their color keys happen to
-- coincide. Track the addon switch explicitly so that case still
-- repaints the base shape below instead of keeping the previous one.
frame.updateAddon = (frame.addon ~= tab.addon)
-- set title and texture to the entry with highest layer
-- and add core information
frame.layer = tab.layer
frame.addon = tab.addon
frame.spawn = tab.spawn
frame.spawnid = tab.spawnid
frame.spawntype = tab.spawntype
frame.respawn = tab.respawn
frame.level = tab.level
frame.questid = tab.questid
frame.texture = tab.texture
frame.vertex = tab.vertex
frame.title = title
frame.func = tab.func
frame.cluster = tab.cluster
frame.description = tab.description
frame.priority = tab.priority
frame.quest = tab.quest
frame.qlvl = tab.qlvl
frame.itemreq = tab.itemreq
frame.arrow = tab.arrow
frame.icon = tab.icon
frame.fade_range = tab.fade_range
frame.sharedspawns = tab.sharedspawns
if pfQuest_config["spawncolors"] == "1" then
frame.color = tab.spawn or tab.title
else
frame.color = tab.title
end
end
end
if (frame.updateTexture or frame.updateVertex or not frame.tex:GetTexture()) and frame.texture then
frame.tex:SetTexture(frame.texture)
frame.tex:SetVertexColor(1, 1, 1)
frame.pic:Hide()
if frame.updateVertex and frame.vertex then
local r, g, b = unpack(frame.vertex)
if r > 0 or g > 0 or b > 0 then
frame.tex:SetVertexColor(r, g, b, 1)
end
end
end
if (frame.updateColor or frame.updateTexture or frame.updateAddon or not frame.tex:GetTexture()) and not frame.texture then
local r, g, b = str2rgb(frame.color)
if (frame.title and pfQuest.icons[frame.title]) or frame.icon then
local texture = (frame.title and pfQuest.icons[frame.title]) or frame.icon
frame.pic:SetTexture(texture)
frame.pic:Show()
if obj == "minimap" then
UpdateMinimapIconFade(frame, distance)
end
else
frame.pic:Hide()
end
if frame.addon == "PFPARTY" then
-- The cutout styles are a ring-shape variant; there is no cutout star,
-- so party pins keep the same tinted star regardless of that setting.
frame.tex:SetTexture(TEX_STAR)
frame.tex:SetVertexColor(r, g, b, 1)
elseif obj == "minimap" and pfQuest_config["cutoutminimap"] == "1" then
frame.tex:SetTexture(TEX_NODECUT)
frame.tex:SetVertexColor(r, g, b, 1)
elseif obj ~= "minimap" and pfQuest_config["cutoutworldmap"] == "1" then
frame.tex:SetTexture(TEX_NODECUT)
frame.tex:SetVertexColor(r, g, b, 1)
else
frame.tex:SetTexture(TEX_NODE)
frame.tex:SetVertexColor(r, g, b, 1)
end
end
if frame.updateLayer then
-- City maps such as Ironforge draw their detailed map artwork above the
-- normal outdoor-map pin layer. Keep world-map pins above that artwork;
-- minimap pins retain their existing compact layer range.
frame:SetFrameLevel((obj == "minimap" and 4 or 240) + frame.layer)
end
if frame.updateTexture or frame.updateVertex or frame.updateColor or frame.updateLayer then
frame:SetScript("OnClick", (frame.func or pfMap.NodeClick))
end
local highlight = frame.texture and pfMap.highlightdb[frame][pfMap.highlight] and true or nil
local target = frame.texture and pfQuest.route and pfQuest.route.IsTarget(frame) or nil
-- set default sizes for different node types
frame.defsize = (frame.cluster or frame.layer == 4) and 18 or 14
-- make the current route target visible
if target then
frame.hl:Show()
else
frame.hl:Hide()
end
-- reset frame size except for highlights
if not highlight then
frame:SetWidth(frame.defsize)
frame:SetHeight(frame.defsize)
end
frame.node = node
end
local function GetExploredBounds(mapid)
-- ClassicAPI reads fog data for any zone by ID. This makes the unexplored
-- filter immediately accurate on continent maps without calling SetMapZoom
-- or disturbing the map a player is viewing.
local apiOverlays = pfQuestCompat.GetExploredMapTextures and pfQuestCompat.GetExploredMapTextures(mapid)
if apiOverlays then
-- Capitals and a few special maps have no exploration-overlay geometry at
-- all. They are fully readable map art, not an unexplored blank area, so
-- leave their quest pins alone.
local allOverlays = C_Map and type(C_Map.GetMapOverlays) == "function"
and C_Map.GetMapOverlays(mapid)
if type(allOverlays) ~= "table" then return nil end
if type(allOverlays) == "table" and table.getn(allOverlays) == 0 then return nil, true end
-- Overlay rectangles use the fixed 1002x668 World Map canvas, rather
-- than C_Map.GetMapWorldSize's yard coordinates.
local bounds = {}
for _, overlay in ipairs(apiOverlays) do
-- The art rectangle often contains transparent padding. ClassicAPI's
-- hit rect follows the actual clickable landmass and avoids allowing
-- pins at the loose edges of an otherwise explored overlay.
if overlay.hitRectLeft and overlay.hitRectRight and overlay.hitRectTop and overlay.hitRectBottom then
table.insert(bounds, {
left = overlay.hitRectLeft / 1002 * 100,
right = overlay.hitRectRight / 1002 * 100,
top = overlay.hitRectTop / 668 * 100,
bottom = overlay.hitRectBottom / 668 * 100,
})
else
local width, height = overlay.textureWidth, overlay.textureHeight
local offsetX, offsetY = overlay.offsetX, overlay.offsetY
if width and height and offsetX and offsetY then
table.insert(bounds, {
left = offsetX / 1002 * 100,
right = (offsetX + width) / 1002 * 100,
top = offsetY / 668 * 100,
bottom = (offsetY + height) / 668 * 100,
})
end
end
end
return bounds, true
end
if not GetNumMapOverlays or not GetMapOverlayInfo or not GetMapInfo then return nil end
local _, mapHeight, mapWidth = GetMapInfo()
if not mapWidth or not mapHeight or mapWidth == 0 or mapHeight == 0 then return nil end
local bounds = {}
for index = 1, GetNumMapOverlays() do
local texture, width, height, offsetX, offsetY = GetMapOverlayInfo(index)
if texture and texture ~= "" and width and height and offsetX and offsetY then
table.insert(bounds, {
left = offsetX / mapWidth * 100,
right = (offsetX + width) / mapWidth * 100,
top = offsetY / mapHeight * 100,
bottom = (offsetY + height) / mapHeight * 100,
})
end
end
-- Vanilla can report zero overlays while a map is still initializing. An
-- empty result is not evidence that every coordinate is unexplored; keep
-- pins visible until it supplies actual explored rectangles.
if table.getn(bounds) == 0 then return nil end
return bounds
end
-- pfQuest-turtle uses this for projected continent pins. Its callers only use
-- the direct form when ClassicAPI advertises map-exploration support.
pfMap.GetExploredBounds = GetExploredBounds
local function IsExploredPosition(bounds, x, y)
if not bounds then return true end
for _, area in pairs(bounds) do
if x >= area.left and x <= area.right and y >= area.top and y <= area.bottom then
return true
end
end
return false
end
-- The Turtle database extension also draws projected continent pins. Keep the
-- most recently known exploration overlays by source zone so it can apply the
-- same visibility rule there without changing the map the player is viewing.
-- Persist discoveries made during ordinary map browsing. We never switch maps
-- ourselves: each zone enters this cache only after the player has opened it.
pfQuest_config.exploredareas = pfQuest_config.exploredareas or {}
pfMap.exploredAreas = pfQuest_config.exploredareas
-- Older builds could save an empty table when vanilla had not populated map
-- overlays yet. That means "unknown", never "nothing explored"; remove such
-- stale records once so they cannot keep hiding an entire zone after upgrade.
for mapID, bounds in pairs(pfMap.exploredAreas) do
if type(bounds) ~= "table" or not next(bounds) then
pfMap.exploredAreas[mapID] = nil
end
end
pfQuest_config.visitedmaps = pfQuest_config.visitedmaps or {}
pfMap.visitedMaps = pfQuest_config.visitedmaps
pfMap.IsExploredPosition = IsExploredPosition
-- Capital maps do not have meaningful regional fog for quest filtering. Some
-- clients still expose decorative overlay rows for them, so use the character
-- visit record rather than interpreting those rows as unexplored terrain.
local cityMaps = {
[1497] = true, -- Undercity
[1519] = true, -- Stormwind City
[1537] = true, -- Ironforge
[1637] = true, -- Orgrimmar
[1638] = true, -- Thunder Bluff
[1657] = true, -- Darnassus
}
function pfMap:IsMapVisited(mapID)
return mapID and self.visitedMaps[mapID] and true or false
end
function pfMap:MarkMapVisited(mapID)
if mapID then self.visitedMaps[mapID] = true end
end
function pfMap:IsVisitedCityPosition(mapID, x, y)
for cityMapID in pairs(cityMaps) do
if self:IsMapVisited(cityMapID) then
local left, right, top, bottom = pfQuestCompat.GetMapRectOnMap
and pfQuestCompat.GetMapRectOnMap(cityMapID, mapID)
if left and right and top and bottom
and x >= left * 100 and x <= right * 100
and y >= top * 100 and y <= bottom * 100 then
return true
end
end
end
return false
end
function pfMap:GetPlayerMapID()
-- SetMapToCurrentZone resolves capitals (for example Orgrimmar) correctly,
-- while GetRealZoneText can report their surrounding outdoor zone (Durotar).
-- Prefer the ID captured on the player's actual zone-change event so Current
-- Zone Only follows the same map the client uses for the character.
if pfMap.playerMapID then
return pfMap.playerMapID
end
-- Fallback for the short period before the first zone-change event fires.
return GetRealZoneText and pfMap:GetMapIDByName(GetRealZoneText()) or nil
end
function pfMap:CacheCurrentExploration(mapID)
local bounds = GetExploredBounds(mapID)
if mapID and bounds then
self.exploredAreas[mapID] = bounds
end
end
function pfMap:UpdateNodes()
pfQuest:Debug("Update Nodes")
local color = pfQuest_config["spawncolors"] == "1" and "spawn" or "title"
local map = pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())
local i = 1
-- reset tracker
pfQuest.tracker.Reset()
-- Continent and world views do not resolve to a zone map ID. Extensions can
-- render their own pins there, but the core zone-node renderer must not use
-- nil as a dirty-map key.
if not map then
pfQuest.route:Clear()
pfMap.lastRouteMap = nil
for _, pin in pairs(pfMap.pins) do
pin:Hide()
end
pfMap.lastUpdateZone = nil
pfMap.mapJustOpened = nil
if pfQuest.tracker and pfQuest.tracker.DoLayout then
pfQuest.tracker.DoLayout()
end
return
end
-- Current Zone Only follows the player's zone, not a different zone selected
-- while browsing the World Map.
if tonumber(pfQuest_config["trackingmethod"]) == 5 and pfMap:GetPlayerMapID() and map ~= pfMap:GetPlayerMapID() then
pfQuest.route:Clear()
for _, pin in pairs(pfMap.pins) do pin:Hide() end
if pfQuest.tracker and pfQuest.tracker.DoLayout then pfQuest.tracker.DoLayout() end
return
end
local boundaryAliases = tonumber(pfQuest_config["trackingmethod"]) == 5
and pfMap.BuildBoundaryAliasKeys and pfMap:BuildBoundaryAliasKeys(map) or nil
local function FilterBoundaryAliases(nodes)
if not boundaryAliases or not next(boundaryAliases) or not pfMap.IsBoundaryAliasNode then
return nodes or {}
end
local filtered = {}
for coords, node in pairs(nodes or {}) do
if not pfMap:IsBoundaryAliasNode(node, boundaryAliases) then
filtered[coords] = node
end
end
return filtered
end
local exploredBounds, explorationHandled = GetExploredBounds(map)
if cityMaps[map] then
if pfMap:IsMapVisited(map) then
exploredBounds, explorationHandled = nil, nil
else
exploredBounds, explorationHandled = {}, true
end
end
if exploredBounds then
pfMap:CacheCurrentExploration(map)
end
-- Some item/object quests resolve to this zone but do not leave a rendered
-- spawn pin in every map refresh. Preserve their confirmed, map-scoped
-- tracker entry in Current Zone Only mode. Entries vanish as soon as the
-- quest is no longer active.
if tonumber(pfQuest_config["trackingmethod"]) == 5 and pfMap.currentZoneTracker and pfMap.currentZoneTracker[map] then
for questid, title in pairs(pfMap.currentZoneTracker[map]) do
local quest = pfQuest.questlog and pfQuest.questlog[questid]
if quest then
-- The Current Zone fallback can be added before the real ender pin.
-- Use the quest-log state here so simple report/talk turn-ins do not
-- leave the tracker with the fallback's unfinished grey question mark.
local _, _, _, _, _, complete = compat.GetQuestLogTitle(quest.qlogid)
local texture = complete
and pfQuestConfig.path .. "\\img\\complete_c"
or pfQuestConfig.path .. "\\img\\complete"
pfQuest.tracker.ButtonAdd(title, {
dummy = true,
addon = "PFQUEST",
questid = questid,
texture = texture,
})
else
pfMap.currentZoneTracker[map][questid] = nil
end
end
end
-- Quest events also fire while the world map is closed. Rebuilding every
-- hidden world-map frame in that state caused a visible accept/abandon
-- hitch. Refresh only the quest tracker here; minimap pins have their own
-- updater, and dirtyMaps keeps the full world-map render pending until the
-- player actually opens it.
if not WorldMapFrame:IsShown() then
local questNodes = pfMap.nodes.PFQUEST and pfMap.nodes.PFQUEST[map]
local rawObjectiveCandidates = {}
local rebuildRoute = pfMap.lastRouteMap ~= map or pfMap.dirtyMaps[map]
if rebuildRoute then
pfQuest.route:Reset()
pfMap.lastRouteMap = map
end
for coords, node in pairs(questNodes or {}) do
local x, y
if coord_cache[coords] then
x, y = coord_cache[coords][1], coord_cache[coords][2]
else
local _, _, strx, stry = strfind(coords, "(.*)|(.*)")
x, y = strx + 0, stry + 0
coord_cache[coords] = { x, y }
end
local routeNode
local routeLayer = 0
for title, meta in pairs(node) do
pfQuest.tracker.ButtonAdd(title, meta)
pfQuest.tracker.RegisterQuestPoint(title, meta, x, y)
-- Select the same highest-priority entry that UpdateNode would bind to
-- a visible map pin, but keep this path free of frame work.
meta.layer = GetLayerByTexture(meta.texture)
if meta.cluster and meta.priority then
meta.layer = meta.layer + (10 - min(meta.priority, 10))
end
if meta.spawn and (meta.layer > routeLayer or not routeNode) then
routeNode = meta
routeNode.title = title
routeLayer = meta.layer
end
end
if rebuildRoute and routeNode then
local routeEligible =
(routeNode.addon ~= "PFPARTY" or pfQuest_config["showPartyQuestPinsRoutable"] ~= "0")
and (
(pfQuest_config["routecluster"] == "1" and routeNode.layer >= 9)
or (pfQuest_config["routeender"] == "1" and routeNode.layer == 4)
or (pfQuest_config["routestarter"] == "1" and routeNode.layer == 1 and routeNode.texture)
or (pfQuest_config["routestarter"] == "1" and routeNode.layer == 2)
or routeNode.arrow == true
)
local hidden = pfQuest_config["hideunexplored"] == "1"
and ((explorationHandled and not exploredBounds and not pfMap:IsMapVisited(map))
or not IsExploredPosition(exploredBounds, x, y))
and not pfMap:IsVisitedCityPosition(map, x, y)
hidden = hidden or (pfQuest_config["showcluster"] == "0" and routeNode.cluster)
hidden = hidden or (pfQuest_config["showspawn"] == "0" and not routeNode.texture)
if routeEligible and not hidden then
pfQuest.route:AddPoint({ x, y, routeNode })
end
end
end
-- questNodes above is PFQUEST-only (deliberately, so PFPARTY never shows
-- in the tracker), so a party pin is otherwise invisible to routing for
-- as long as the World Map stays closed -- the common case while
-- actually questing. Without this, the arrow only ever reflected party
-- progress from the instant the map was last opened, then went stale.
-- Route-candidate purposes only: no tracker/ButtonAdd calls here, so
-- PFPARTY still never appears in the quest tracker sidebar. No layer
-- priority dance needed like above -- a PFPARTY node is always
-- untextured/layer 1 by construction, with no competing textured or
-- clustered entry to out-prioritize.
local partyNodes = pfMap.nodes.PFPARTY and pfMap.nodes.PFPARTY[map]
if partyNodes and pfQuest_config["showPartyQuestPinsRoutable"] ~= "0" then
for coords, node in pairs(partyNodes) do
local x, y
if coord_cache[coords] then
x, y = coord_cache[coords][1], coord_cache[coords][2]
else
local _, _, strx, stry = strfind(coords, "(.*)|(.*)")
x, y = strx + 0, stry + 0
coord_cache[coords] = { x, y }
end
for title, meta in pairs(node) do
if meta.spawn and not meta.texture then
table.insert(rawObjectiveCandidates, { x, y, meta, nil, true })
end
end
end
end
pfQuest.route:SetRawObjectiveCandidates(rawObjectiveCandidates)
if pfQuest.tracker and pfQuest.tracker.DoLayout then
pfQuest.tracker.DoLayout()
end
return
end
-- A tracker/UI refresh can call UpdateNodes without changing any map node.
-- Keep the existing route in that case; resetting it redraws the path every
-- couple of seconds even though its inputs are unchanged.
if pfMap.lastRouteMap ~= map or pfMap.dirtyMaps[map] then
pfQuest.route:Reset()
pfMap.lastRouteMap = map
end
-- refresh all nodes
local n_pins, n_skipped = 0, 0
-- hoist map dimensions: same for every pin this call, and if the map
-- is resized between calls the new values will invalidate cached px/py.
local mapW = WorldMapButton:GetWidth()
local mapH = WorldMapButton:GetHeight()
-- The enhanced client renders certain capital-city maps on DetailFrame and
-- hides WorldMapButton. Pins parented to the hidden button still receive
-- valid coordinates but can never be drawn. Use the visible detail surface
-- in that case, then return to WorldMapButton for ordinary outdoor maps.
local mapParent = WorldMapButton
if not WorldMapButton:IsVisible() and WorldMapDetailFrame and WorldMapDetailFrame:IsVisible() then
mapParent = WorldMapDetailFrame
end
-- A party-quest pin never gets a "cluster" pin the way the player's own
-- quest objectives do (that only happens inside pfDatabase:SearchQuestID,
-- which is tied to the player's own qlogid), so it stays an ordinary
-- un-clustered, untextured layer-1 node even with the World Map open and
-- would otherwise never satisfy any routeEligible condition below. Collect
-- it as a raw route candidate instead, the same way pfQuest-HDB's map.lua
-- does for its own closed-map item objectives; route.lua picks the nearest
-- one on every movement tick. Scoped to PFPARTY only so this never changes
-- routing for the player's own (already-working) quest objectives.
local rawObjectiveCandidates = {}
for addon, _ in pairs(pfMap.nodes) do
if pfMap.nodes[addon][map] then
for coords, node in pairs(FilterBoundaryAliases(pfMap.nodes[addon][map])) do
if not pfMap.pins[i] then
pfMap.pins[i] = pfMap:BuildNode("pfMapPin" .. i, WorldMapButton)
end
if pfMap.pins[i]:GetParent() ~= mapParent then
pfMap.pins[i]:SetParent(mapParent)
pfMap.pins[i].lastX = nil
pfMap.pins[i].lastY = nil
end
-- skip UpdateNode if this pin is already bound to this exact node table
-- and nothing has been added/removed from it since the last UpdateNodes call.
-- pfMap.dirtyNodes[node] is set by AddNode/DeleteNode on any real write.
-- frame.node ~= node catches coord-slot shifts from insertions/removals.
if pfMap.pins[i].node ~= node or pfMap.dirtyNodes[node] then
pfMap:UpdateNode(pfMap.pins[i], node, color)
pfMap.dirtyNodes[node] = nil
else
n_skipped = n_skipped + 1
end
-- set position (use cached coord parse to avoid strfind alloc)
local x, y
if coord_cache[coords] then
x, y = coord_cache[coords][1], coord_cache[coords][2]
else
local _, _, strx, stry = strfind(coords, "(.*)|(.*)")
x, y = strx + 0, stry + 0
coord_cache[coords] = { x, y }
end
-- QTYPE lives only on the raw per-title meta table, not on the pin
-- frame (UpdateNode never copies it there), so a PFPARTY raw-objective
-- check has to re-pick the same highest-priority entry UpdateNode
-- would bind to this pin, mirroring pfQuest-HDB's map.lua.
local partyRouteNode
local partyRouteLayer = 0
for title, meta in pairs(node) do
local layer = GetLayerByTexture(meta.texture)
if meta.cluster and meta.priority then
layer = layer + (10 - min(meta.priority, 10))
end
if meta.spawn and (layer > partyRouteLayer or not partyRouteNode) then
partyRouteNode = meta
partyRouteLayer = layer
end
end
local rawObjective = partyRouteNode and partyRouteLayer == 1 and not partyRouteNode.texture
and partyRouteNode.QTYPE and string.find(partyRouteNode.QTYPE, "OBJECTIVE", 1, true)
and partyRouteNode.addon == "PFPARTY" and pfQuest_config["showPartyQuestPinsRoutable"] ~= "0"
if rawObjective then
table.insert(rawObjectiveCandidates, { x, y, partyRouteNode, nil, true })
end
-- Route eligibility is determined here, but the point is only added
-- after the final map-visibility checks below. Otherwise the route
-- can lead to an objective that is hidden by fog or a display filter.
local routeEligible =
(pfMap.pins[i].addon ~= "PFPARTY" or pfQuest_config["showPartyQuestPinsRoutable"] ~= "0")
and (
(pfQuest_config["routecluster"] == "1" and pfMap.pins[i].layer >= 9)
or (pfQuest_config["routeender"] == "1" and pfMap.pins[i].layer == 4)
or (pfQuest_config["routestarter"] == "1" and pfMap.pins[i].layer == 1 and pfMap.pins[i].texture)
or (pfQuest_config["routestarter"] == "1" and pfMap.pins[i].layer == 2)
or pfMap.pins[i].arrow == true
)
-- Populate the tracker even when the matching map pin is hidden by a
-- display preference. Hidden objective spawns are still active quests
-- and must remain visible in Current Zone Only mode.
for title, node in pairs(pfMap.pins[i].node) do
pfQuest.tracker.ButtonAdd(title, node)
pfQuest.tracker.RegisterQuestPoint(title, node, x, y)
end
-- Hide pfQuest pins outside the character's discovered map overlays.
if addon == "PFQUEST" and pfQuest_config["hideunexplored"] == "1"
and ((explorationHandled and not exploredBounds and not pfMap:IsMapVisited(map))
or not IsExploredPosition(exploredBounds, x, y))
and not pfMap:IsVisitedCityPosition(map, x, y) then
pfMap.pins[i]:Hide()
-- hide cluster nodes if set
elseif pfQuest_config["showcluster"] == "0" and pfMap.pins[i].cluster then
pfMap.pins[i]:Hide()
-- hide individual quest spawns
elseif pfQuest_config["showspawn"] == "0" and addon == "PFQUEST" and not pfMap.pins[i].texture then
pfMap.pins[i]:Hide()
else
local px = x / 100 * mapW
local py = y / 100 * mapH
-- skip layout calls when the pin hasn't moved; ClearAllPoints +
-- SetPoint are the dominant cost in UpdateNodes for large pin counts
if pfMap.pins[i].lastX ~= px or pfMap.pins[i].lastY ~= py then
pfMap.pins[i].lastX = px
pfMap.pins[i].lastY = py
pfMap.pins[i]:ClearAllPoints()
pfMap.pins[i]:SetPoint("CENTER", mapParent, "TOPLEFT", px, -py)
end
pfMap.pins[i]:Show()
if routeEligible then
pfQuest.route:AddPoint({ x, y, pfMap.pins[i] })
end
end
n_pins = n_pins + 1
i = i + 1
end
end
end
pfQuest.route:SetRawObjectiveCandidates(rawObjectiveCandidates)
pfQuest:Debug(format("UpdateNodes pins=%d skipped=%d", n_pins, n_skipped))
-- hide remaining pins
for j = i, table.getn(pfMap.pins) do
if pfMap.pins[j] then
pfMap.pins[j]:Hide()
pfMap.pins[j].lastX = nil
pfMap.pins[j].lastY = nil
end
end
-- Perform tracker layout once after all ButtonAdd calls complete
if pfQuest.tracker and pfQuest.tracker.DoLayout then
pfQuest.tracker.DoLayout()
end
-- record which zone was rendered so WORLD_MAP_UPDATE can skip no-op opens
pfMap.lastUpdateZone = map
pfMap.dirtyMaps[map] = nil
-- map has fully rendered; subsequent zone changes are deliberate user actions
pfMap.mapJustOpened = nil
end
function pfMap:UpdateMinimap()
-- check for disabled minimap nodes
if pfQuest_config["minimapnodes"] == "0" then
return
end
-- Holding Ctrl over the minimap is an interaction gesture, not a normal map
-- refresh. Handle it before the selected refresh mode can defer work for
-- several hundred milliseconds, then force one redraw on release.
local hideMinimapNodes = controlkey.pressed and MouseIsOver(pfMap.drawlayer)
if hideMinimapNodes then
this.xPlayer = nil
this.minimapHiddenByCtrl = true
for _, pin in pairs(pfMap.mpins) do
pin:Hide()
end
return
elseif this.minimapHiddenByCtrl then
this.minimapHiddenByCtrl = nil
this.minimapTick = nil
end
-- Smooth preserves the original high-end behavior. The other modes reduce
-- repeated pin placement in dense areas, especially at wide minimap zoom.
local mZoom = pfMap.drawlayer:GetZoom()
local refreshMode = pfQuest_config["minimaprefresh"] or "smooth"
local interval
if refreshMode == "performance" then
interval = WorldMapFrame:IsShown() and 0.6 or (mZoom <= 1 and 0.75 or 0.4)
elseif refreshMode == "balanced" then
interval = WorldMapFrame:IsShown() and 0.4 or (mZoom <= 1 and 0.5 or 0.25)
else
interval = 0
end
if (this.minimapTick or 0) > GetTime() then
return
end
this.minimapTick = GetTime() + interval
-- The 1.12 API reports the player in the coordinates of whichever World Map
-- view is currently selected. While a continent map is open that is not the
-- player's zone, so use the last real-zone position for minimap placement.
-- It is refreshed continuously whenever the World Map is closed.
local xPlayer, yPlayer
if WorldMapFrame:IsShown() then
xPlayer, yPlayer = pfMap.minimapPlayerX, pfMap.minimapPlayerY
-- The coordinate API is valid when the player is browsing their current
-- zone. Keep minimap quest pins moving in that case, but retain the last
-- known real-zone position when they browse another zone or continent.
local visibleMap = pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())
if visibleMap and visibleMap == pfMap.minimapMapID then
local currentX, currentY = GetPlayerMapPosition("player")
if currentX and currentY and not (currentX == 0 and currentY == 0) then
xPlayer, yPlayer = currentX, currentY
pfMap.minimapPlayerX, pfMap.minimapPlayerY = currentX, currentY
end
end
else
xPlayer, yPlayer = GetPlayerMapPosition("player")
if xPlayer and yPlayer and not (xPlayer == 0 and yPlayer == 0) then
pfMap.minimapPlayerX, pfMap.minimapPlayerY = xPlayer, yPlayer
-- The World Map changes the active map context, including on the
-- opposite continent. Retain the player's actual map ID with the
-- coordinates so minimap nodes continue to use the real zone.
pfMap.minimapMapID = pfMap.playerMapID
or pfMap:GetMapIDByName(GetRealZoneText())
end
end
-- hide nodes and skip further processing in dungeons or before a usable
-- real-zone position has been captured.
if xPlayer == 0 and yPlayer == 0 then
for pins, pin in pairs(pfMap.mpins) do
pin:Hide()
end
return
end
if not xPlayer or not yPlayer then return end
xPlayer, yPlayer = xPlayer * 100, yPlayer * 100
-- force refresh every second even without changed values, otherwise skip
if this.xPlayer == xPlayer and this.yPlayer == yPlayer and this.mZoom == mZoom then
if (this.tick or 1) > GetTime() then
return
else
this.tick = GetTime() + 1
end
end
this.xPlayer, this.yPlayer, this.mZoom = xPlayer, yPlayer, mZoom
local color = pfQuest_config["spawncolors"] == "1" and "spawn" or "title"
local mapID = WorldMapFrame:IsShown() and pfMap.minimapMapID
or pfMap:GetMapIDByName(GetRealZoneText())
local mapZoom = minimap_zoom[minimap_indoor()][mZoom]
local mapWidth = minimap_sizes[mapID] and minimap_sizes[mapID][1] or 0
local mapHeight = minimap_sizes[mapID] and minimap_sizes[mapID][2] or 0
local xScale = mapZoom / mapWidth
local yScale = mapZoom / mapHeight
local xDraw = pfMap.drawlayer:GetWidth() / xScale / 100
local yDraw = pfMap.drawlayer:GetHeight() / yScale / 100
-- At a zoomed-out minimap scale, ordinary movement often shifts every pin
-- by less than a screen pixel. Keep the last layout until that shift is
-- visible (or the next scheduled refresh has elapsed), rather than
-- re-anchoring a large visible marker set on every polling interval.
local anchorX, anchorY = xPlayer * xDraw, yPlayer * yDraw
if this.minimapAnchorX and math.abs(anchorX - this.minimapAnchorX) < 1
and math.abs(anchorY - this.minimapAnchorY) < 1
and (this.minimapAnchorAt or 0) + interval > GetTime() then
return
end
this.minimapAnchorX, this.minimapAnchorY = anchorX, anchorY
this.minimapAnchorAt = GetTime()
-- Keep marker coordinates in a shared moving layer. Player movement now
-- moves this one layer instead of ClearAllPoints/SetPoint on every visible
-- minimap pin, which is vital when a zoomed-out map has many quest spawns.
local minimapLayer = pfMap.minimapLayer
if not minimapLayer then
minimapLayer = CreateFrame("Frame", nil, pfMap.drawlayer)
minimapLayer:SetFrameStrata(pfMap.drawlayer:GetFrameStrata())
pfMap.minimapLayer = minimapLayer
end
minimapLayer:SetWidth(pfMap.drawlayer:GetWidth())
minimapLayer:SetHeight(pfMap.drawlayer:GetHeight())
minimapLayer:ClearAllPoints()
minimapLayer:SetPoint("CENTER", pfMap.drawlayer, "CENTER", -anchorX, anchorY)
-- Nodes outside the minimap cannot be seen. Updating their anchors every
-- time the player moves is especially expensive in dense quest zones, so
-- cull them before texture or layout work. Keep a small margin for icons
-- entering from the edge.
local visibleHalfWidth = pfMap.drawlayer:GetWidth() / 2 + 24
local visibleHalfHeight = pfMap.drawlayer:GetHeight() / 2 + 24
-- Mark visible pins for this pass. A separate node-to-pin index prevents a
-- removal from shifting and rebuilding every later visual pin.
for _, pin in pairs(pfMap.mpins) do
pin.minimapUsed = nil
end
local freePin = 1
-- refresh all nodes
for addon, data in pairs(pfMap.nodes) do
-- hide minimap nodes in continent view
if data[mapID] and minimap_sizes[mapID] and pfMap:HasMinimap(mapID) then
for coords, node in pairs(data[mapID]) do
local x, y
if coord_cache[coords] then
x, y = coord_cache[coords][1], coord_cache[coords][2]
else
local _, _, strx, stry = strfind(coords, "(.*)|(.*)")
x, y = strx + 0, stry + 0
coord_cache[coords] = { x, y }
end
local xPos = (x - xPlayer) * xDraw
local yPos = (y - yPlayer) * yDraw
if pfQuestCompat.rotateMinimap then
-- TODO: this part is broken and does not work yet.
local sinFacing = sin(pfQuestCompat.GetPlayerFacing())
local cosFacing = cos(pfQuestCompat.GetPlayerFacing())
local dx, dy = xPos, -yPos
xPos = (dx * cosFacing) + (dy * sinFacing)
yPos = -((-dx * sinFacing) + (dy * cosFacing))
end
local isVisible = math.abs(xPos) <= visibleHalfWidth
and math.abs(yPos) <= visibleHalfHeight
if not isVisible then
-- Keep the visible-pin pool compact; remaining old pins are hidden
-- together after the scan.
else
local display = nil
local distance = sqrt(xPos * xPos + yPos * yPos)
if pfUI.minimap then
display = (abs(xPos) + 8 < pfMap.drawlayer:GetWidth() / 2 and abs(yPos) + 8 < pfMap.drawlayer:GetHeight() / 2)
and true
or nil
else
display = (distance + 8 < pfMap.drawlayer:GetWidth() / 2) and true or nil
end
if display then
local pin = pfMap.mpinNodeIndex[node]
if not pin or pin.minimapUsed then
while pfMap.mpins[freePin] and pfMap.mpins[freePin].minimapUsed do
freePin = freePin + 1
end
pin = pfMap.mpins[freePin]
if not pin then
pin = pfMap:BuildNode(nodename .. freePin, pfMap.drawlayer)
pfMap.mpins[freePin] = pin
elseif pin.node then
pfMap.mpinNodeIndex[pin.node] = nil
end
pfMap.mpinNodeIndex[node] = pin
-- Force one visual update when this reusable frame changes owner.
pin.node = nil
freePin = freePin + 1
end
pin.minimapUsed = true
if pin:GetParent() ~= minimapLayer then
pin:SetParent(minimapLayer)
pin.minimapX = nil
pin.minimapY = nil
end
-- skip expensive UpdateNode work (highlightdb rebuild, node iteration,
-- size calls) when this pin is already showing the correct node and
-- nothing has been added or removed from it since the last render.
if pin.node ~= node or pfMap.dirtyMinimapNodes[node] then
pfMap:UpdateNode(pin, node, color, "minimap", distance)
pfMap.dirtyMinimapNodes[node] = nil
end
-- Custom tracking icons fade with player distance even when the
-- underlying node data is unchanged and its expensive rebuild is
-- skipped.
UpdateMinimapIconFade(pin, distance)
if pin.hl:IsShown() then
pin.hl:Hide()
end
if pfQuest_config["showclustermini"] == "0" and pin.cluster then
if pin:IsShown() then pin:Hide() end
elseif pfQuest_config["showspawnmini"] == "0" and addon == "PFQUEST" and not pin.texture then
if pin:IsShown() then pin:Hide() end
else
-- Anchor against absolute map coordinates. The shared layer above
-- supplies the player-position offset, so walking does not touch
-- this pin's anchors.
if pin.minimapX ~= x or pin.minimapY ~= y
or pin.minimapXDraw ~= xDraw or pin.minimapYDraw ~= yDraw then
pin.minimapX = x
pin.minimapY = y
pin.minimapXDraw = xDraw
pin.minimapYDraw = yDraw
pin:ClearAllPoints()
pin:SetPoint("CENTER", minimapLayer, "CENTER", x * xDraw, -y * yDraw)
end
if not pin:IsShown() then
pin:Show()
end
end
end
end
end
end
end
-- hide remaining pins
for _, pin in pairs(pfMap.mpins) do
if not pin.minimapUsed and pin:IsShown() then
pin:Hide()
end
end
end
local zone
local function CapturePlayerMapID()
-- SetMapToCurrentZone gives city maps their own ID. Keep this independent of
-- the map currently selected by the player in the World Map window.
if WorldMapFrame:IsShown() then
-- Do not change a map the player is browsing, but real-zone text remains
-- safe to read and lets us retain capital visits made with the map open.
if GetRealZoneText then
pfMap:MarkMapVisited(pfMap:GetMapIDByName(GetRealZoneText()))
end
return
end
-- MINIMAP_ZONE_CHANGED also fires while moving between named subareas in a
-- city. If the real map has not changed, calling SetMapToCurrentZone again
-- creates a WORLD_MAP_UPDATE burst and rebuilds the map for no benefit.
-- Keep the existing map ID in that common movement path.
local realMapID = GetRealZoneText and pfMap:GetMapIDByName(GetRealZoneText())
if realMapID and pfMap.playerMapID == realMapID then
pfMap:MarkMapVisited(realMapID)
return
end
SetMapToCurrentZone()
pfMap.playerMapID = pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())
or (GetRealZoneText and pfMap:GetMapIDByName(GetRealZoneText()))
pfMap:MarkMapVisited(pfMap.playerMapID)
-- Some clients draw a capital as its surrounding zone map, but still report
-- the capital's real zone text. Preserve that city visit as well.
if GetRealZoneText then
pfMap:MarkMapVisited(pfMap:GetMapIDByName(GetRealZoneText()))
end
end
pfMap:RegisterEvent("PLAYER_LOGIN")
pfMap:RegisterEvent("ZONE_CHANGED")
pfMap:RegisterEvent("ZONE_CHANGED_NEW_AREA")
pfMap:RegisterEvent("MINIMAP_ZONE_CHANGED")
pfMap:RegisterEvent("WORLD_MAP_UPDATE")
pfMap:SetScript("OnEvent", function()
-- Darnassus and other dense cities can emit MINIMAP_ZONE_CHANGED repeatedly
-- while the player moves. Once the real map is known, do not even query map
-- state for those cosmetic subarea notifications.
if event == "MINIMAP_ZONE_CHANGED" and pfMap.playerMapID then
return
end
-- save current zone
zone = GetCurrentMapZone()
-- set map to current zone when possible
if event == "PLAYER_LOGIN" or event == "ZONE_CHANGED" or event == "ZONE_CHANGED_NEW_AREA" then
-- Read the map immediately after SetMapToCurrentZone. This preserves a
-- capital's own map ID rather than replacing it with its parent zone.
CapturePlayerMapID()
elseif event == "MINIMAP_ZONE_CHANGED" and not pfMap.playerMapID then
-- This event can fire repeatedly while walking through named subareas.
-- It is only useful before the initial player map has been established;
-- real zone transitions emit the zone-change events above.
CapturePlayerMapID()
end
-- update nodes on world map changes.
-- Three distinct cases:
-- (1) Map just opened (burst of ~100 events while frame renders): use the
-- debounce to coalesce them into one call once rendering settles.
-- (2) Zone changed by user (deliberate click): call UpdateNodes immediately.
-- (3) Continent view (newzone == nil): hide all pins immediately.
-- (4) Same zone, dirty nodes: stamp debounce.
if event == "WORLD_MAP_UPDATE" then
local newzone = pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())
-- Let the selected zone finish drawing before reading its overlay data.
-- The first WORLD_MAP_UPDATE arrives before 1.12 has populated fog data.
if newzone and WorldMapFrame:IsShown() then
pfMap.explorationCacheMap = newzone
pfMap.explorationCacheAt = GetTime() + 0.35
end
if newzone == nil then
-- continent view: hide all worldmap pins immediately
for j = 1, table.getn(pfMap.pins) do
if pfMap.pins[j] then
pfMap.pins[j]:Hide()
end
end
pfMap.lastUpdateZone = nil
elseif pfMap.mapJustOpened then
-- Map opens and map selections emit a short event burst. Render after
-- the normal settle period. Even enhanced clients emit a burst while
-- the map view changes. Ordinary
-- filter and quest-data updates retain the full debounce below.
-- A route created while the map was hidden has valid coordinates but
-- its last-draw cache refers to the hidden canvas. Invalidate only the
-- drawing cache so the existing target is painted on the visible map.
if pfQuest.route then
pfQuest.route.lastDrawX = nil
pfQuest.route.lastDrawY = nil
pfQuest.route.lastDrawNode = nil
end
pfMap.queue_update = GetTime()
elseif newzone ~= pfMap.lastUpdateZone then
-- deliberate zone change: update immediately, no debounce
pfMap.queue_update = nil
pfMap:UpdateNodes()
elseif pfMap.dirtyMaps[newzone] then
-- same zone, pending writes: coalesce via debounce
pfMap.queue_update = GetTime()
end
end
end)
local hlstate, shiftstate, transition, hidecluster, fps, resetmap
pfMap:SetScript("OnUpdate", function()
-- handle highlights and animations
if pfMap.queue_update or transition or pfMap.highlight ~= hlstate or shiftstate ~= hidecluster then
hlstate, shiftstate, transition = pfMap.highlight, hidecluster, nil
fps = math.max(0.2, GetFramerate() / 30)
for frame, data in pairs(pfMap.highlightdb) do
local highlight = pfMap.highlightdb[frame][pfMap.highlight] and true or nil
if hidecluster and frame.cluster then
-- hide clusters
transition = frame:Animate(frame.defsize, 0, fps) or transition
elseif highlight then
-- zoom node
transition = frame:Animate((frame.texture and frame.defsize + 4 or frame.defsize), 1, fps) or transition
elseif not highlight and pfMap.highlight then
-- fade node
transition = frame:Animate(frame.defsize, tonumber(pfQuest_config["nodefade"]) or 0.3, fps) or transition
elseif frame.texture or frame.cluster then
-- defaults for textured nodes
transition = frame:Animate(frame.defsize, 1, fps) or transition
else
-- defaults
transition = frame:Animate(frame.defsize, frame.defalpha, fps) or transition
end
end
end
-- limit all map updates to once per .05 seconds
if (this.throttle or 0.2) > GetTime() then
return
else
this.throttle = GetTime() + 0.05
end
-- process node updates if required
if pfMap.queue_update and pfMap.queue_update + 0.25 < GetTime() then
-- don't fire while the quest system still has work pending: each queue entry
-- and SearchQuests/UpdateQuestlog call will push queue_update to a newer time,
-- so the debounce will settle naturally once the whole batch is done.
-- This prevents UpdateNodes from firing between queue entries when a prior
-- queue_update stamp happens to be 0.25s old mid-drain.
local questBusy = pfQuest and ((pfQuest.queueCount or 0) > 0 or pfQuest.updateQuestGivers or pfQuest.updateQuestLog)
if not questBusy then
pfMap.queue_update = nil
pfMap:UpdateNodes()
end
end
if pfMap.explorationCacheAt and pfMap.explorationCacheAt <= GetTime() then
local map = pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())
if WorldMapFrame:IsShown() and map == pfMap.explorationCacheMap then
pfMap:CacheCurrentExploration(map)
-- Map overlays arrive after the initial WORLD_MAP_UPDATE on many maps.
-- The first render may therefore have treated every pin as unexplored.
-- Rebuild once the client has populated its fog data so the display and
-- saved cache use the same bounds.
if pfQuest_config["hideunexplored"] == "1" then
pfMap.queue_update = GetTime()
end
end
pfMap.explorationCacheMap = nil
pfMap.explorationCacheAt = nil
end
-- reset map to current zone once map is closed
-- also flag the frame as just-opened so the WORLD_MAP_UPDATE handler
-- knows to use the debounce instead of calling UpdateNodes immediately
-- (the burst of ~100 events during map-open rendering would otherwise
-- trigger multiple immediate UpdateNodes calls)
if WorldMapFrame:IsShown() then
if not resetmap then
pfMap.mapJustOpened = true
end
resetmap = true
elseif resetmap == true then
SetMapToCurrentZone()
-- Do not call GetPlayerMapID here: it intentionally returns the cached
-- value first, which would preserve the map the player was browsing.
-- Read the client map context we just restored instead.
pfMap.playerMapID = pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())
or (GetRealZoneText and pfMap:GetMapIDByName(GetRealZoneText()))
pfMap:MarkMapVisited(pfMap.playerMapID)
resetmap = nil
end
-- refresh minimap
pfMap:UpdateMinimap()
-- update hidecluster detection
if controlkey.pressed then
hidecluster = MouseIsOver(WorldMapFrame)
else
hidecluster = nil
end
end)
-- only hook for 3.3.5
if compat.client >= 30300 then
-- Initialize a variable to track the previous clicked title
local previousTitle = nil
-- Highlight Map Quest Log Selection Nodes
local pfHookWorldMapQuestFrame_OnMouseUp = WorldMapQuestFrame_OnMouseUp
WorldMapQuestFrame_OnMouseUp = function(self)
pfHookWorldMapQuestFrame_OnMouseUp(self)
WorldMapBlobFrame:Hide()
WorldMapFrame_ClearQuestPOIs()
if not IsShiftKeyDown() then
pfMap.highlight = nil
local questLogIndex = GetQuestLogSelection()
local title = GetQuestLogTitle(questLogIndex)
if title then
if previousTitle == title then
-- Reset the highlight if the same title is clicked again
pfMap.highlight = nil
previousTitle = nil
else
-- Logic for highlighting nodes associated with the clicked quest
pfMap.highlight = title
previousTitle = title
pfMap.queue_update = GetTime()
end
end
end
end
end