1283 lines
47 KiB
Lua
1283 lines
47 KiB
Lua
--------------------------------------------------------------------------------
|
|
-- Nanami-UI: Flight Map (FlightMap.lua)
|
|
-- Skins TaxiFrame with Nanami-UI theme, destination list, in-flight timer
|
|
--------------------------------------------------------------------------------
|
|
|
|
SFrames = SFrames or {}
|
|
SFrames.FlightMap = {}
|
|
local FM = SFrames.FlightMap
|
|
SFramesDB = SFramesDB or {}
|
|
SFramesGlobalDB = SFramesGlobalDB or {}
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Theme (Pink Cat-Paw)
|
|
--------------------------------------------------------------------------------
|
|
local T = SFrames.Theme:Extend({
|
|
currentText = { 0.40, 1.0, 0.40 },
|
|
moneyGold = { 1, 0.84, 0.0 },
|
|
moneySilver = { 0.78, 0.78, 0.78 },
|
|
moneyCopper = { 0.71, 0.43, 0.18 },
|
|
arrivedText = { 0.40, 1.0, 0.40 },
|
|
})
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Layout
|
|
--------------------------------------------------------------------------------
|
|
local DEST_PANEL_W = 220
|
|
local DEST_ROW_H = 22
|
|
local HEADER_H = 34
|
|
local SIDE_PAD = 10
|
|
local MAX_DEST_ROWS = 30
|
|
|
|
local BAR_W = 160
|
|
local TRACK_H = 170
|
|
local TRACK_X = 20
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- State
|
|
--------------------------------------------------------------------------------
|
|
local skinApplied = false
|
|
local DestPanel = nil
|
|
local DestRows = {}
|
|
local FlightBar = nil
|
|
|
|
local flightState = {
|
|
pendingFlight = false,
|
|
inFlight = false,
|
|
source = "",
|
|
dest = "",
|
|
startTime = 0,
|
|
estimated = 0,
|
|
lingerTime = 0,
|
|
}
|
|
|
|
FM.currentSource = ""
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Helpers
|
|
--------------------------------------------------------------------------------
|
|
local function GetFont()
|
|
if SFrames and SFrames.GetFont then return SFrames:GetFont() end
|
|
return "Fonts\\ARIALN.TTF"
|
|
end
|
|
|
|
local function FormatMoney(copper)
|
|
if not copper or copper <= 0 then return 0, 0, 0 end
|
|
local g = math.floor(copper / 10000)
|
|
local s = math.floor(math.mod(copper, 10000) / 100)
|
|
local c = math.mod(copper, 100)
|
|
return g, s, c
|
|
end
|
|
|
|
local function FormatTime(seconds)
|
|
if not seconds or seconds < 0 then seconds = 0 end
|
|
local m = math.floor(seconds / 60)
|
|
local s = math.floor(math.mod(seconds, 60))
|
|
return string.format("%d:%02d", m, s)
|
|
end
|
|
|
|
local function StripTextures(frame)
|
|
if not frame or not frame.GetRegions then return end
|
|
local regions = { frame:GetRegions() }
|
|
for i = 1, table.getn(regions) do
|
|
local region = regions[i]
|
|
if region and region.SetTexture and not region._nanamiKeep then
|
|
local drawLayer = region.GetDrawLayer and region:GetDrawLayer()
|
|
if drawLayer == "BACKGROUND" or drawLayer == "BORDER" or drawLayer == "ARTWORK" then
|
|
region:SetTexture(nil)
|
|
region:SetAlpha(0)
|
|
region:Hide()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function CreateShadow(parent)
|
|
local s = CreateFrame("Frame", nil, parent)
|
|
s:SetPoint("TOPLEFT", parent, "TOPLEFT", -4, 4)
|
|
s:SetPoint("BOTTOMRIGHT", parent, "BOTTOMRIGHT", 4, -4)
|
|
s:SetBackdrop({
|
|
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
|
|
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
|
|
tile = true, tileSize = 16, edgeSize = 16,
|
|
insets = { left = 4, right = 4, top = 4, bottom = 4 },
|
|
})
|
|
s:SetBackdropColor(0, 0, 0, 0.45)
|
|
s:SetBackdropBorderColor(0, 0, 0, 0.6)
|
|
s:SetFrameLevel(math.max(0, parent:GetFrameLevel() - 1))
|
|
return s
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Flight Time Database (self-learning, stored in SFramesGlobalDB)
|
|
--------------------------------------------------------------------------------
|
|
local function GetFlightDB()
|
|
if not SFramesGlobalDB then SFramesGlobalDB = {} end
|
|
if not SFramesGlobalDB.flightTimes then SFramesGlobalDB.flightTimes = {} end
|
|
return SFramesGlobalDB.flightTimes
|
|
end
|
|
|
|
local function GetRouteKey(src, dst)
|
|
return (src or "") .. "->" .. (dst or "")
|
|
end
|
|
|
|
local function GetTaxiNodeHash(nodeIndex)
|
|
local x, y = TaxiNodePosition(nodeIndex)
|
|
if not x then return nil end
|
|
return tostring(math.floor(x * 100000000))
|
|
end
|
|
|
|
local function GetPlayerFaction()
|
|
local faction = UnitFactionGroup("player")
|
|
if faction == "Alliance" then return "Alliance" end
|
|
return "Horde"
|
|
end
|
|
|
|
-- Hash-based index built when taxi map opens: hash -> nodeIndex
|
|
local hashToIndex = {}
|
|
local indexToHash = {}
|
|
local hashCorrection = {} -- actualHash -> ftcHash (fuzzy match)
|
|
|
|
local function BuildHashIndex()
|
|
hashToIndex = {}
|
|
indexToHash = {}
|
|
hashCorrection = {}
|
|
local numNodes = NumTaxiNodes()
|
|
local faction = GetPlayerFaction()
|
|
local factionData = FTCData and FTCData[faction]
|
|
|
|
-- Collect all hashes used in FTCData for fuzzy matching
|
|
local ftcHashes = {}
|
|
if factionData then
|
|
for srcH, routes in pairs(factionData) do
|
|
ftcHashes[srcH] = true
|
|
for dstH in pairs(routes) do
|
|
ftcHashes[dstH] = true
|
|
end
|
|
end
|
|
end
|
|
|
|
for i = 1, numNodes do
|
|
local h = GetTaxiNodeHash(i)
|
|
if h then
|
|
hashToIndex[h] = i
|
|
indexToHash[i] = h
|
|
if ftcHashes[h] then
|
|
hashCorrection[h] = h
|
|
else
|
|
-- Turtle WoW coords may differ slightly from Classic; try ±10
|
|
local hNum = tonumber(h)
|
|
if hNum then
|
|
for delta = -10, 10 do
|
|
local candidate = tostring(hNum + delta)
|
|
if ftcHashes[candidate] then
|
|
hashCorrection[h] = candidate
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function LookupFTCData(srcHash, dstHash)
|
|
if not srcHash or not dstHash then return nil end
|
|
local faction = GetPlayerFaction()
|
|
-- Priority 1: self-learned hash DB (exact hash, no correction needed)
|
|
local hdb = SFramesGlobalDB and SFramesGlobalDB.flightTimesHash
|
|
if hdb and hdb[faction] then
|
|
local lr = hdb[faction][srcHash]
|
|
if lr and lr[dstHash] then return lr[dstHash] end
|
|
end
|
|
-- Priority 2: FTCData pre-recorded (with fuzzy hash correction)
|
|
if not FTCData then return nil end
|
|
local factionData = FTCData[faction]
|
|
if not factionData then return nil end
|
|
local corrSrc = hashCorrection[srcHash] or srcHash
|
|
local corrDst = hashCorrection[dstHash] or dstHash
|
|
local srcRoutes = factionData[corrSrc]
|
|
if not srcRoutes then return nil end
|
|
return srcRoutes[corrDst]
|
|
end
|
|
|
|
local function GetEstimatedTime(src, dst)
|
|
local routeKey = GetRouteKey(src, dst)
|
|
-- Priority 1: per-account learned database (SavedVariables)
|
|
local db = GetFlightDB()
|
|
local learned = db[routeKey]
|
|
if learned then return learned end
|
|
|
|
-- Priority 2: shared learned database (FlightData.lua, cross-account)
|
|
if NanamiLearnedFlights and NanamiLearnedFlights[routeKey] then
|
|
return NanamiLearnedFlights[routeKey]
|
|
end
|
|
|
|
-- Priority 3: FTCData pre-recorded database (by hash)
|
|
if FM.currentSourceHash and dst then
|
|
local numNodes = NumTaxiNodes()
|
|
for i = 1, numNodes do
|
|
if TaxiNodeName(i) == dst then
|
|
local dstHash = indexToHash[i] or GetTaxiNodeHash(i)
|
|
if dstHash then
|
|
local ftcTime = LookupFTCData(FM.currentSourceHash, dstHash)
|
|
if ftcTime then return ftcTime end
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
local function GetEstimatedTimeByHash(srcHash, dstHash)
|
|
-- Check learned DB by resolving hash to names
|
|
local srcIdx = hashToIndex[srcHash]
|
|
local dstIdx = hashToIndex[dstHash]
|
|
if srcIdx and dstIdx then
|
|
local db = GetFlightDB()
|
|
local learned = db[GetRouteKey(TaxiNodeName(srcIdx), TaxiNodeName(dstIdx))]
|
|
if learned then return learned end
|
|
end
|
|
return LookupFTCData(srcHash, dstHash)
|
|
end
|
|
|
|
local function GetFlightHashDB()
|
|
if not SFramesGlobalDB then SFramesGlobalDB = {} end
|
|
if not SFramesGlobalDB.flightTimesHash then SFramesGlobalDB.flightTimesHash = {} end
|
|
return SFramesGlobalDB.flightTimesHash
|
|
end
|
|
|
|
local function SaveFlightTime(src, dst, duration, srcHash, dstHash)
|
|
if not src or src == "" or not dst or dst == "" then return end
|
|
if duration < 5 then return end
|
|
local secs = math.floor(duration + 0.5)
|
|
local db = GetFlightDB()
|
|
db[GetRouteKey(src, dst)] = secs
|
|
-- Also save in hash format for cross-account export
|
|
if srcHash and dstHash then
|
|
local faction = GetPlayerFaction()
|
|
local hdb = GetFlightHashDB()
|
|
if not hdb[faction] then hdb[faction] = {} end
|
|
if not hdb[faction][srcHash] then hdb[faction][srcHash] = {} end
|
|
hdb[faction][srcHash][dstHash] = secs
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Money Layout (icon-based, like Merchant.lua)
|
|
--------------------------------------------------------------------------------
|
|
local function LayoutRowMoney(row, copper)
|
|
row.gTxt:Hide(); row.gTex:Hide()
|
|
row.sTxt:Hide(); row.sTex:Hide()
|
|
row.cTxt:Hide(); row.cTex:Hide()
|
|
|
|
if not copper or copper <= 0 then
|
|
row.gTxt:SetText("--")
|
|
row.gTxt:SetTextColor(T.dimText[1], T.dimText[2], T.dimText[3])
|
|
row.gTxt:ClearAllPoints()
|
|
row.gTxt:SetPoint("RIGHT", row, "RIGHT", -6, 0)
|
|
row.gTxt:Show()
|
|
return
|
|
end
|
|
|
|
local vG, vS, vC = FormatMoney(copper)
|
|
local anchor = nil
|
|
|
|
local function AttachPair(txt, tex, val, cr, cg, cb)
|
|
txt:SetText(val)
|
|
txt:SetTextColor(cr, cg, cb)
|
|
txt:ClearAllPoints()
|
|
if not anchor then
|
|
txt:SetPoint("RIGHT", row, "RIGHT", -6, 0)
|
|
else
|
|
txt:SetPoint("RIGHT", anchor, "LEFT", -3, 0)
|
|
end
|
|
txt:Show()
|
|
tex:ClearAllPoints()
|
|
tex:SetPoint("RIGHT", txt, "LEFT", -1, 0)
|
|
tex:Show()
|
|
anchor = tex
|
|
end
|
|
|
|
if vC > 0 then AttachPair(row.cTxt, row.cTex, vC, T.moneyCopper[1], T.moneyCopper[2], T.moneyCopper[3]) end
|
|
if vS > 0 then AttachPair(row.sTxt, row.sTex, vS, T.moneySilver[1], T.moneySilver[2], T.moneySilver[3]) end
|
|
if vG > 0 then AttachPair(row.gTxt, row.gTex, vG, T.moneyGold[1], T.moneyGold[2], T.moneyGold[3]) end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Destination Row Factory
|
|
--------------------------------------------------------------------------------
|
|
local function CreateDestRow(parent, index)
|
|
local row = CreateFrame("Button", "NanamiFlightDest" .. index, parent)
|
|
row:SetHeight(DEST_ROW_H)
|
|
|
|
local font = GetFont()
|
|
|
|
local dot = row:CreateTexture(nil, "ARTWORK")
|
|
dot:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
dot:SetWidth(6)
|
|
dot:SetHeight(6)
|
|
dot:SetPoint("LEFT", row, "LEFT", 6, 0)
|
|
row.dot = dot
|
|
|
|
local nameFS = row:CreateFontString(nil, "OVERLAY")
|
|
nameFS:SetFont(font, 10, "OUTLINE")
|
|
nameFS:SetPoint("LEFT", dot, "RIGHT", 5, 0)
|
|
nameFS:SetPoint("RIGHT", row, "RIGHT", -112, 0)
|
|
nameFS:SetJustifyH("LEFT")
|
|
row.nameFS = nameFS
|
|
|
|
local timeFS = row:CreateFontString(nil, "OVERLAY")
|
|
timeFS:SetFont(font, 9, "OUTLINE")
|
|
timeFS:SetPoint("RIGHT", row, "RIGHT", -78, 0)
|
|
timeFS:SetJustifyH("RIGHT")
|
|
timeFS:SetTextColor(T.dimText[1], T.dimText[2], T.dimText[3])
|
|
row.timeFS = timeFS
|
|
|
|
row.gTxt = row:CreateFontString(nil, "OVERLAY")
|
|
row.gTxt:SetFont(font, 9, "OUTLINE")
|
|
row.gTex = row:CreateTexture(nil, "ARTWORK")
|
|
row.gTex:SetTexture("Interface\\MoneyFrame\\UI-MoneyIcons")
|
|
row.gTex:SetTexCoord(0, 0.25, 0, 1)
|
|
row.gTex:SetWidth(10); row.gTex:SetHeight(10)
|
|
|
|
row.sTxt = row:CreateFontString(nil, "OVERLAY")
|
|
row.sTxt:SetFont(font, 9, "OUTLINE")
|
|
row.sTex = row:CreateTexture(nil, "ARTWORK")
|
|
row.sTex:SetTexture("Interface\\MoneyFrame\\UI-MoneyIcons")
|
|
row.sTex:SetTexCoord(0.25, 0.5, 0, 1)
|
|
row.sTex:SetWidth(10); row.sTex:SetHeight(10)
|
|
|
|
row.cTxt = row:CreateFontString(nil, "OVERLAY")
|
|
row.cTxt:SetFont(font, 9, "OUTLINE")
|
|
row.cTex = row:CreateTexture(nil, "ARTWORK")
|
|
row.cTex:SetTexture("Interface\\MoneyFrame\\UI-MoneyIcons")
|
|
row.cTex:SetTexCoord(0.5, 0.75, 0, 1)
|
|
row.cTex:SetWidth(10); row.cTex:SetHeight(10)
|
|
|
|
local hl = row:CreateTexture(nil, "HIGHLIGHT")
|
|
hl:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight")
|
|
hl:SetBlendMode("ADD")
|
|
hl:SetAllPoints(row)
|
|
hl:SetAlpha(0.15)
|
|
|
|
row.nodeIndex = nil
|
|
row.nodeType = nil
|
|
|
|
row:SetScript("OnEnter", function()
|
|
if this.nodeType == "REACHABLE" and this.nodeIndex then
|
|
GameTooltip:SetOwner(this, "ANCHOR_LEFT")
|
|
GameTooltip:AddLine(TaxiNodeName(this.nodeIndex), 1, 1, 1)
|
|
local cost = TaxiNodeCost(this.nodeIndex)
|
|
if cost and cost > 0 then
|
|
SetTooltipMoney(GameTooltip, cost)
|
|
end
|
|
local est = GetEstimatedTime(FM.currentSource, TaxiNodeName(this.nodeIndex))
|
|
if est then
|
|
GameTooltip:AddLine(" ")
|
|
GameTooltip:AddLine("预计飞行: " .. FormatTime(est), 0.6, 0.8, 1.0)
|
|
end
|
|
GameTooltip:AddLine(" ")
|
|
GameTooltip:AddLine("点击飞往此处", T.dimText[1], T.dimText[2], T.dimText[3])
|
|
GameTooltip:Show()
|
|
end
|
|
end)
|
|
|
|
row:SetScript("OnLeave", function()
|
|
GameTooltip:Hide()
|
|
end)
|
|
|
|
row:SetScript("OnClick", function()
|
|
if this.nodeType == "REACHABLE" and this.nodeIndex then
|
|
TakeTaxiNode(this.nodeIndex)
|
|
end
|
|
end)
|
|
|
|
return row
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Skin TaxiFrame
|
|
--------------------------------------------------------------------------------
|
|
function FM:ApplySkin()
|
|
if skinApplied then return end
|
|
if not TaxiFrame then return end
|
|
skinApplied = true
|
|
|
|
local font = GetFont()
|
|
|
|
StripTextures(TaxiFrame)
|
|
|
|
if TaxiPortrait then TaxiPortrait:Hide(); TaxiPortrait:SetAlpha(0) end
|
|
if TaxiTitleText then TaxiTitleText:Hide() end
|
|
|
|
local origClose = TaxiCloseButton
|
|
if origClose then
|
|
origClose:Hide()
|
|
origClose:SetAlpha(0)
|
|
origClose.Show = function() end
|
|
end
|
|
|
|
TaxiFrame:SetBackdrop({
|
|
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
|
|
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
|
|
tile = true, tileSize = 16, edgeSize = 14,
|
|
insets = { left = 3, right = 3, top = 3, bottom = 3 },
|
|
})
|
|
TaxiFrame:SetBackdropColor(T.panelBg[1], T.panelBg[2], T.panelBg[3], T.panelBg[4])
|
|
TaxiFrame:SetBackdropBorderColor(T.panelBorder[1], T.panelBorder[2], T.panelBorder[3], T.panelBorder[4])
|
|
|
|
CreateShadow(TaxiFrame)
|
|
|
|
-- Trim empty space at the bottom (TaxiMap anchored to top, safe to shrink from bottom)
|
|
if TaxiMap then
|
|
local mapBottom = TaxiMap:GetBottom()
|
|
local frameBottom = TaxiFrame:GetBottom()
|
|
if mapBottom and frameBottom and mapBottom > frameBottom then
|
|
local excess = mapBottom - frameBottom - 10
|
|
if excess > 10 then
|
|
TaxiFrame:SetHeight(TaxiFrame:GetHeight() - excess)
|
|
end
|
|
end
|
|
end
|
|
|
|
TaxiFrame:SetMovable(true)
|
|
TaxiFrame:EnableMouse(true)
|
|
TaxiFrame:RegisterForDrag("LeftButton")
|
|
TaxiFrame:SetScript("OnDragStart", function() this:StartMoving() end)
|
|
TaxiFrame:SetScript("OnDragStop", function() this:StopMovingOrSizing() end)
|
|
|
|
local header = CreateFrame("Frame", nil, TaxiFrame)
|
|
header:SetPoint("TOPLEFT", TaxiFrame, "TOPLEFT", 0, 0)
|
|
header:SetPoint("TOPRIGHT", TaxiFrame, "TOPRIGHT", 0, 0)
|
|
header:SetHeight(HEADER_H)
|
|
header:SetBackdrop({ bgFile = "Interface\\Buttons\\WHITE8X8" })
|
|
header:SetBackdropColor(T.headerBg[1], T.headerBg[2], T.headerBg[3], T.headerBg[4])
|
|
header:SetFrameLevel(TaxiFrame:GetFrameLevel() + 5)
|
|
|
|
local titleIco = SFrames:CreateIcon(header, "mount", 16)
|
|
titleIco:SetDrawLayer("OVERLAY")
|
|
titleIco:SetPoint("LEFT", header, "LEFT", SIDE_PAD, 0)
|
|
titleIco:SetVertexColor(T.gold[1], T.gold[2], T.gold[3])
|
|
|
|
local titleFS = header:CreateFontString(nil, "OVERLAY")
|
|
titleFS:SetFont(font, 14, "OUTLINE")
|
|
titleFS:SetPoint("LEFT", titleIco, "RIGHT", 5, 0)
|
|
titleFS:SetPoint("RIGHT", header, "RIGHT", -30, 0)
|
|
titleFS:SetJustifyH("LEFT")
|
|
titleFS:SetTextColor(T.gold[1], T.gold[2], T.gold[3])
|
|
FM.titleFS = titleFS
|
|
|
|
local closeBtn = CreateFrame("Button", nil, header)
|
|
closeBtn:SetWidth(20)
|
|
closeBtn:SetHeight(20)
|
|
closeBtn:SetPoint("RIGHT", header, "RIGHT", -8, 0)
|
|
closeBtn:SetFrameLevel(header:GetFrameLevel() + 1)
|
|
local closeTex = closeBtn:CreateTexture(nil, "ARTWORK")
|
|
closeTex:SetTexture("Interface\\AddOns\\Nanami-UI\\img\\icon")
|
|
closeTex:SetTexCoord(0.25, 0.375, 0, 0.125)
|
|
closeTex:SetAllPoints()
|
|
closeTex:SetVertexColor(T.dimText[1], T.dimText[2], T.dimText[3])
|
|
closeBtn:SetScript("OnClick", function() CloseTaxiMap() end)
|
|
closeBtn:SetScript("OnEnter", function() closeTex:SetVertexColor(1, 0.6, 0.7) end)
|
|
closeBtn:SetScript("OnLeave", function() closeTex:SetVertexColor(T.dimText[1], T.dimText[2], T.dimText[3]) end)
|
|
|
|
local headerSep = TaxiFrame:CreateTexture(nil, "OVERLAY")
|
|
headerSep:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
headerSep:SetHeight(1)
|
|
headerSep:SetPoint("TOPLEFT", TaxiFrame, "TOPLEFT", 4, -HEADER_H)
|
|
headerSep:SetPoint("TOPRIGHT", TaxiFrame, "TOPRIGHT", -4, -HEADER_H)
|
|
headerSep:SetVertexColor(T.divider[1], T.divider[2], T.divider[3], T.divider[4])
|
|
headerSep._nanamiKeep = true
|
|
|
|
if TaxiMap then
|
|
local mapBorder = CreateFrame("Frame", nil, TaxiFrame)
|
|
mapBorder:SetPoint("TOPLEFT", TaxiMap, "TOPLEFT", -3, 3)
|
|
mapBorder:SetPoint("BOTTOMRIGHT", TaxiMap, "BOTTOMRIGHT", 3, -3)
|
|
mapBorder:SetBackdrop({
|
|
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
|
|
edgeSize = 12,
|
|
insets = { left = 2, right = 2, top = 2, bottom = 2 },
|
|
})
|
|
mapBorder:SetBackdropBorderColor(T.panelBorder[1], T.panelBorder[2], T.panelBorder[3], T.panelBorder[4])
|
|
mapBorder:SetFrameLevel(TaxiFrame:GetFrameLevel() + 3)
|
|
end
|
|
|
|
FM:CreateDestPanel()
|
|
|
|
local origOnHide = TaxiFrame:GetScript("OnHide")
|
|
TaxiFrame:SetScript("OnHide", function()
|
|
if origOnHide then origOnHide() end
|
|
if DestPanel then DestPanel:Hide() end
|
|
end)
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Destination Panel
|
|
--------------------------------------------------------------------------------
|
|
function FM:CreateDestPanel()
|
|
local font = GetFont()
|
|
|
|
DestPanel = CreateFrame("Frame", "NanamiFlightDestPanel", UIParent)
|
|
DestPanel:SetWidth(DEST_PANEL_W)
|
|
DestPanel:SetPoint("TOPLEFT", TaxiFrame, "TOPRIGHT", 4, 0)
|
|
DestPanel:SetPoint("BOTTOMLEFT", TaxiFrame, "BOTTOMRIGHT", 4, 0)
|
|
DestPanel:SetFrameStrata(TaxiFrame:GetFrameStrata())
|
|
DestPanel:SetFrameLevel(TaxiFrame:GetFrameLevel() + 1)
|
|
DestPanel:SetBackdrop({
|
|
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
|
|
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
|
|
tile = true, tileSize = 16, edgeSize = 14,
|
|
insets = { left = 3, right = 3, top = 3, bottom = 3 },
|
|
})
|
|
DestPanel:SetBackdropColor(T.listBg[1], T.listBg[2], T.listBg[3], T.listBg[4])
|
|
DestPanel:SetBackdropBorderColor(T.listBorder[1], T.listBorder[2], T.listBorder[3], T.listBorder[4])
|
|
|
|
CreateShadow(DestPanel)
|
|
|
|
local panelTitle = DestPanel:CreateFontString(nil, "OVERLAY")
|
|
panelTitle:SetFont(font, 12, "OUTLINE")
|
|
panelTitle:SetPoint("TOP", DestPanel, "TOP", 0, -8)
|
|
panelTitle:SetTextColor(T.gold[1], T.gold[2], T.gold[3])
|
|
panelTitle:SetText("目的地列表")
|
|
|
|
FM.currentLabel = DestPanel:CreateFontString(nil, "OVERLAY")
|
|
FM.currentLabel:SetFont(font, 10, "OUTLINE")
|
|
FM.currentLabel:SetPoint("TOPLEFT", DestPanel, "TOPLEFT", 8, -28)
|
|
FM.currentLabel:SetPoint("RIGHT", DestPanel, "RIGHT", -8, 0)
|
|
FM.currentLabel:SetJustifyH("LEFT")
|
|
FM.currentLabel:SetTextColor(T.currentText[1], T.currentText[2], T.currentText[3])
|
|
|
|
local sepLine = DestPanel:CreateTexture(nil, "OVERLAY")
|
|
sepLine:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
sepLine:SetHeight(1)
|
|
sepLine:SetPoint("TOPLEFT", DestPanel, "TOPLEFT", 8, -46)
|
|
sepLine:SetPoint("TOPRIGHT", DestPanel, "TOPRIGHT", -8, -46)
|
|
sepLine:SetVertexColor(T.divider[1], T.divider[2], T.divider[3], T.divider[4])
|
|
|
|
FM.noDestLabel = DestPanel:CreateFontString(nil, "OVERLAY")
|
|
FM.noDestLabel:SetFont(font, 10, "OUTLINE")
|
|
FM.noDestLabel:SetPoint("TOP", DestPanel, "TOP", 0, -60)
|
|
FM.noDestLabel:SetTextColor(T.dimText[1], T.dimText[2], T.dimText[3])
|
|
FM.noDestLabel:SetText("暂无可用航线")
|
|
FM.noDestLabel:Hide()
|
|
|
|
local scrollFrame = CreateFrame("ScrollFrame", "NanamiFlightDestScroll", DestPanel, "UIPanelScrollFrameTemplate")
|
|
scrollFrame:SetPoint("TOPLEFT", DestPanel, "TOPLEFT", 2, -50)
|
|
scrollFrame:SetPoint("BOTTOMRIGHT", DestPanel, "BOTTOMRIGHT", -20, 6)
|
|
|
|
local scrollChild = CreateFrame("Frame", "NanamiFlightDestScrollChild", scrollFrame)
|
|
scrollChild:SetWidth(DEST_PANEL_W - 24)
|
|
scrollChild:SetHeight(MAX_DEST_ROWS * DEST_ROW_H + 20)
|
|
scrollFrame:SetScrollChild(scrollChild)
|
|
|
|
local scrollBar = getglobal("NanamiFlightDestScrollScrollBar")
|
|
if scrollBar then
|
|
scrollBar:SetWidth(12)
|
|
local regions = { scrollBar:GetRegions() }
|
|
for i = 1, table.getn(regions) do
|
|
local region = regions[i]
|
|
if region and region.GetObjectType and region:GetObjectType() == "Texture" then
|
|
region:SetTexture(nil)
|
|
region:SetAlpha(0)
|
|
end
|
|
end
|
|
local thumb = scrollBar:GetThumbTexture()
|
|
if thumb then
|
|
thumb:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
thumb:SetVertexColor(T.divider[1], T.divider[2], T.divider[3], 0.6)
|
|
thumb:SetWidth(10)
|
|
thumb:SetHeight(40)
|
|
end
|
|
end
|
|
local scrollUp = getglobal("NanamiFlightDestScrollScrollBarScrollUpButton")
|
|
if scrollUp then scrollUp:SetAlpha(0); scrollUp:SetWidth(1); scrollUp:SetHeight(1) end
|
|
local scrollDown = getglobal("NanamiFlightDestScrollScrollBarScrollDownButton")
|
|
if scrollDown then scrollDown:SetAlpha(0); scrollDown:SetWidth(1); scrollDown:SetHeight(1) end
|
|
|
|
for i = 1, MAX_DEST_ROWS do
|
|
local row = CreateDestRow(scrollChild, i)
|
|
row:SetPoint("TOPLEFT", scrollChild, "TOPLEFT", 0, -((i - 1) * DEST_ROW_H))
|
|
row:SetPoint("RIGHT", scrollChild, "RIGHT", 0, 0)
|
|
row:Hide()
|
|
DestRows[i] = row
|
|
end
|
|
|
|
DestPanel:Hide()
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Update Destinations
|
|
--------------------------------------------------------------------------------
|
|
function FM:UpdateDestinations()
|
|
if not DestPanel then return end
|
|
|
|
local numNodes = NumTaxiNodes()
|
|
local currentName = ""
|
|
local reachable = {}
|
|
local unreachableCount = 0
|
|
|
|
for i = 1, numNodes do
|
|
local name = TaxiNodeName(i)
|
|
local ntype = TaxiNodeGetType(i)
|
|
local cost = TaxiNodeCost(i)
|
|
|
|
if ntype == "CURRENT" then
|
|
currentName = name
|
|
elseif ntype == "REACHABLE" then
|
|
table.insert(reachable, { index = i, name = name, cost = cost })
|
|
elseif ntype == "NONE" then
|
|
unreachableCount = unreachableCount + 1
|
|
end
|
|
end
|
|
|
|
FM.currentSource = currentName
|
|
|
|
-- Build hash index for FTCData lookup
|
|
BuildHashIndex()
|
|
FM.currentSourceHash = nil
|
|
for i = 1, numNodes do
|
|
if TaxiNodeGetType(i) == "CURRENT" then
|
|
FM.currentSourceHash = indexToHash[i] or GetTaxiNodeHash(i)
|
|
break
|
|
end
|
|
end
|
|
|
|
table.sort(reachable, function(a, b) return a.cost < b.cost end)
|
|
|
|
local npcName = UnitName("NPC") or "飞行管理员"
|
|
FM.titleFS:SetText(npcName .. " - 飞行路线")
|
|
|
|
if currentName ~= "" then
|
|
FM.currentLabel:SetText("|cFF66E666*|r " .. currentName)
|
|
else
|
|
FM.currentLabel:SetText("|cFF66E666*|r 未知")
|
|
end
|
|
|
|
local rowIdx = 0
|
|
|
|
for _, dest in ipairs(reachable) do
|
|
rowIdx = rowIdx + 1
|
|
if rowIdx <= MAX_DEST_ROWS then
|
|
local row = DestRows[rowIdx]
|
|
row.nodeIndex = dest.index
|
|
row.nodeType = "REACHABLE"
|
|
row.dot:SetVertexColor(T.nameText[1], T.nameText[2], T.nameText[3])
|
|
row.nameFS:SetText(dest.name)
|
|
row.nameFS:SetTextColor(T.nameText[1], T.nameText[2], T.nameText[3])
|
|
LayoutRowMoney(row, dest.cost)
|
|
local est = GetEstimatedTime(currentName, dest.name)
|
|
if not est and FM.currentSourceHash then
|
|
local dstHash = indexToHash[dest.index] or GetTaxiNodeHash(dest.index)
|
|
if dstHash then est = LookupFTCData(FM.currentSourceHash, dstHash) end
|
|
end
|
|
if est then
|
|
row.timeFS:SetText(FormatTime(est))
|
|
row.timeFS:Show()
|
|
else
|
|
row.timeFS:SetText("")
|
|
row.timeFS:Hide()
|
|
end
|
|
row:Show()
|
|
end
|
|
end
|
|
|
|
if unreachableCount > 0 then
|
|
rowIdx = rowIdx + 1
|
|
if rowIdx <= MAX_DEST_ROWS then
|
|
local row = DestRows[rowIdx]
|
|
row.nodeIndex = nil
|
|
row.nodeType = "NONE"
|
|
row.dot:SetVertexColor(T.dimText[1], T.dimText[2], T.dimText[3])
|
|
row.nameFS:SetText("(" .. unreachableCount .. " 个未发现)")
|
|
row.nameFS:SetTextColor(T.dimText[1], T.dimText[2], T.dimText[3])
|
|
row.gTxt:Hide(); row.gTex:Hide()
|
|
row.sTxt:Hide(); row.sTex:Hide()
|
|
row.cTxt:Hide(); row.cTex:Hide()
|
|
row.timeFS:SetText(""); row.timeFS:Hide()
|
|
row:Show()
|
|
end
|
|
end
|
|
|
|
for i = rowIdx + 1, MAX_DEST_ROWS do
|
|
DestRows[i]:Hide()
|
|
end
|
|
|
|
if rowIdx == 0 then
|
|
FM.noDestLabel:Show()
|
|
else
|
|
FM.noDestLabel:Hide()
|
|
end
|
|
|
|
local child = getglobal("NanamiFlightDestScrollChild")
|
|
if child then
|
|
child:SetHeight(math.max(rowIdx * DEST_ROW_H + 10, 50))
|
|
end
|
|
|
|
DestPanel:Show()
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Hook Node Buttons (tooltip only)
|
|
--------------------------------------------------------------------------------
|
|
function FM:HookNodeButtons()
|
|
local numNodes = NumTaxiNodes()
|
|
for i = 1, numNodes do
|
|
local btn = getglobal("TaxiButton" .. i)
|
|
if btn and not btn._nanamiHooked then
|
|
btn._nanamiHooked = true
|
|
|
|
local origEnter = btn:GetScript("OnEnter")
|
|
btn:SetScript("OnEnter", function()
|
|
if origEnter then origEnter() end
|
|
local id = this:GetID()
|
|
if TaxiNodeGetType(id) == "REACHABLE" then
|
|
local cost = TaxiNodeCost(id)
|
|
if cost and cost > 0 then
|
|
GameTooltip:AddLine(" ")
|
|
SetTooltipMoney(GameTooltip, cost)
|
|
end
|
|
local est = GetEstimatedTime(FM.currentSource, TaxiNodeName(id))
|
|
if est then
|
|
GameTooltip:AddLine("预计飞行: " .. FormatTime(est), 0.6, 0.8, 1.0)
|
|
end
|
|
GameTooltip:Show()
|
|
end
|
|
for _, row in ipairs(DestRows) do
|
|
if row:IsShown() and row.nodeIndex == id then
|
|
row.nameFS:SetTextColor(T.gold[1], T.gold[2], T.gold[3])
|
|
end
|
|
end
|
|
end)
|
|
|
|
local origLeave = btn:GetScript("OnLeave")
|
|
btn:SetScript("OnLeave", function()
|
|
if origLeave then origLeave() end
|
|
for _, row in ipairs(DestRows) do
|
|
if row:IsShown() and row.nodeType == "REACHABLE" then
|
|
row.nameFS:SetTextColor(T.nameText[1], T.nameText[2], T.nameText[3])
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Flight Progress Bar (vertical axis: departure → destination with countdown)
|
|
--------------------------------------------------------------------------------
|
|
local COLLAPSED_H = 34
|
|
local barCollapsed = false
|
|
|
|
local function SetBarCollapsed(collapsed)
|
|
barCollapsed = collapsed
|
|
if not FlightBar then return end
|
|
local bar = FlightBar
|
|
if collapsed then
|
|
bar:SetHeight(COLLAPSED_H)
|
|
for _, el in ipairs(bar.expandElements) do el:Hide() end
|
|
bar.collapseBtn.label:SetText("+")
|
|
-- Vertically center all visible elements
|
|
bar.titleFS:ClearAllPoints()
|
|
bar.titleFS:SetPoint("LEFT", bar, "LEFT", 10, 0)
|
|
bar.compactFS:ClearAllPoints()
|
|
bar.compactFS:SetPoint("RIGHT", bar, "RIGHT", -28, 0)
|
|
bar.collapseBtn:ClearAllPoints()
|
|
bar.collapseBtn:SetPoint("RIGHT", bar, "RIGHT", -6, 0)
|
|
bar.compactFS:Show()
|
|
else
|
|
bar:SetHeight(bar.expandedH)
|
|
for _, el in ipairs(bar.expandElements) do el:Show() end
|
|
bar.collapseBtn.label:SetText("-")
|
|
-- Restore top-aligned positions
|
|
bar.titleFS:ClearAllPoints()
|
|
bar.titleFS:SetPoint("TOPLEFT", bar, "TOPLEFT", 10, -8)
|
|
bar.compactFS:ClearAllPoints()
|
|
bar.compactFS:SetPoint("RIGHT", bar, "RIGHT", -28, -9)
|
|
bar.collapseBtn:ClearAllPoints()
|
|
bar.collapseBtn:SetPoint("TOPRIGHT", bar, "TOPRIGHT", -6, -6)
|
|
bar.compactFS:Hide()
|
|
end
|
|
end
|
|
|
|
local function CreateFlightBar()
|
|
if FlightBar then return end
|
|
|
|
local font = GetFont()
|
|
local panelH = 8 + 18 + 6 + 12 + 6 + TRACK_H + 6 + 12 + 10 + 14 + 4 + 14 + 4 + 14 + 10
|
|
|
|
local bar = CreateFrame("Frame", "NanamiFlightBar", UIParent)
|
|
bar:SetWidth(BAR_W)
|
|
bar:SetHeight(panelH)
|
|
bar.expandedH = panelH
|
|
bar:SetPoint("TOPRIGHT", UIParent, "TOPRIGHT", -80, -300)
|
|
bar:SetFrameStrata("HIGH")
|
|
bar:SetMovable(true)
|
|
bar:EnableMouse(true)
|
|
bar:RegisterForDrag("LeftButton")
|
|
bar:SetScript("OnDragStart", function() this:StartMoving() end)
|
|
bar:SetScript("OnDragStop", function() this:StopMovingOrSizing() end)
|
|
bar:SetBackdrop({
|
|
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
|
|
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
|
|
tile = true, tileSize = 16, edgeSize = 14,
|
|
insets = { left = 3, right = 3, top = 3, bottom = 3 },
|
|
})
|
|
bar:SetBackdropColor(T.panelBg[1], T.panelBg[2], T.panelBg[3], T.panelBg[4])
|
|
bar:SetBackdropBorderColor(T.panelBorder[1], T.panelBorder[2], T.panelBorder[3], T.panelBorder[4])
|
|
CreateShadow(bar)
|
|
|
|
bar.expandElements = {}
|
|
local yOff = -8
|
|
|
|
-- Title (always visible)
|
|
bar.titleFS = bar:CreateFontString(nil, "OVERLAY")
|
|
bar.titleFS:SetFont(font, 13, "OUTLINE")
|
|
bar.titleFS:SetPoint("TOPLEFT", bar, "TOPLEFT", 10, yOff)
|
|
bar.titleFS:SetTextColor(T.gold[1], T.gold[2], T.gold[3])
|
|
bar.titleFS:SetText("飞行中...")
|
|
|
|
-- Compact remaining time (shown only when collapsed, next to title)
|
|
bar.compactFS = bar:CreateFontString(nil, "OVERLAY")
|
|
bar.compactFS:SetFont(font, 13, "OUTLINE")
|
|
bar.compactFS:SetPoint("RIGHT", bar, "RIGHT", -28, yOff - 1)
|
|
bar.compactFS:SetJustifyH("RIGHT")
|
|
bar.compactFS:SetTextColor(T.gold[1], T.gold[2], T.gold[3])
|
|
bar.compactFS:Hide()
|
|
|
|
-- Collapse / expand button
|
|
local colBtn = CreateFrame("Button", nil, bar)
|
|
colBtn:SetWidth(18)
|
|
colBtn:SetHeight(18)
|
|
colBtn:SetPoint("TOPRIGHT", bar, "TOPRIGHT", -6, -6)
|
|
colBtn:SetFrameLevel(bar:GetFrameLevel() + 3)
|
|
local colLabel = colBtn:CreateFontString(nil, "OVERLAY")
|
|
colLabel:SetFont(font, 14, "OUTLINE")
|
|
colLabel:SetPoint("CENTER", 0, 1)
|
|
colLabel:SetTextColor(T.dimText[1], T.dimText[2], T.dimText[3])
|
|
colLabel:SetText("-")
|
|
colBtn.label = colLabel
|
|
colBtn:SetScript("OnClick", function()
|
|
SetBarCollapsed(not barCollapsed)
|
|
end)
|
|
colBtn:SetScript("OnEnter", function()
|
|
colLabel:SetTextColor(1, 0.7, 0.85)
|
|
end)
|
|
colBtn:SetScript("OnLeave", function()
|
|
colLabel:SetTextColor(T.dimText[1], T.dimText[2], T.dimText[3])
|
|
end)
|
|
bar.collapseBtn = colBtn
|
|
|
|
yOff = yOff - 18
|
|
|
|
-- Separator
|
|
local sep1 = bar:CreateTexture(nil, "OVERLAY")
|
|
sep1:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
sep1:SetHeight(1)
|
|
sep1:SetPoint("TOPLEFT", bar, "TOPLEFT", 8, yOff - 2)
|
|
sep1:SetPoint("TOPRIGHT", bar, "TOPRIGHT", -8, yOff - 2)
|
|
sep1:SetVertexColor(T.divider[1], T.divider[2], T.divider[3], T.divider[4])
|
|
table.insert(bar.expandElements, sep1)
|
|
yOff = yOff - 6
|
|
|
|
-- Source dot + name
|
|
local srcDot = bar:CreateTexture(nil, "OVERLAY")
|
|
srcDot:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
srcDot:SetWidth(9)
|
|
srcDot:SetHeight(9)
|
|
srcDot:SetPoint("TOPLEFT", bar, "TOPLEFT", TRACK_X, yOff)
|
|
srcDot:SetVertexColor(T.currentText[1], T.currentText[2], T.currentText[3])
|
|
bar.srcDot = srcDot
|
|
table.insert(bar.expandElements, srcDot)
|
|
|
|
bar.srcNameFS = bar:CreateFontString(nil, "OVERLAY")
|
|
bar.srcNameFS:SetFont(font, 10, "OUTLINE")
|
|
bar.srcNameFS:SetPoint("LEFT", srcDot, "RIGHT", 6, 0)
|
|
bar.srcNameFS:SetPoint("RIGHT", bar, "RIGHT", -8, 0)
|
|
bar.srcNameFS:SetJustifyH("LEFT")
|
|
bar.srcNameFS:SetTextColor(T.currentText[1], T.currentText[2], T.currentText[3])
|
|
table.insert(bar.expandElements, bar.srcNameFS)
|
|
|
|
yOff = yOff - 14
|
|
|
|
-- Vertical track area
|
|
local trackTop = yOff
|
|
local trackBg = bar:CreateTexture(nil, "BACKGROUND")
|
|
trackBg:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
trackBg:SetWidth(3)
|
|
trackBg:SetHeight(TRACK_H)
|
|
trackBg:SetPoint("TOPLEFT", bar, "TOPLEFT", TRACK_X + 3, trackTop)
|
|
trackBg:SetVertexColor(T.sectionBg[1], T.sectionBg[2], T.sectionBg[3], T.sectionBg[4])
|
|
bar.trackBg = trackBg
|
|
table.insert(bar.expandElements, trackBg)
|
|
|
|
-- Track fill (grows from top downward)
|
|
local trackFillFrame = CreateFrame("Frame", nil, bar)
|
|
trackFillFrame:SetPoint("TOPLEFT", trackBg, "TOPLEFT", 0, 0)
|
|
trackFillFrame:SetWidth(3)
|
|
trackFillFrame:SetHeight(1)
|
|
local trackFill = trackFillFrame:CreateTexture(nil, "ARTWORK")
|
|
trackFill:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
trackFill:SetAllPoints(trackFillFrame)
|
|
trackFill:SetVertexColor(T.progressFill[1], T.progressFill[2], T.progressFill[3], T.progressFill[4])
|
|
bar.trackFillFrame = trackFillFrame
|
|
bar.trackFill = trackFill
|
|
table.insert(bar.expandElements, trackFillFrame)
|
|
|
|
-- Progress indicator
|
|
local progDot = bar:CreateTexture(nil, "OVERLAY")
|
|
progDot:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
progDot:SetWidth(13)
|
|
progDot:SetHeight(5)
|
|
progDot:SetPoint("CENTER", trackBg, "TOP", 0, 0)
|
|
progDot:SetVertexColor(T.accent[1], T.accent[2], T.accent[3], T.accent[4])
|
|
bar.progDot = progDot
|
|
table.insert(bar.expandElements, progDot)
|
|
|
|
-- Progress glow
|
|
local progGlow = bar:CreateTexture(nil, "ARTWORK")
|
|
progGlow:SetTexture("Interface\\Buttons\\UI-ActionButton-Border")
|
|
progGlow:SetBlendMode("ADD")
|
|
progGlow:SetWidth(28)
|
|
progGlow:SetHeight(28)
|
|
progGlow:SetPoint("CENTER", progDot, "CENTER", 0, 0)
|
|
progGlow:SetVertexColor(T.progressFill[1], T.progressFill[2], T.progressFill[3], 0.4)
|
|
bar.progGlow = progGlow
|
|
table.insert(bar.expandElements, progGlow)
|
|
|
|
-- Elapsed time
|
|
bar.elapsedFS = bar:CreateFontString(nil, "OVERLAY")
|
|
bar.elapsedFS:SetFont(font, 11, "OUTLINE")
|
|
bar.elapsedFS:SetPoint("LEFT", trackBg, "RIGHT", 12, 0)
|
|
bar.elapsedFS:SetTextColor(T.bodyText[1], T.bodyText[2], T.bodyText[3])
|
|
table.insert(bar.expandElements, bar.elapsedFS)
|
|
|
|
-- Remaining time (follows progress dot)
|
|
bar.remainFS = bar:CreateFontString(nil, "OVERLAY")
|
|
bar.remainFS:SetFont(font, 14, "OUTLINE")
|
|
bar.remainFS:SetPoint("LEFT", progDot, "RIGHT", 10, 0)
|
|
bar.remainFS:SetTextColor(T.gold[1], T.gold[2], T.gold[3])
|
|
table.insert(bar.expandElements, bar.remainFS)
|
|
|
|
yOff = trackTop - TRACK_H
|
|
|
|
-- Destination dot + name
|
|
local dstDot = bar:CreateTexture(nil, "OVERLAY")
|
|
dstDot:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
dstDot:SetWidth(9)
|
|
dstDot:SetHeight(9)
|
|
dstDot:SetPoint("TOPLEFT", bar, "TOPLEFT", TRACK_X, yOff - 4)
|
|
dstDot:SetVertexColor(T.nameText[1], T.nameText[2], T.nameText[3])
|
|
bar.dstDot = dstDot
|
|
table.insert(bar.expandElements, dstDot)
|
|
|
|
bar.dstNameFS = bar:CreateFontString(nil, "OVERLAY")
|
|
bar.dstNameFS:SetFont(font, 10, "OUTLINE")
|
|
bar.dstNameFS:SetPoint("LEFT", dstDot, "RIGHT", 6, 0)
|
|
bar.dstNameFS:SetPoint("RIGHT", bar, "RIGHT", -8, 0)
|
|
bar.dstNameFS:SetJustifyH("LEFT")
|
|
bar.dstNameFS:SetTextColor(T.nameText[1], T.nameText[2], T.nameText[3])
|
|
table.insert(bar.expandElements, bar.dstNameFS)
|
|
|
|
yOff = yOff - 18
|
|
|
|
-- Bottom info
|
|
local sep2 = bar:CreateTexture(nil, "OVERLAY")
|
|
sep2:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
sep2:SetHeight(1)
|
|
sep2:SetPoint("TOPLEFT", bar, "TOPLEFT", 8, yOff)
|
|
sep2:SetPoint("TOPRIGHT", bar, "TOPRIGHT", -8, yOff)
|
|
sep2:SetVertexColor(T.divider[1], T.divider[2], T.divider[3], T.divider[4])
|
|
table.insert(bar.expandElements, sep2)
|
|
|
|
yOff = yOff - 6
|
|
|
|
bar.totalFS = bar:CreateFontString(nil, "OVERLAY")
|
|
bar.totalFS:SetFont(font, 10, "OUTLINE")
|
|
bar.totalFS:SetPoint("TOPLEFT", bar, "TOPLEFT", 12, yOff)
|
|
bar.totalFS:SetTextColor(T.dimText[1], T.dimText[2], T.dimText[3])
|
|
table.insert(bar.expandElements, bar.totalFS)
|
|
|
|
bar:Hide()
|
|
FlightBar = bar
|
|
end
|
|
|
|
local function ShowFlightBar()
|
|
CreateFlightBar()
|
|
local bar = FlightBar
|
|
|
|
bar.srcNameFS:SetText(flightState.source)
|
|
bar.dstNameFS:SetText(flightState.dest)
|
|
|
|
if flightState.estimated > 0 then
|
|
bar.totalFS:SetText("预计: " .. FormatTime(flightState.estimated))
|
|
else
|
|
bar.totalFS:SetText("首次飞行 - 记录中...")
|
|
end
|
|
|
|
bar.titleFS:SetText("飞行中...")
|
|
bar.titleFS:SetTextColor(T.gold[1], T.gold[2], T.gold[3])
|
|
bar:SetAlpha(1)
|
|
bar.compactFS:SetText("")
|
|
|
|
-- Reset track fill
|
|
bar.trackFillFrame:SetHeight(1)
|
|
bar.progDot:ClearAllPoints()
|
|
bar.progDot:SetPoint("CENTER", bar.trackBg, "TOP", 0, 0)
|
|
bar.progGlow:ClearAllPoints()
|
|
bar.progGlow:SetPoint("CENTER", bar.progDot, "CENTER", 0, 0)
|
|
bar.elapsedFS:SetText("0:00")
|
|
bar.remainFS:SetText("")
|
|
|
|
-- Restore collapse state
|
|
SetBarCollapsed(barCollapsed)
|
|
|
|
bar:Show()
|
|
end
|
|
|
|
local function UpdateFlightBar()
|
|
if not FlightBar or not FlightBar:IsShown() then return end
|
|
local bar = FlightBar
|
|
|
|
local elapsed = GetTime() - flightState.startTime
|
|
local estimated = flightState.estimated
|
|
local progress = 0
|
|
local compactText = FormatTime(elapsed)
|
|
|
|
if estimated > 0 then
|
|
progress = math.min(1, elapsed / estimated)
|
|
local remain = math.max(0, estimated - elapsed)
|
|
bar.remainFS:SetText(FormatTime(remain))
|
|
compactText = FormatTime(remain)
|
|
if remain <= 0 then
|
|
bar.remainFS:SetText("即将到达")
|
|
bar.remainFS:SetTextColor(T.arrivedText[1], T.arrivedText[2], T.arrivedText[3])
|
|
compactText = "即将到达"
|
|
else
|
|
bar.remainFS:SetTextColor(T.gold[1], T.gold[2], T.gold[3])
|
|
end
|
|
else
|
|
bar.remainFS:SetText("记录中...")
|
|
bar.remainFS:SetTextColor(T.dimText[1], T.dimText[2], T.dimText[3])
|
|
progress = math.mod(elapsed / 10, 1) * 0.8
|
|
end
|
|
|
|
bar.compactFS:SetText(compactText)
|
|
bar.elapsedFS:SetText("已飞行 " .. FormatTime(elapsed))
|
|
|
|
if not barCollapsed then
|
|
local fillH = math.max(1, progress * TRACK_H)
|
|
bar.trackFillFrame:SetHeight(fillH)
|
|
bar.progDot:ClearAllPoints()
|
|
bar.progDot:SetPoint("CENTER", bar.trackBg, "TOP", 0, -fillH)
|
|
bar.progGlow:ClearAllPoints()
|
|
bar.progGlow:SetPoint("CENTER", bar.progDot, "CENTER", 0, 0)
|
|
end
|
|
end
|
|
|
|
local function OnFlightArrived()
|
|
if not FlightBar then return end
|
|
local bar = FlightBar
|
|
|
|
local elapsed = GetTime() - flightState.startTime
|
|
SaveFlightTime(flightState.source, flightState.dest, elapsed, flightState.srcHash, flightState.dstHash)
|
|
|
|
bar.titleFS:SetText("已到达!")
|
|
bar.titleFS:SetTextColor(T.arrivedText[1], T.arrivedText[2], T.arrivedText[3])
|
|
bar.remainFS:SetText("")
|
|
bar.elapsedFS:SetText("飞行用时 " .. FormatTime(elapsed))
|
|
bar.totalFS:SetText("")
|
|
|
|
-- Fill track to 100%
|
|
bar.trackFillFrame:SetHeight(TRACK_H)
|
|
bar.progDot:ClearAllPoints()
|
|
bar.progDot:SetPoint("CENTER", bar.trackBg, "BOTTOM", 0, 0)
|
|
bar.progGlow:ClearAllPoints()
|
|
bar.progGlow:SetPoint("CENTER", bar.progDot, "CENTER", 0, 0)
|
|
bar.progDot:SetVertexColor(T.arrivedText[1], T.arrivedText[2], T.arrivedText[3])
|
|
|
|
flightState.lingerTime = 4
|
|
end
|
|
|
|
local function HideFlightBar()
|
|
if FlightBar then
|
|
FlightBar:Hide()
|
|
FlightBar.progDot:SetVertexColor(T.accent[1], T.accent[2], T.accent[3], T.accent[4])
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Initialize
|
|
--------------------------------------------------------------------------------
|
|
function FM:Initialize()
|
|
-- TaxiMap skin updater
|
|
local updater = CreateFrame("Frame")
|
|
updater:RegisterEvent("TAXIMAP_OPENED")
|
|
updater.needsUpdate = false
|
|
|
|
updater:SetScript("OnEvent", function()
|
|
if event == "TAXIMAP_OPENED" then
|
|
this.needsUpdate = true
|
|
end
|
|
end)
|
|
|
|
updater:SetScript("OnUpdate", function()
|
|
if this.needsUpdate then
|
|
this.needsUpdate = false
|
|
FM:ApplySkin()
|
|
FM:UpdateDestinations()
|
|
FM:HookNodeButtons()
|
|
end
|
|
end)
|
|
|
|
-- Hook TakeTaxiNode to capture route info before flight starts
|
|
local origTakeTaxiNode = TakeTaxiNode
|
|
TakeTaxiNode = function(index)
|
|
local numNodes = NumTaxiNodes()
|
|
local srcName = ""
|
|
local srcHash = nil
|
|
for i = 1, numNodes do
|
|
if TaxiNodeGetType(i) == "CURRENT" then
|
|
srcName = TaxiNodeName(i)
|
|
srcHash = indexToHash[i] or GetTaxiNodeHash(i)
|
|
break
|
|
end
|
|
end
|
|
local dstName = TaxiNodeName(index) or ""
|
|
local dstHash = indexToHash[index] or GetTaxiNodeHash(index)
|
|
|
|
flightState.source = srcName
|
|
flightState.dest = dstName
|
|
flightState.srcHash = srcHash
|
|
flightState.dstHash = dstHash
|
|
flightState.pendingFlight = true
|
|
flightState.inFlight = false
|
|
flightState.lingerTime = 0
|
|
|
|
-- Lookup estimated time: learned DB first, then FTCData
|
|
local est = GetEstimatedTime(srcName, dstName)
|
|
if not est and srcHash and dstHash then
|
|
est = LookupFTCData(srcHash, dstHash)
|
|
end
|
|
flightState.estimated = est or 0
|
|
|
|
origTakeTaxiNode(index)
|
|
end
|
|
|
|
-- Flight state monitor
|
|
local monitor = CreateFrame("Frame")
|
|
monitor:SetScript("OnUpdate", function()
|
|
local dt = arg1 or 0
|
|
local onTaxi = UnitOnTaxi("player")
|
|
|
|
if flightState.pendingFlight and onTaxi then
|
|
flightState.pendingFlight = false
|
|
flightState.inFlight = true
|
|
flightState.startTime = GetTime()
|
|
ShowFlightBar()
|
|
end
|
|
|
|
if flightState.inFlight then
|
|
if not onTaxi then
|
|
flightState.inFlight = false
|
|
OnFlightArrived()
|
|
else
|
|
UpdateFlightBar()
|
|
end
|
|
end
|
|
|
|
-- Linger after arrival then hide
|
|
if flightState.lingerTime > 0 then
|
|
flightState.lingerTime = flightState.lingerTime - dt
|
|
if flightState.lingerTime <= 1 and FlightBar then
|
|
FlightBar:SetAlpha(math.max(0, flightState.lingerTime))
|
|
end
|
|
if flightState.lingerTime <= 0 then
|
|
flightState.lingerTime = 0
|
|
HideFlightBar()
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Bootstrap
|
|
--------------------------------------------------------------------------------
|
|
local bootstrap = CreateFrame("Frame")
|
|
bootstrap:RegisterEvent("PLAYER_LOGIN")
|
|
bootstrap:SetScript("OnEvent", function()
|
|
if event == "PLAYER_LOGIN" then
|
|
if SFramesDB.enableFlightMap == nil then
|
|
SFramesDB.enableFlightMap = true
|
|
end
|
|
if SFramesDB.enableFlightMap ~= false then
|
|
FM:Initialize()
|
|
end
|
|
end
|
|
end)
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Debug: /ftcdebug (open taxi map first, then type this command)
|
|
--------------------------------------------------------------------------------
|
|
SLASH_FTCDEBUG1 = "/ftcdebug"
|
|
SlashCmdList["FTCDEBUG"] = function()
|
|
local faction = GetPlayerFaction()
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[NanamiFlightDebug]|r faction=" .. tostring(faction) .. " FTCData=" .. tostring(FTCData ~= nil))
|
|
if FTCData then
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[NanamiFlightDebug]|r FTCData[" .. faction .. "]=" .. tostring(FTCData[faction] ~= nil))
|
|
end
|
|
local numNodes = NumTaxiNodes()
|
|
if not numNodes or numNodes == 0 then
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cFFFF6666[NanamiFlightDebug]|r Taxi map not open!")
|
|
return
|
|
end
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[NanamiFlightDebug]|r Nodes=" .. numNodes .. " srcHash=" .. tostring(FM.currentSourceHash))
|
|
for i = 1, numNodes do
|
|
local name = TaxiNodeName(i)
|
|
local ntype = TaxiNodeGetType(i)
|
|
local x, y = TaxiNodePosition(i)
|
|
local h = tostring(math.floor(x * 100000000))
|
|
local corr = hashCorrection[h]
|
|
local corrTag = ""
|
|
if corr and corr ~= h then
|
|
corrTag = " |cFFFFFF00->fuzzy:" .. corr .. "|r"
|
|
elseif corr then
|
|
corrTag = " |cFF00FF00exact|r"
|
|
else
|
|
corrTag = " |cFFFF6666NO_MATCH|r"
|
|
end
|
|
local tag = ""
|
|
if ntype == "CURRENT" then tag = " |cFF66E666<< YOU|r" end
|
|
DEFAULT_CHAT_FRAME:AddMessage(" #" .. i .. " [" .. ntype .. "] " .. name .. " h=" .. h .. corrTag .. tag)
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Export: /ftcexport (prints learned flight times in FlightData.lua format)
|
|
--------------------------------------------------------------------------------
|
|
SLASH_FTCEXPORT1 = "/ftcexport"
|
|
SlashCmdList["FTCEXPORT"] = function()
|
|
local hdb = SFramesGlobalDB and SFramesGlobalDB.flightTimesHash
|
|
if not hdb then
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cFFFF6666[NanamiFlightExport]|r No learned flight times yet.")
|
|
return
|
|
end
|
|
local count = 0
|
|
for faction, sources in pairs(hdb) do
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[NanamiFlightExport]|r -- " .. faction .. " learned routes:")
|
|
for srcHash, dests in pairs(sources) do
|
|
for dstHash, secs in pairs(dests) do
|
|
DEFAULT_CHAT_FRAME:AddMessage(" FTCData." .. faction .. "['" .. srcHash .. "']['" .. dstHash .. "'] = " .. secs)
|
|
count = count + 1
|
|
end
|
|
end
|
|
end
|
|
if count == 0 then
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cFFFF6666[NanamiFlightExport]|r No learned flight times yet. Fly some routes first!")
|
|
else
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[NanamiFlightExport]|r Total: " .. count .. " routes. Copy lines above into FlightData.lua for permanent cross-account sharing.")
|
|
end
|
|
end
|