Files
pfQuest/route.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

705 lines
23 KiB
Lua

-- Performance: cache frequently-used globals
local pairs = pairs
local floor, ceil, sqrt, abs = math.floor, math.ceil, math.sqrt, math.abs
local sin, cos, rad, pi = math.sin, math.cos, math.rad, math.pi
-- WoW's global atan2 returns degrees; fallback for clients without it
local atan2 = atan2 or function(x, y)
return math.deg(math.atan2(x, y))
end
local min, max = math.min, math.max
local getn, insert, sort = table.getn, table.insert, table.sort
local GetTime = GetTime
-- table.getn doesn't return sizes on tables that
-- are using a named index on which setn is not updated
local function tablesize(tbl)
local count = 0
for _ in pairs(tbl) do
count = count + 1
end
return count
end
local function modulo(val, by)
return val - floor(val / by) * by
end
local function GetNearest(xstart, ystart, db, blacklist)
local nearest = nil
local best = nil
for id, data in pairs(db) do
if data[1] and data[2] and not blacklist[id] then
local x, y = xstart - data[1], ystart - data[2]
-- Use squared distance for comparison (avoid sqrt)
local distSq = x * x + y * y
local replace = not nearest or distSq < nearest
if distSq == nearest and best then
local previous = db[best]
-- Keep equal-distance choices stable even when db was rebuilt through
-- pairs(). Coordinates are sufficient; the index is a final tie-break.
replace = data[1] < previous[1]
or (data[1] == previous[1] and (data[2] < previous[2] or (data[2] == previous[2] and id < best)))
end
if replace then
nearest = distSq
best = id
end
end
end
if not best then
return
end
blacklist[best] = true
return db[best]
end
-- connection between objectives
local objectivepath = {}
-- connection between player and the first objective
local playerpath = {} -- worldmap
local mplayerpath = {} -- minimap
local function ClearPath(path)
for id, tex in pairs(path) do
tex.enable = nil
tex:Hide()
end
end
local function DrawLine(path, x, y, nx, ny, hl, minimap)
local display = true
local zoom = 1
-- calculate minimap variables
local xplayer, yplayer, xdraw, ydraw
if minimap then
-- player coords
xplayer, yplayer = GetPlayerMapPosition("player")
xplayer, yplayer = xplayer * 100, yplayer * 100
-- query minimap zoom/size data
local mZoom = pfMap.drawlayer:GetZoom()
local mapID = pfMap:GetMapIDByName(GetRealZoneText())
local mapZoom = pfMap.minimap_zoom[pfMap.minimap_indoor()][mZoom]
local mapWidth = pfMap.minimap_sizes[mapID] and pfMap.minimap_sizes[mapID][1] or 0
local mapHeight = pfMap.minimap_sizes[mapID] and pfMap.minimap_sizes[mapID][2] or 0
-- calculate drawlayer size
xdraw = pfMap.drawlayer:GetWidth() / (mapZoom / mapWidth) / 100
ydraw = pfMap.drawlayer:GetHeight() / (mapZoom / mapHeight) / 100
zoom = ((mapZoom / mapWidth) + (mapZoom / mapHeight)) * 3
end
-- general
local dx, dy = x - nx, y - ny
local dots = ceil(math.sqrt(dx * 1.5 * dx * 1.5 + dy * dy)) / zoom
for i = (minimap and 1 or 2), dots - (minimap and 1 or 2) do
local xpos = nx + dx / dots * i
local ypos = ny + dy / dots * i
if minimap then
-- adjust values to minimap
xpos = (xplayer - xpos) * xdraw
ypos = (yplayer - ypos) * ydraw
-- check if dot should be visible
if pfUI.minimap then
display = (abs(xpos) + 1 < pfMap.drawlayer:GetWidth() / 2 and abs(ypos) + 1 < pfMap.drawlayer:GetHeight() / 2)
and true
or nil
else
local distance = sqrt(xpos * xpos + ypos * ypos)
display = (distance + 1 < pfMap.drawlayer:GetWidth() / 2) and true or nil
end
else
-- adjust values to worldmap
xpos = xpos / 100 * WorldMapButton:GetWidth()
ypos = ypos / 100 * WorldMapButton:GetHeight()
end
if display then
local nline = tablesize(path) + 1
for id, tex in pairs(path) do
if not tex.enable then
nline = id
break
end
end
path[nline] = path[nline] or (minimap and pfMap.drawlayer or WorldMapButton.routes):CreateTexture(nil, "OVERLAY")
path[nline]:SetWidth(4)
path[nline]:SetHeight(4)
path[nline]:SetTexture(pfQuestConfig.path .. "\\img\\route")
if hl and minimap then
path[nline]:SetVertexColor(0.6, 0.4, 0.2, 0.5)
elseif hl then
path[nline]:SetVertexColor(1, 0.8, 0.4, 1)
else
path[nline]:SetVertexColor(0.6, 0.4, 0.2, 1)
end
path[nline]:ClearAllPoints()
if minimap then -- draw minimap
path[nline]:SetPoint("CENTER", pfMap.drawlayer, "CENTER", -xpos, ypos)
else -- draw worldmap
path[nline]:SetPoint("CENTER", WorldMapButton, "TOPLEFT", xpos, -ypos)
end
path[nline]:Show()
path[nline].enable = true
end
end
end
pfQuest.route = CreateFrame("Frame", "pfQuestRoute", WorldFrame)
pfQuest.route.firstnode = nil
pfQuest.route.coords = {}
-- Declared here (ahead of its later re-declaration below, which now just
-- reuses this upvalue) so Reset() can drop a stale automatic-target lock.
-- Without this, a target picked before a map/zone change could keep winning
-- the "stay put" tie-break in OnUpdate even after it stopped being the
-- nearest candidate, since Reset() only ever cleared self.coords/firstnode.
local automaticTargetKey = nil
pfQuest.route.Reset = function(self)
self.coords = {}
self.firstnode = nil
self.recalculate = true
self.lastDrawX = nil
self.lastDrawY = nil
self.lastDrawNode = nil
automaticTargetKey = nil
end
pfQuest.route.Clear = function(self)
self:Reset()
ClearPath(objectivepath)
ClearPath(playerpath)
ClearPath(mplayerpath)
if self.arrow then
self.arrow:Hide()
end
end
pfQuest.route.AddPoint = function(self, tbl)
table.insert(self.coords, tbl)
self.firstnode = nil
self.recalculate = true
end
-- A party-quest pin never gets a "cluster" pin (that only happens inside
-- pfDatabase:SearchQuestID, tied to the player's own qlogid), so it stays a
-- raw, un-clustered spawn candidate here instead of going through AddPoint.
-- Ported from pfQuest-HDB's route.lua, where the same mechanism handles its
-- closed-map item objectives.
pfQuest.route.SetRawObjectiveCandidates = function(self, candidates)
if candidates and next(candidates) then
self.rawObjectiveCandidates = candidates
return
end
if not self.rawObjectiveCandidates then return end
self.rawObjectiveCandidates = nil
for index = table.getn(self.coords), 1, -1 do
if self.coords[index][5] then table.remove(self.coords, index) end
end
self.firstnode = nil
self.recalculate = true
end
-- Update point distances on demand. The route's OnUpdate normally calls this
-- while the player moves, but consumers such as the tracker can request an
-- immediate, consistent snapshot when changing sort modes.
pfQuest.route.UpdateDistances = function(self)
local xplayer, yplayer = GetPlayerMapPosition("player")
if xplayer == 0 and yplayer == 0 then return nil end
for id, data in ipairs(self.coords) do
if data[1] and data[2] then
local x, y = (xplayer * 100 - data[1]) * 1.5, yplayer * 100 - data[2]
self.coords[id][4] = ceil(math.sqrt(x * x + y * y) * 100) / 100
end
end
return true
end
local targetTitle, targetCluster, targetLayer, targetTexture = nil, nil, nil, nil
pfQuest.route.SetTarget = function(node, default)
if
node
and (
node.title ~= targetTitle
or node.cluster ~= targetCluster
or node.layer ~= targetLayer
or node.texture ~= targetTexture
)
then
pfMap.queue_update = true
end
targetTitle = node and node.title or nil
targetCluster = node and node.cluster or nil
targetLayer = node and node.layer or nil
targetTexture = node and node.texture or nil
-- An explicit target owns the arrow until it is cleared. If that target is
-- not present in the current map's route points, do not silently fall back
-- to the nearest quest objective.
pfQuest.route.targetMissing = node and true or nil
pfQuest.route.recalculate = true
end
pfQuest.route.IsTarget = function(node)
if node then
if
targetTitle
and targetTitle == node.title
and targetCluster == node.cluster
and targetLayer == node.layer
and targetTexture == node.texture
then
return true
end
end
return nil
end
local lastpos, completed = 0, 0
local function TargetKey(data)
if not data then return nil end
local node = data[3]
return tostring(data[1]) .. ":" .. tostring(data[2]) .. ":" .. tostring(node and (node.title or node.spawn) or "")
end
local function sortfunc(a, b)
-- Distances are rounded to two decimals, so ties are common. UpdateNodes
-- rebuilds its list through pairs(), whose order is undefined; without a
-- deterministic tie-breaker the first route target can flip every refresh.
-- Some legacy map pins have no coordinate pair, so UpdateDistances leaves
-- their distance nil. Keep those incomplete points after usable targets.
local adistance = tonumber(a[4]) or math.huge
local bdistance = tonumber(b[4]) or math.huge
if adistance ~= bdistance then
return adistance < bdistance
end
local ax, bx = tonumber(a[1]) or math.huge, tonumber(b[1]) or math.huge
if ax ~= bx then
return ax < bx
end
local ay, by = tonumber(a[2]) or math.huge, tonumber(b[2]) or math.huge
if ay ~= by then
return ay < by
end
local an = a[3] and (a[3].title or a[3].spawn or "") or ""
local bn = b[3] and (b[3].title or b[3].spawn or "") or ""
return tostring(an) < tostring(bn)
end
pfQuest.route:SetScript("OnUpdate", function()
local xplayer, yplayer = GetPlayerMapPosition("player")
local wrongmap = xplayer == 0 and yplayer == 0 and true or nil
local curpos = xplayer + yplayer
-- limit distance and route updates to once per .1 seconds
if (this.tick or 5) > GetTime() and lastpos == curpos then
return
else
this.tick = GetTime() + 1
end
-- limit to a maxium of each .05 seconds even on position change
if (this.throttle or 0.2) > GetTime() then
return
else
this.throttle = GetTime() + 0.05
end
-- save current position
lastpos = curpos
-- update distances to player
this:UpdateDistances()
-- Keep a single raw party-objective route point, but choose it on every
-- movement tick, mirroring pfQuest-HDB's route.lua.
if not targetTitle and this.rawObjectiveCandidates then
local nearest, nearestDistance
for _, candidate in ipairs(this.rawObjectiveCandidates) do
local dx, dy = (xplayer * 100 - candidate[1]) * 1.5, yplayer * 100 - candidate[2]
candidate[4] = ceil(math.sqrt(dx * dx + dy * dy) * 100) / 100
if not nearestDistance or candidate[4] < nearestDistance then
nearest, nearestDistance = candidate, candidate[4]
end
end
if nearest and TargetKey(nearest) ~= automaticTargetKey then
for index = table.getn(this.coords), 1, -1 do
if this.coords[index][5] then table.remove(this.coords, index) end
end
table.insert(this.coords, nearest)
this.firstnode = nil
this.recalculate = true
-- Update the lock immediately: the "stay near current pick" stability
-- check below still reads the pre-swap key on this same tick otherwise.
automaticTargetKey = TargetKey(nearest)
end
end
-- Reorder only when the available route nodes or an explicit target change.
-- Re-sorting every second while the player moves causes route flicker and
-- expensive map redraws without improving the selected objective.
if this.recalculate then
table.sort(this.coords, sortfunc)
-- Map-position updates have slight jitter. Keep the current automatic
-- target while it remains close to the best candidate, otherwise two
-- nearby objectives can continuously trade places and redraw the route.
if not targetTitle and automaticTargetKey and this.coords[1] then
local previousIndex
for id, data in ipairs(this.coords) do
if TargetKey(data) == automaticTargetKey then
previousIndex = id
break
end
end
if previousIndex and previousIndex > 1 then
local previous = this.coords[previousIndex]
if previous[4] and this.coords[1][4] and previous[4] <= this.coords[1][4] + 0.5 then
table.remove(this.coords, previousIndex)
table.insert(this.coords, 1, previous)
end
end
end
-- order list on custom targets
if targetTitle and this.coords[1] and not pfQuest.route.IsTarget(this.coords[1][3]) then
local target = nil
-- check for the old index of the target
for id, data in ipairs(this.coords) do
if pfQuest.route.IsTarget(data[3]) then
target = id
break
end
end
-- rearrange coordinates
if target then
local tmp = {}
table.insert(tmp, this.coords[target])
for id, data in ipairs(this.coords) do
if id ~= target then
table.insert(tmp, this.coords[id])
end
end
this.coords = tmp
end
end
-- SetTarget is also used by waypoint addons. Keep an explicit selection
-- authoritative: while its node is unavailable on the current map, the
-- route and arrow stay hidden instead of switching to an unrelated quest.
this.targetMissing = targetTitle and
(not this.coords[1] or not pfQuest.route.IsTarget(this.coords[1][3])) or nil
automaticTargetKey = not targetTitle and TargetKey(this.coords[1]) or nil
this.recalculate = nil
end
-- show arrow when route exists and is stable
if
not wrongmap
and not this.targetMissing
and this.coords[1]
and this.coords[1][4]
and not this.arrow:IsShown()
and pfQuest_config["arrow"] == "1"
and GetTime() > completed + 1
then
this.arrow:Show()
end
-- abort without any nodes or distances
if this.targetMissing or not this.coords[1] or not this.coords[1][4] or pfQuest_config["routes"] == "0" then
ClearPath(objectivepath)
ClearPath(playerpath)
ClearPath(mplayerpath)
return
end
-- check first node for changes
if this.firstnode ~= tostring(this.coords[1][1] .. this.coords[1][2]) then
this.firstnode = tostring(this.coords[1][1] .. this.coords[1][2])
-- recalculate objective paths
local route = { [1] = this.coords[1] }
local blacklist = { [1] = true }
for i = 2, table.getn(this.coords) do
if route[i - 1] then -- make sure the route was not blacklisted
route[i] = GetNearest(route[i - 1][1], route[i - 1][2], this.coords, blacklist)
end
-- remove other item requirement gameobjects of same type from route
if route[i] and route[i][3] and route[i][3].itemreq then
for id, data in ipairs(this.coords) do
if
not blacklist[id]
and data[1]
and data[2]
and data[3]
and data[3].itemreq
and data[3].itemreq == route[i][3].itemreq
then
blacklist[id] = true
end
end
end
end
ClearPath(objectivepath)
for i, data in pairs(route) do
if i > 1 then
DrawLine(objectivepath, route[i - 1][1], route[i - 1][2], route[i][1], route[i][2])
end
end
-- route calculation timestamp
completed = GetTime()
end
if wrongmap then
-- hide player-to-object path
ClearPath(playerpath)
ClearPath(mplayerpath)
this.lastDrawX = nil
this.lastDrawY = nil
else
-- only redraw player-to-object path when position has changed enough to
-- produce a visible difference — DrawLine places one dot-texture per unit
-- of distance, so sub-threshold redraws are pure waste.
-- also invalidate when the target node changed (firstnode flip).
local px, py = xplayer * 100, yplayer * 100
local dx = (this.lastDrawX or px + 1) - px
local dy = (this.lastDrawY or py + 1) - py
local moved = dx * dx + dy * dy
local targetChanged = this.lastDrawNode ~= this.firstnode
if moved > 0.09 or targetChanged then -- threshold: 0.3 map units squared
this.lastDrawX = px
this.lastDrawY = py
this.lastDrawNode = this.firstnode
-- draw player-to-object path
ClearPath(playerpath)
ClearPath(mplayerpath)
DrawLine(playerpath, px, py, this.coords[1][1], this.coords[1][2], true)
-- also draw minimap path if enabled
if pfQuest_config["routeminimap"] == "1" then
DrawLine(mplayerpath, px, py, this.coords[1][1], this.coords[1][2], true, true)
end
end
end
end)
pfQuest.route.drawlayer = CreateFrame("Frame", "pfQuestRouteDrawLayer", WorldMapButton)
pfQuest.route.drawlayer:SetFrameLevel(113)
pfQuest.route.drawlayer:SetAllPoints()
WorldMapButton.routes = CreateFrame("Frame", "pfQuestRouteDisplay", pfQuest.route.drawlayer)
WorldMapButton.routes:SetAllPoints()
pfQuest.route.arrow = CreateFrame("Frame", "pfQuestRouteArrow", UIParent)
pfQuest.route.arrow:SetPoint("CENTER", 0, -100)
pfQuest.route.arrow:SetWidth(48)
pfQuest.route.arrow:SetHeight(36)
pfQuest.route.arrow:SetClampedToScreen(true)
pfQuest.route.arrow:SetMovable(true)
pfQuest.route.arrow:EnableMouse(true)
pfQuest.route.arrow:RegisterForDrag("LeftButton")
pfQuest.route.arrow:SetScript("OnDragStart", function()
if IsShiftKeyDown() then
this:StartMoving()
end
end)
pfQuest.route.arrow:SetScript("OnDragStop", function()
this:StopMovingOrSizing()
end)
local invalid, lasttarget
local xplayer, yplayer, wrongmap
local xDelta, yDelta, dir, angle
local player, perc, column, row, xstart, ystart, xend, yend
local area, alpha, texalpha, color
local defcolor = "|cffffcc00"
local r, g, b
pfQuest.route.arrow:SetScript("OnUpdate", function()
-- abort if the frame is not initialized yet
if not this.parent then
return
end
-- A disabled arrow must stop before any position, texture, or model work.
-- This also makes configuration changes take effect immediately instead of
-- waiting for the invalid-route debounce below.
if pfQuest_config["arrow"] ~= "1" then
invalid = nil
this:Hide()
return
end
-- Route coordinates update at 20 Hz. Updating the visual arrow more often
-- only repeats the same calculations and creates garbage every render frame.
if (this.tick or 0) > GetTime() then
return
end
this.tick = GetTime() + 0.05
xplayer, yplayer = GetPlayerMapPosition("player")
wrongmap = xplayer == 0 and yplayer == 0 and true or nil
target = not this.parent.targetMissing and this.parent.coords and this.parent.coords[1]
and this.parent.coords[1][4] and this.parent.coords[1] or nil
-- disable arrow on invalid map/route
if not target or wrongmap then
if invalid and invalid < GetTime() then
this:Hide()
elseif not invalid then
invalid = GetTime() + 1
end
return
else
invalid = nil
end
-- arrow positioning stolen from TomTomVanilla.
-- all credits to the original authors:
-- https://github.com/cralor/TomTomVanilla
xDelta = (target[1] - xplayer * 100) * 1.5
yDelta = (target[2] - yplayer * 100)
dir = atan2(xDelta, -yDelta)
dir = dir > 0 and (math.pi * 2) - dir or -dir
if dir < 0 then
dir = dir + 360
end
angle = math.rad(dir)
player = pfQuestCompat.GetPlayerFacing()
angle = angle - player
perc = math.abs(((math.pi - math.abs(angle)) / math.pi))
r, g, b = pfUI.api.GetColorGradient(floor(perc * 100) / 100)
cell = modulo(floor(angle / (math.pi * 2) * 108 + 0.5), 108)
column = modulo(cell, 9)
row = floor(cell / 9)
xstart = (column * 56) / 512
ystart = (row * 42) / 512
xend = ((column + 1) * 56) / 512
yend = ((row + 1) * 42) / 512
-- guess area based on node count
area = target[3].priority and target[3].priority or 1
area = max(1, area)
area = min(20, area)
area = (area / 10) + 1
alpha = target[4] - area
alpha = alpha > 1 and 1 or alpha
alpha = alpha < 0.5 and 0.5 or alpha
texalpha = (1 - alpha) * 2
texalpha = texalpha > 1 and 1 or texalpha
texalpha = texalpha < 0 and 0 or texalpha
r, g, b = r + texalpha, g + texalpha, b + texalpha
-- update arrow
this.model:SetTexCoord(xstart, xend, ystart, yend)
this.model:SetVertexColor(r, g, b)
-- recalculate values on target change
if target ~= lasttarget then
-- calculate difficulty color
color = defcolor
if tonumber(target[3]["qlvl"]) then
color = pfMap:HexDifficultyColor(tonumber(target[3]["qlvl"]))
end
-- update node texture
if target[3].texture then
this.texture:SetTexture(target[3].texture)
if target[3].vertex and (target[3].vertex[1] > 0 or target[3].vertex[2] > 0 or target[3].vertex[3] > 0) then
this.texture:SetVertexColor(unpack(target[3].vertex))
else
this.texture:SetVertexColor(1, 1, 1, 1)
end
else
this.texture:SetTexture(pfQuestConfig.path .. "\\img\\node")
this.texture:SetVertexColor(pfMap.str2rgb(target[3].title))
end
-- update arrow texts
local level = target[3].qlvl and "[" .. target[3].qlvl .. "] " or ""
this.title:SetText(color .. level .. target[3].title .. "|r")
local desc = target[3].description or ""
if not pfUI or not pfUI.uf then
this.description:SetTextColor(1, 0.9, 0.7, 1)
desc = string.gsub(desc, "ff33ffcc", "ffffffff")
end
this.description:SetText(desc .. "|r.")
end
-- only refresh distance text on change
local distance = floor(target[4] * 10) / 10
if distance ~= this.distance.number then
this.distance:SetText("|cffaaaaaa" .. pfQuest_Loc["Distance"] .. ": " .. string.format("%.1f", distance))
this.distance.number = distance
end
-- update transparencies
this.texture:SetAlpha(texalpha)
this.model:SetAlpha(alpha)
end)
pfQuest.route.arrow.texture = pfQuest.route.arrow:CreateTexture("pfQuestRouteNodeTexture", "OVERLAY")
pfQuest.route.arrow.texture:SetWidth(28)
pfQuest.route.arrow.texture:SetHeight(28)
pfQuest.route.arrow.texture:SetPoint("BOTTOM", 0, 0)
pfQuest.route.arrow.model = pfQuest.route.arrow:CreateTexture("pfQuestRouteArrow", "MEDIUM")
pfQuest.route.arrow.model:SetTexture(pfQuestConfig.path .. "\\img\\arrow")
pfQuest.route.arrow.model:SetTexCoord(0, 0, 0.109375, 0.08203125)
pfQuest.route.arrow.model:SetAllPoints()
pfQuest.route.arrow.title = pfQuest.route.arrow:CreateFontString("pfQuestRouteText", "HIGH", "GameFontWhite")
pfQuest.route.arrow.title:SetPoint("TOP", pfQuest.route.arrow.model, "BOTTOM", 0, -10)
pfQuest.route.arrow.title:SetFont(pfUI.font_default, pfUI_config.global.font_size + 1, "OUTLINE")
pfQuest.route.arrow.title:SetTextColor(1, 0.8, 0)
pfQuest.route.arrow.title:SetJustifyH("CENTER")
pfQuest.route.arrow.description = pfQuest.route.arrow:CreateFontString("pfQuestRouteText", "HIGH", "GameFontWhite")
pfQuest.route.arrow.description:SetPoint("TOP", pfQuest.route.arrow.title, "BOTTOM", 0, -2)
pfQuest.route.arrow.description:SetFont(pfUI.font_default, pfUI_config.global.font_size, "OUTLINE")
pfQuest.route.arrow.description:SetTextColor(1, 1, 1)
pfQuest.route.arrow.description:SetJustifyH("CENTER")
pfQuest.route.arrow.distance = pfQuest.route.arrow:CreateFontString("pfQuestRouteDistance", "HIGH", "GameFontWhite")
pfQuest.route.arrow.distance:SetPoint("TOP", pfQuest.route.arrow.description, "BOTTOM", 0, -2)
pfQuest.route.arrow.distance:SetFont(pfUI.font_default, pfUI_config.global.font_size - 1, "OUTLINE")
pfQuest.route.arrow.distance:SetTextColor(0.8, 0.8, 0.8)
pfQuest.route.arrow.distance:SetJustifyH("CENTER")
pfQuest.route.arrow.parent = pfQuest.route