812 lines
30 KiB
Lua
812 lines
30 KiB
Lua
-- Easy Route: the step window, laid out like RestedXP's. At the top, the step you are on in a box ("Step 12"), with
|
|
-- a tick for each thing in it as you do it and the count for kill and collect objectives; under it the guide's name
|
|
-- with a gear for the guide menu; then the next few steps (click one to jump to it); and < > to step by hand.
|
|
-- The guide menu lists the guides for your faction by level, the ones that suit you now marked, like RestedXP's.
|
|
--
|
|
-- The steps and when they are done come from Steps.lua; the arrow is Arrow.lua.
|
|
|
|
local ER = EasyRoute
|
|
local GOLD, GREY, WHITE, END = ER.GOLD, ER.GREY, ER.WHITE, ER.END
|
|
local GREEN = ER.GREEN
|
|
|
|
local W = 300
|
|
local LINES, ROWS = 10, 6
|
|
local MARK = { A = "|cffffff00!|r ", T = "|cffffff00?|r ", C = "|cffff8040*|r ", K = "|cff00bcd4*|r ", X = "|cffb070ff*|r ",
|
|
H = "|cff79a2ff*|r ", F = "|cff79a2ff*|r ", P = "|cff79a2ff*|r ", B = "|cff79a2ff*|r " }
|
|
|
|
local T = { lines = {}, rows = {} }
|
|
local M = { groupRows = {}, guideRows = {}, extraRows = {} }
|
|
local Refresh
|
|
|
|
local function Say(msg)
|
|
if DEFAULT_CHAT_FRAME then DEFAULT_CHAT_FRAME:AddMessage("|cff33ff99Easy Route:|r " .. msg) end
|
|
end
|
|
|
|
local function Plain(text)
|
|
text = string.gsub(text or "", "|c%x%x%x%x%x%x%x%x", "")
|
|
return (string.gsub(text, "|r", ""))
|
|
end
|
|
|
|
-- How tall a text is at this width, measured by the game (never guessed from letter counts). Leaves the font string
|
|
-- at that width and height with the text in it. The minimum height is only a floor for the result; if the game gives
|
|
-- no height, each line counts as the font size plus a small gap.
|
|
function ER.FitHeight(fs, text, width, minHeight)
|
|
local least = minHeight or 14
|
|
fs:SetWidth(width)
|
|
fs:SetHeight(0) -- 0 = size to the text
|
|
fs:SetText(text or "")
|
|
local h = fs:GetHeight()
|
|
if not h or h < 1 then
|
|
-- The client gave no height: work it out from the width of the text on one line.
|
|
fs:SetWidth(0)
|
|
local full = fs:GetStringWidth() or 0
|
|
fs:SetWidth(width)
|
|
local lines = math.ceil(full / (width * 0.9)) -- the 0.9 leaves room for words that do not fill a row
|
|
if lines < 1 then lines = 1 end
|
|
local _, size = fs:GetFont()
|
|
if type(size) ~= "number" or size < 1 then size = 12 end
|
|
h = lines * (size + 2)
|
|
end
|
|
if h < least then h = least end
|
|
fs:SetHeight(h)
|
|
return h
|
|
end
|
|
|
|
-- One line that fits the width: when it is too wide, whole words come off the end and "..." goes on. With an ending ("tail"), the
|
|
-- ending always stays whole and follows the "..."; only the text before it is cut, word by word and last letter by letter.
|
|
function ER.FitLine(fs, text, width, tail)
|
|
tail = tail or ""
|
|
fs:SetWidth(0) -- 0 = size to the text, so the width read next is the whole text on one line
|
|
fs:SetText((text or "") .. tail)
|
|
local full = fs:GetStringWidth() or 0
|
|
if full <= width then
|
|
fs:SetWidth(width)
|
|
return
|
|
end
|
|
local words = {}
|
|
for w in string.gfind(text or "", "[^ ]+") do table.insert(words, w) end
|
|
while table.getn(words) > 1 do
|
|
table.remove(words)
|
|
fs:SetText(table.concat(words, " ") .. "..." .. tail)
|
|
if (fs:GetStringWidth() or 0) <= width then break end
|
|
end
|
|
if table.getn(words) == 1 then
|
|
local word = words[1]
|
|
fs:SetText(word .. "..." .. tail)
|
|
while tail ~= "" and string.len(word) > 1 and (fs:GetStringWidth() or 0) > width do
|
|
word = string.sub(word, 1, string.len(word) - 1)
|
|
fs:SetText(word .. "..." .. tail)
|
|
end
|
|
end
|
|
fs:SetWidth(width)
|
|
end
|
|
|
|
local function Backdrop(f, alpha)
|
|
f:SetBackdrop({
|
|
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
|
|
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
|
|
tile = true, tileSize = 16, edgeSize = 14,
|
|
insets = { left = 4, right = 4, top = 4, bottom = 4 },
|
|
})
|
|
f:SetBackdropColor(0.03, 0.03, 0.05, alpha or 0.9)
|
|
f:SetBackdropBorderColor(0.55, 0.55, 0.6, 1)
|
|
end
|
|
|
|
local function Tip(widget, fn)
|
|
widget:SetScript("OnEnter", function()
|
|
local title, body, hint = fn(this)
|
|
if not title then return end
|
|
GameTooltip:SetOwner(this, "ANCHOR_LEFT")
|
|
GameTooltip:SetText(title)
|
|
if body then GameTooltip:AddLine(body, 1, 1, 1, 1) end
|
|
if hint then GameTooltip:AddLine(hint, 0.6, 0.6, 0.6, 1) end
|
|
GameTooltip:Show()
|
|
end)
|
|
widget:SetScript("OnLeave", function() GameTooltip:Hide() end)
|
|
end
|
|
|
|
local function Credit(parent, x, y)
|
|
local credit = parent:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
|
|
credit:SetPoint("BOTTOMRIGHT", parent, "BOTTOMRIGHT", x, y)
|
|
credit:SetText(GREY .. "Made by " .. END .. "|cffabd473stealthzi" .. END .. GREY .. " v" .. ER.VERSION .. END)
|
|
return credit
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- The step box
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
-- The lines of one step: { text, done, kind, step }.
|
|
local function StepLines(step, max)
|
|
local out = {}
|
|
local Steps = ER.Steps
|
|
for _, e in ipairs(step.elements) do
|
|
local line = Steps.Line(step, e)
|
|
if line then
|
|
line.step = step
|
|
-- A hearth line that is not done becomes the "Use your hearthstone" button (a real click only; Auto.lua does the use), unless the
|
|
-- Settings tick for the button is off (hearthBtnOff): then it stays a plain line and you use the hearthstone yourself.
|
|
if line.kind == "H" and line.done ~= true and ER.Auto and ER.Auto.UseHearth and not (ER.db and ER.db.hearthBtnOff) then
|
|
line.hearth = true
|
|
line.text = GOLD .. "Use your hearthstone" .. END .. GREY .. " (" .. Plain(line.text) .. ")" .. END
|
|
end
|
|
table.insert(out, line)
|
|
if max and table.getn(out) >= max then break end
|
|
end
|
|
end
|
|
if table.getn(out) == 0 then table.insert(out, { text = Steps.Title(step), step = step }) end
|
|
return out
|
|
end
|
|
|
|
-- The quest a step is about, for the right-click skip: the first pick-up, hand-in or quest work the step shows (nil when it has none).
|
|
local function StepQuest(step)
|
|
for _, e in ipairs(step.elements) do
|
|
local id = tonumber(e.id)
|
|
if id and id ~= 0 and (e.kind == "A" or e.kind == "T" or e.kind == "C" or e.kind == "K") and ER.Steps.Line(step, e) then return id end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function LineText(line)
|
|
local text = line.text
|
|
if line.done == true then
|
|
return GREEN .. "[x] " .. END .. GREY .. Plain(text) .. END
|
|
elseif line.done == false then
|
|
return GREY .. "[ ] " .. END .. (MARK[line.kind] or "") .. text
|
|
end
|
|
return text
|
|
end
|
|
|
|
-- The guide that comes after the one running. For the casual route, a player who is past the next zone (above its top level) gets the first
|
|
-- zone after it that is not passed over; the second value lists the zones passed over (nil when none).
|
|
local function NextToStart()
|
|
local nxt = ER.Steps.NextGuide()
|
|
if nxt and ER.RouteSkipPast then return ER.RouteSkipPast(nxt) end
|
|
return nxt, nil
|
|
end
|
|
|
|
local function FillBox()
|
|
local Steps = ER.Steps
|
|
local step = Steps.Current()
|
|
local lines = {}
|
|
if step then
|
|
for _, l in ipairs(StepLines(step)) do table.insert(lines, l) end
|
|
-- At low levels a grey line under the step says why it is worth doing (ER.WhyLine, Adapt.lua).
|
|
local reason = ER.WhyLine and ER.WhyLine(step)
|
|
if reason then table.insert(lines, { text = GREY .. reason .. END, step = step }) end
|
|
-- The guide's own warnings are step lines already; the cave, survival, escort and safe-route lines join here.
|
|
-- The Settings tick "Show warnings" off (warnOff) leaves these out; the guide's own words stay, they are the step.
|
|
for _, w in ipairs((ER.db and ER.db.warnOff) and {} or Steps.Warnings()) do
|
|
-- A red enemy name in the line ends with |r, which would end the gold too: the gold starts again after it.
|
|
if w.kind ~= "rxp" then table.insert(lines, { text = GOLD .. string.gsub(w.line, "|r", "|r" .. GOLD) .. END, step = step }) end
|
|
end
|
|
local hard = ER.HardLine and ER.HardLine(step)
|
|
if hard then table.insert(lines, { text = hard, step = step }) end
|
|
local needLevel = ER.NeedLevelLine and ER.NeedLevelLine(step)
|
|
if needLevel then table.insert(lines, { text = needLevel, step = step }) end
|
|
local why = ER.GrindReasonLine and ER.GrindReasonLine(step)
|
|
if why then table.insert(lines, { text = GREY .. why .. END, step = step }) end
|
|
local chain = ER.ChainLine and ER.ChainLine(step)
|
|
if chain then
|
|
for line in string.gfind(chain, "[^\n]+") do table.insert(lines, { text = GREY .. line .. END, step = step }) end
|
|
end
|
|
if ER.IsStuck and ER.IsStuck() then
|
|
table.insert(lines, { text = GOLD .. "Stuck? Skip this step" .. END, step = step, skip = true })
|
|
end
|
|
local rate = ER.QuestRateLine and ER.QuestRateLine(step)
|
|
if rate then
|
|
rate.step = step
|
|
table.insert(lines, rate)
|
|
end
|
|
if Steps.ByHand(step) then
|
|
table.insert(lines, { text = GREY .. "Click here or press Done when this is done." .. END, step = step, tick = true })
|
|
end
|
|
local where = ER.RouteLine and ER.RouteLine()
|
|
if where then table.insert(lines, { text = GREY .. where .. END }) end
|
|
else
|
|
table.insert(lines, { text = GOLD .. "This guide is finished." .. END })
|
|
local nxt = NextToStart()
|
|
if nxt then
|
|
table.insert(lines, { text = "Next: " .. WHITE .. (nxt.title or nxt.name) .. END .. GREY .. " (click to start it)" .. END, nextGuide = nxt })
|
|
else
|
|
table.insert(lines, { text = GREY .. "Click the guide's name to pick the next guide." .. END })
|
|
end
|
|
local where = ER.RouteLine and ER.RouteLine()
|
|
if where then table.insert(lines, { text = GREY .. where .. END }) end
|
|
end
|
|
local side = Steps.Side()
|
|
if table.getn(side) > 0 then
|
|
table.insert(lines, { text = GREY .. "On the way:" .. END })
|
|
for _, s in ipairs(side) do
|
|
for _, l in ipairs(StepLines(s, 2)) do
|
|
l.side = true
|
|
table.insert(lines, l)
|
|
end
|
|
end
|
|
end
|
|
-- The box shows LINES lines. "Stuck? Skip this step" is the only way out of a stuck step, so when the lines before it fill the box it takes
|
|
-- the place of the last one shown.
|
|
for i, l in ipairs(lines) do
|
|
if l.skip and i > LINES then
|
|
lines[LINES] = l
|
|
break
|
|
end
|
|
end
|
|
local y = -12
|
|
for i = 1, LINES do
|
|
local b, line = T.lines[i], lines[i]
|
|
if line then
|
|
local text = LineText(line)
|
|
b:ClearAllPoints()
|
|
b:SetPoint("TOPLEFT", T.box, "TOPLEFT", 10, y)
|
|
local h = ER.FitHeight(b.text, text, W - 20, 14) + 2
|
|
b:SetHeight(h)
|
|
b.line = line
|
|
b:Show()
|
|
y = y - h - 2
|
|
else
|
|
b.line = nil
|
|
b:Hide()
|
|
end
|
|
end
|
|
T.box:SetHeight(-y + 8)
|
|
T.tab:SetText(step and (GOLD .. "Step " .. Steps.Position() .. END .. GREY .. " of " .. Steps.Count() .. END) or (GOLD .. "Done" .. END))
|
|
T.tick:SetText(step and Steps.ByHand(step) and "Done" or "Skip")
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- The guide name and the list of what comes next
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
-- The fast routes' groups ("Alliance 1-20") are shown as "Fast route 1-20"; every other name stays as it is. Display only:
|
|
-- the group of a guide, and so its saved key, keeps its name.
|
|
function ER.GroupLabel(name)
|
|
if type(name) ~= "string" then return name end
|
|
local _, _, levels = string.find(name, "^%a+ (%d+%-%d+)$")
|
|
if levels then return "Fast route " .. levels end
|
|
return name
|
|
end
|
|
|
|
local function FillList()
|
|
local Steps = ER.Steps
|
|
local info = Steps.Info()
|
|
T.name:SetText(info and (GOLD .. (info.title or info.name) .. END) or "")
|
|
T.group:SetText(info and (GREY .. ER.GroupLabel(info.group) .. ", on " .. ER.MODES[ER.Mode()].label .. END) or "")
|
|
local list = Steps.Upcoming(ROWS)
|
|
local lh = ER.FitHeight(T.rows[1].text, "Hg", W - 24, 14) -- one line as the game lays it out
|
|
T.rowH = lh + 2
|
|
T.list:SetHeight(ROWS * T.rowH + 40)
|
|
for i = 1, ROWS do
|
|
local r, s = T.rows[i], list[i]
|
|
r:ClearAllPoints()
|
|
r:SetPoint("TOPLEFT", T.list, "TOPLEFT", 8, -8 - (i - 1) * T.rowH)
|
|
r:SetHeight(T.rowH)
|
|
if s then
|
|
ER.FitLine(r.text, GREY .. s.n .. END .. " " .. Plain(Steps.Title(s)), W - 24)
|
|
r.text:SetHeight(lh)
|
|
r.step = s
|
|
r:Show()
|
|
else
|
|
r.step = nil
|
|
r:Hide()
|
|
end
|
|
end
|
|
end
|
|
|
|
Refresh = function()
|
|
if not T.frame or not T.frame:IsShown() then return end
|
|
if not ER.Steps.Running() then
|
|
T.frame:Hide()
|
|
return
|
|
end
|
|
FillBox()
|
|
FillList()
|
|
T.frame:SetHeight(T.box:GetHeight() + 44 + T.list:GetHeight())
|
|
end
|
|
ER.StepsChanged = function()
|
|
Refresh()
|
|
if ER.RefreshSimple then ER.RefreshSimple() end
|
|
if M.frame and M.frame:IsShown() and M.Refresh then M.Refresh() end
|
|
end
|
|
|
|
-- The step window's bottom edge, for the tips box to sit under (nil when it is not up).
|
|
function ER.TrackerBottom()
|
|
if T.frame and T.frame:IsShown() then return T.list end
|
|
return nil
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- The guide menu
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
local function MenuRow(parent, name, w)
|
|
local r = CreateFrame("Button", name, parent)
|
|
r:SetWidth(w)
|
|
r:SetHeight(16)
|
|
local glow = r:CreateTexture(nil, "HIGHLIGHT")
|
|
glow:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight")
|
|
glow:SetBlendMode("ADD")
|
|
glow:SetAllPoints(r)
|
|
r.text = r:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
|
|
r.text:SetPoint("LEFT", r, "LEFT", 4, 0)
|
|
r.text:SetWidth(w - 8)
|
|
r.text:SetHeight(14) -- one line: anything longer ends in "..." instead of running into the next row
|
|
r.text:SetJustifyH("LEFT")
|
|
return r
|
|
end
|
|
|
|
local function ShowGroup(grp)
|
|
M.group = grp
|
|
local suggested = {}
|
|
local best = ER.Steps.Suggest()[1]
|
|
if best then suggested[best] = 1 end
|
|
local running = ER.Steps.Info()
|
|
local n = 0
|
|
for i, r in ipairs(M.guideRows) do
|
|
local g = grp and grp.guides[i]
|
|
if g then
|
|
local text = g.title or g.name
|
|
if running == g then
|
|
text = GREEN .. text .. " (now)" .. END
|
|
elseif suggested[g] then
|
|
text = GOLD .. text .. END .. GREY .. " (best)" .. END
|
|
else
|
|
text = WHITE .. text .. END
|
|
end
|
|
r.text:SetText(text)
|
|
r.guide = g
|
|
r:Show()
|
|
n = i
|
|
else
|
|
r.guide = nil
|
|
r:Hide()
|
|
end
|
|
end
|
|
local height = n * 16 + 36
|
|
-- The running casual-route zone's position line goes under its group's guide rows.
|
|
local where = grp and running and running.group == grp.name and ER.RouteLine and ER.RouteLine()
|
|
if where then
|
|
local h = ER.FitHeight(M.panelLine, GREY .. where .. END, 250, 12)
|
|
M.panelLine:ClearAllPoints()
|
|
M.panelLine:SetPoint("TOPLEFT", M.panel, "TOPLEFT", 12, -28 - n * 16 - 4)
|
|
M.panelLine:Show()
|
|
height = height + h + 4
|
|
else
|
|
M.panelLine:Hide()
|
|
end
|
|
M.panel:SetHeight(height)
|
|
M.panelTitle:SetText(grp and (GOLD .. ER.GroupLabel(grp.name) .. END) or "")
|
|
if grp then M.panel:Show() else M.panel:Hide() end
|
|
end
|
|
|
|
M.Refresh = function()
|
|
local groups = ER.Steps.Groups()
|
|
local suggested = ER.Steps.Suggest()[1]
|
|
local n = 0
|
|
for i, r in ipairs(M.groupRows) do
|
|
local grp = groups[i]
|
|
if grp then
|
|
local has = false
|
|
for _, g in ipairs(grp.guides) do if g == suggested then has = true end end
|
|
r.text:SetText((has and GOLD or WHITE) .. ER.GroupLabel(grp.name) .. END .. GREY .. " >" .. END)
|
|
r.grp = grp
|
|
r:Show()
|
|
n = i
|
|
else
|
|
r.grp = nil
|
|
r:Hide()
|
|
end
|
|
end
|
|
local y = -30 - n * 16 - 10
|
|
M.otherTitle:ClearAllPoints()
|
|
M.otherTitle:SetPoint("TOPLEFT", M.frame, "TOPLEFT", 12, y)
|
|
y = y - 16
|
|
-- Everything else lives in the settings window (Settings.lua).
|
|
local extras = {
|
|
{ "Settings (every option)", function()
|
|
M.frame:Hide()
|
|
if ER.ShowSettings then ER.ShowSettings() end
|
|
end },
|
|
{ "Close", function() M.frame:Hide() end },
|
|
}
|
|
for i, r in ipairs(M.extraRows) do
|
|
local x = extras[i]
|
|
if x then
|
|
r:ClearAllPoints()
|
|
r:SetPoint("TOPLEFT", M.frame, "TOPLEFT", 8, y - (i - 1) * 16)
|
|
r.text:SetText(WHITE .. x[1] .. END)
|
|
r.fn = x[2]
|
|
r:Show()
|
|
else
|
|
r.fn = nil
|
|
r:Hide()
|
|
end
|
|
end
|
|
M.frame:SetHeight(-y + table.getn(extras) * 16 + 34)
|
|
-- Open on the group that holds the guide that suits you best.
|
|
local open = M.group
|
|
if not open then
|
|
for _, grp in ipairs(groups) do
|
|
for _, g in ipairs(grp.guides) do if g == suggested then open = grp end end
|
|
end
|
|
end
|
|
ShowGroup(open or groups[1])
|
|
end
|
|
|
|
local function BuildMenu()
|
|
local f = CreateFrame("Frame", "EasyRouteGuideMenu", UIParent)
|
|
M.frame = f
|
|
f:SetWidth(250)
|
|
f:SetHeight(200)
|
|
f:SetFrameStrata("DIALOG")
|
|
f:SetClampedToScreen(true)
|
|
f:EnableMouse(true)
|
|
Backdrop(f, 0.97)
|
|
f:Hide()
|
|
table.insert(UISpecialFrames, "EasyRouteGuideMenu")
|
|
local title = f:CreateFontString(nil, "ARTWORK", "GameFontNormal")
|
|
title:SetPoint("TOPLEFT", f, "TOPLEFT", 12, -10)
|
|
title:SetText("Pick a guide")
|
|
for i = 1, 6 do
|
|
local r = MenuRow(f, "EasyRouteGuideMenuGroup" .. i, 234)
|
|
r:SetPoint("TOPLEFT", f, "TOPLEFT", 8, -28 - (i - 1) * 16)
|
|
r:SetScript("OnEnter", function() if this.grp then ShowGroup(this.grp) end end)
|
|
r:SetScript("OnClick", function() if this.grp then ShowGroup(this.grp) end end)
|
|
r:Hide()
|
|
M.groupRows[i] = r
|
|
end
|
|
M.otherTitle = f:CreateFontString(nil, "ARTWORK", "GameFontNormal")
|
|
M.otherTitle:SetText("More")
|
|
for i = 1, 2 do
|
|
local r = MenuRow(f, "EasyRouteGuideMenuExtra" .. i, 234)
|
|
r:SetScript("OnClick", function() if this.fn then this.fn() end end)
|
|
r:Hide()
|
|
M.extraRows[i] = r
|
|
end
|
|
Credit(f, -10, 8)
|
|
|
|
local p = CreateFrame("Frame", "EasyRouteGuideMenuPanel", f)
|
|
M.panel = p
|
|
p:SetWidth(270)
|
|
p:SetHeight(200)
|
|
p:SetPoint("TOPLEFT", f, "TOPRIGHT", -2, 0)
|
|
p:EnableMouse(true)
|
|
Backdrop(p, 0.95)
|
|
M.panelTitle = p:CreateFontString(nil, "ARTWORK", "GameFontNormal")
|
|
M.panelTitle:SetPoint("TOPLEFT", p, "TOPLEFT", 12, -10)
|
|
M.panelLine = p:CreateFontString("EasyRouteGuideMenuLine", "ARTWORK", "GameFontHighlightSmall")
|
|
M.panelLine:SetJustifyH("LEFT")
|
|
M.panelLine:Hide()
|
|
for i = 1, 22 do
|
|
local r = MenuRow(p, "EasyRouteGuideMenuGuide" .. i, 254)
|
|
r:SetPoint("TOPLEFT", p, "TOPLEFT", 8, -28 - (i - 1) * 16)
|
|
r:SetScript("OnClick", function()
|
|
local g = this.guide
|
|
if not g then return end
|
|
M.frame:Hide()
|
|
ER.StartGuide(ER.Steps.Key(g), nil, nil, true)
|
|
end)
|
|
Tip(r, function(b)
|
|
local g = b.guide
|
|
if not g then return nil end
|
|
return g.title or g.name, "Levels " .. g.lo .. " to " .. g.hi .. ".", "Click to follow this guide."
|
|
end)
|
|
r:Hide()
|
|
M.guideRows[i] = r
|
|
end
|
|
end
|
|
|
|
-- Opens the guide menu, next to the step window when it is up, in the middle of the screen when not.
|
|
function ER.ShowGuideMenu(anchor)
|
|
if not M.frame then BuildMenu() end
|
|
M.group = nil
|
|
M.frame:ClearAllPoints()
|
|
if anchor then
|
|
M.frame:SetPoint("TOPRIGHT", anchor, "BOTTOMLEFT", 0, 0)
|
|
elseif ER.SimpleShown and ER.SimpleShown() then
|
|
M.frame:SetPoint("TOPRIGHT", ER.SimpleFrame(), "TOPLEFT", -276, 0)
|
|
elseif T.frame and T.frame:IsShown() then
|
|
M.frame:SetPoint("TOPRIGHT", T.frame, "TOPLEFT", -276, 0)
|
|
else
|
|
M.frame:SetPoint("CENTER", UIParent, "CENTER", -140, 40)
|
|
end
|
|
M.frame:Show()
|
|
M.Refresh()
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- Building the window
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
local function Button(name, parent, w, label, fn)
|
|
local b = CreateFrame("Button", name, parent, "UIPanelButtonTemplate")
|
|
b:SetWidth(w)
|
|
b:SetHeight(20)
|
|
b:SetText(label)
|
|
b:SetScript("OnClick", fn)
|
|
return b
|
|
end
|
|
|
|
local function Build()
|
|
local f = CreateFrame("Frame", "EasyRouteTracker", UIParent)
|
|
T.frame = f
|
|
f:SetWidth(W)
|
|
f:SetHeight(300)
|
|
local pos = ER.db and ER.db.trackerPos
|
|
if type(pos) == "table" and pos.point then
|
|
f:SetPoint(pos.point, UIParent, pos.relPoint or pos.point, pos.x or 0, pos.y or 0)
|
|
else
|
|
f:SetPoint("TOPRIGHT", UIParent, "TOPRIGHT", -40, -220)
|
|
end
|
|
f:SetFrameStrata("MEDIUM")
|
|
f:SetClampedToScreen(true)
|
|
f:EnableMouse(true)
|
|
f:SetMovable(true)
|
|
f:RegisterForDrag("LeftButton")
|
|
f:SetScript("OnDragStart", function() this:StartMoving() end)
|
|
f:SetScript("OnDragStop", function()
|
|
this:StopMovingOrSizing()
|
|
local point, _, relPoint, x, y = this:GetPoint()
|
|
if ER.db then ER.db.trackerPos = { point = point, relPoint = relPoint, x = x, y = y } end
|
|
end)
|
|
f:SetScript("OnShow", function() Refresh() end)
|
|
f:Hide()
|
|
|
|
-- The step box, with its "Step 12" tab on top.
|
|
local box = CreateFrame("Frame", "EasyRouteTrackerBox", f)
|
|
T.box = box
|
|
box:SetWidth(W)
|
|
box:SetHeight(80)
|
|
box:SetPoint("TOPLEFT", f, "TOPLEFT", 0, -16)
|
|
Backdrop(box, 0.97)
|
|
box:SetBackdropBorderColor(0.85, 0.65, 0.3, 1)
|
|
local tab = CreateFrame("Frame", "EasyRouteTrackerTab", f)
|
|
tab:SetWidth(130)
|
|
tab:SetHeight(22)
|
|
tab:SetPoint("BOTTOMLEFT", box, "TOPLEFT", 6, -6)
|
|
Backdrop(tab, 0.95)
|
|
tab:SetBackdropBorderColor(0.85, 0.65, 0.3, 1)
|
|
T.tab = tab:CreateFontString(nil, "ARTWORK", "GameFontNormalSmall")
|
|
T.tab:SetPoint("CENTER", tab, "CENTER", 0, 0)
|
|
local close = CreateFrame("Button", "EasyRouteTrackerClose", f, "UIPanelCloseButton")
|
|
close:SetWidth(24)
|
|
close:SetHeight(24)
|
|
close:SetPoint("BOTTOMRIGHT", box, "TOPRIGHT", 2, -6)
|
|
close:SetScript("OnClick", function()
|
|
f:Hide()
|
|
if ER.PlaceTips then ER.PlaceTips() end
|
|
Say("step window hidden; the guide keeps going. " .. GOLD .. "/er" .. END .. " shows it again.")
|
|
end)
|
|
for i = 1, LINES do
|
|
local b = CreateFrame("Button", "EasyRouteTrackerLine" .. i, box)
|
|
b:SetWidth(W - 20)
|
|
b:SetHeight(14)
|
|
local glow = b:CreateTexture(nil, "HIGHLIGHT")
|
|
glow:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight")
|
|
glow:SetBlendMode("ADD")
|
|
glow:SetAllPoints(b)
|
|
b.text = b:CreateFontString(nil, "ARTWORK", "GameFontHighlight")
|
|
b.text:SetPoint("TOPLEFT", b, "TOPLEFT", 0, 0)
|
|
b.text:SetWidth(W - 20)
|
|
b.text:SetJustifyH("LEFT")
|
|
b.text:SetJustifyV("TOP")
|
|
b:SetScript("OnClick", function()
|
|
local line = this.line
|
|
if line and line.hearth then
|
|
if ER.Auto and ER.Auto.UseHearth then ER.Auto.UseHearth() end
|
|
return
|
|
end
|
|
if line and line.skip then
|
|
ER.Steps.Next(true)
|
|
return
|
|
end
|
|
if line and line.nextGuide then
|
|
-- A casual-route zone that follows its own zone starts at the top (the part-way scan is for a guide picked from the menu).
|
|
local nxt, skipped = NextToStart()
|
|
nxt = nxt or line.nextGuide
|
|
local prev = ER.Steps.Info()
|
|
if ER.StartGuide(ER.Steps.Key(nxt), nxt.route and true or nil, skipped and true or nil) and skipped and ER.RouteNextLine then
|
|
local words = ER.RouteNextLine(prev, nxt, skipped)
|
|
if words then Say(words) end
|
|
end
|
|
return
|
|
end
|
|
if line and line.rate then
|
|
ER.NextQuestRating(line.rate)
|
|
if Refresh then Refresh() end
|
|
return
|
|
end
|
|
if not line or not line.step then return end
|
|
if line.tick or line.kind == "M" or ER.Steps.ByHand(line.step) then
|
|
ER.Steps.Tick(line.step.n)
|
|
end
|
|
end)
|
|
Tip(b, function(btn)
|
|
local line = btn.line
|
|
if line and line.rate then
|
|
local r = line.rate
|
|
local body = r.mine and "You said this one is " .. Plain(ER.Coloured(r.rating)) .. "."
|
|
or "My guess: " .. Plain(ER.Coloured(r.rating)) .. (r.why and (", because " .. r.why) or "") .. "."
|
|
return "How hard is " .. r.title .. "?", body,
|
|
"Click to change it: Easy, Medium, Hard. Your answer is saved and goes in Send feedback."
|
|
end
|
|
if not line or not line.step then return nil end
|
|
local hint = "The arrow shows where this happens."
|
|
if line.skip then hint = "Click to skip this step. The guide never skips by itself." end
|
|
if line.tick or line.kind == "M" or ER.Steps.ByHand(line.step) then hint = "Click when you have done this." end
|
|
if line.hearth then hint = "Click to use your hearthstone. Easy Route never uses it by itself." end
|
|
return Plain(ER.Steps.Title(line.step)), Plain(line.text), hint
|
|
end)
|
|
b:Hide()
|
|
T.lines[i] = b
|
|
end
|
|
|
|
-- The guide's name, with the gear for the guide menu.
|
|
local head = CreateFrame("Button", "EasyRouteTrackerHead", f)
|
|
T.head = head
|
|
head:SetWidth(W)
|
|
head:SetHeight(38)
|
|
head:SetPoint("TOPLEFT", box, "BOTTOMLEFT", 0, 2)
|
|
Backdrop(head, 0.97)
|
|
local icon = head:CreateTexture(nil, "ARTWORK")
|
|
icon:SetTexture("Interface\\Icons\\INV_Misc_Book_09")
|
|
icon:SetWidth(26)
|
|
icon:SetHeight(26)
|
|
icon:SetPoint("LEFT", head, "LEFT", 7, 0)
|
|
T.name = head:CreateFontString(nil, "ARTWORK", "GameFontNormal")
|
|
T.name:SetPoint("TOPLEFT", icon, "TOPRIGHT", 6, 0)
|
|
T.name:SetWidth(W - 80)
|
|
T.name:SetJustifyH("LEFT")
|
|
T.group = head:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
|
|
T.group:SetPoint("BOTTOMLEFT", icon, "BOTTOMRIGHT", 6, 0)
|
|
T.group:SetWidth(W - 80)
|
|
T.group:SetJustifyH("LEFT")
|
|
head:SetScript("OnClick", function() ER.ShowGuideMenu() end)
|
|
local gear = CreateFrame("Button", "EasyRouteTrackerGear", head)
|
|
gear:SetWidth(22)
|
|
gear:SetHeight(22)
|
|
gear:SetPoint("RIGHT", head, "RIGHT", -8, 0)
|
|
gear:SetNormalTexture("Interface\\Icons\\INV_Misc_Gear_01")
|
|
gear:SetHighlightTexture("Interface\\Buttons\\ButtonHilight-Square")
|
|
gear:SetScript("OnClick", function()
|
|
if ER.ShowSettings then ER.ShowSettings() else ER.ShowGuideMenu() end
|
|
end)
|
|
Tip(gear, function() return "Settings", "Every option in one place: the guide, how hard, auto mode, the arrow, tips and more.", nil end)
|
|
Tip(head, function() return "Pick a guide", "Click to see every guide.", nil end)
|
|
|
|
-- What comes next.
|
|
local list = CreateFrame("Frame", "EasyRouteTrackerList", f)
|
|
T.list = list
|
|
list:SetWidth(W)
|
|
T.rowH = 16
|
|
list:SetHeight(ROWS * T.rowH + 40)
|
|
list:SetPoint("TOPLEFT", head, "BOTTOMLEFT", 0, 2)
|
|
Backdrop(list, 0.97)
|
|
for i = 1, ROWS do
|
|
local r = MenuRow(list, "EasyRouteTrackerRow" .. i, W - 16)
|
|
r:SetPoint("TOPLEFT", list, "TOPLEFT", 8, -8 - (i - 1) * T.rowH)
|
|
r:RegisterForClicks("LeftButtonUp", "RightButtonUp")
|
|
r:SetScript("OnClick", function()
|
|
if not this.step then return end
|
|
if arg1 == "RightButton" then
|
|
local id = StepQuest(this.step)
|
|
if id and ER.ShowSkipMenu then
|
|
ER.ShowSkipMenu(id)
|
|
else
|
|
Say("this step has no quest to skip.")
|
|
end
|
|
return
|
|
end
|
|
ER.Steps.Jump(this.step.n)
|
|
end)
|
|
Tip(r, function(b)
|
|
if not b.step then return nil end
|
|
local lines = {}
|
|
for _, l in ipairs(StepLines(b.step)) do table.insert(lines, Plain(l.text)) end
|
|
local hint = "Click to jump to this step."
|
|
if StepQuest(b.step) then hint = hint .. "\nRight-click to skip its quest." end
|
|
return "Step " .. b.step.n, table.concat(lines, "\n"), hint
|
|
end)
|
|
r:Hide()
|
|
T.rows[i] = r
|
|
end
|
|
Button("EasyRouteTrackerPrev", list, 26, "<", function() ER.Steps.Prev() end):SetPoint("BOTTOMLEFT", list, "BOTTOMLEFT", 8, 8)
|
|
Button("EasyRouteTrackerNext", list, 26, ">", function() ER.Steps.Next() end):SetPoint("BOTTOMLEFT", list, "BOTTOMLEFT", 36, 8)
|
|
T.tick = Button("EasyRouteTrackerTick", list, 50, "Skip", function()
|
|
local step = ER.Steps.Current()
|
|
if step and ER.Steps.ByHand(step) then ER.Steps.Tick(step.n) else ER.Steps.Next(true) end
|
|
end)
|
|
T.tick:SetPoint("BOTTOMLEFT", list, "BOTTOMLEFT", 64, 8)
|
|
Tip(T.tick, function()
|
|
return "Done / Skip", "Done: you have done this step. Skip: leave it out and go on; its quests then count as Hard for you.", nil
|
|
end)
|
|
Credit(list, -10, 12)
|
|
end
|
|
|
|
-- Shows the guide: the step box, or in simple mode the quest list (Simple.lua).
|
|
function ER.ShowTracker()
|
|
if not T.frame then Build() end
|
|
if ER.db and ER.db.simple and ER.ShowSimple then
|
|
T.frame:Hide()
|
|
ER.ShowSimple()
|
|
else
|
|
if ER.HideSimple then ER.HideSimple() end
|
|
T.frame:Show()
|
|
Refresh()
|
|
end
|
|
if ER.PlaceTips then ER.PlaceTips() end
|
|
end
|
|
|
|
function ER.TrackerShown()
|
|
if ER.SimpleShown and ER.SimpleShown() then return true end
|
|
return T.frame and T.frame:IsShown() or false
|
|
end
|
|
|
|
function ER.ToggleTracker()
|
|
if not T.frame then Build() end
|
|
if ER.TrackerShown() then
|
|
T.frame:Hide()
|
|
if ER.HideSimple then ER.HideSimple() end
|
|
if ER.PlaceTips then ER.PlaceTips() end
|
|
else
|
|
ER.ShowTracker()
|
|
end
|
|
end
|
|
|
|
-- Starts a guide and shows the step window and the arrow. quiet: the caller prints its own line. byHand: picked from the guide list
|
|
-- (the check-in then waits a while before it asks about moving on, Adapt.lua).
|
|
function ER.StartGuide(key, fresh, quiet, byHand)
|
|
-- A zone that is started again is not "ahead of the plan" because of the last time (ER.RouteNextLine reads that mark).
|
|
local again = ER.Steps.Find(key)
|
|
if again then again.ahead = nil end
|
|
if not ER.Steps.Load(key, fresh) then
|
|
Say("that guide could not be loaded.")
|
|
return false
|
|
end
|
|
local info = ER.Steps.Info()
|
|
if ER.GuideStarted then ER.GuideStarted(ER.Steps.Key(info), byHand) end
|
|
if not quiet then
|
|
Say("following " .. GOLD .. (info.title or info.name) .. END .. ". The arrow points the way; " .. GOLD .. "/er" .. END ..
|
|
" shows or hides the steps.")
|
|
end
|
|
if ER.db then ER.db.arrowOff = nil end -- a new guide always starts with the arrow on
|
|
ER.ShowTracker()
|
|
if ER.ArrowUpdate then ER.ArrowUpdate() end
|
|
return true
|
|
end
|
|
|
|
-- When a guide is finished the next one starts by itself, no click needed. true when one was started.
|
|
function ER.AutoNextGuide()
|
|
if ER.db and ER.db.autoNextOff then return false end
|
|
local prev = ER.Steps.Info()
|
|
local nxt, skipped = NextToStart()
|
|
if not nxt then return false end
|
|
-- A casual-route zone that follows its own zone starts at the top: the part-way scan would drop its travel steps and could take a quest
|
|
-- of the same name from the zone before for progress. Advance ticks off whatever is already done.
|
|
if not ER.StartGuide(ER.Steps.Key(nxt), nxt.route and true or nil, true) then return false end
|
|
-- The casual route has its own single line; every other guide keeps the old one.
|
|
local line = ER.RouteNextLine and ER.RouteNextLine(prev, nxt, skipped)
|
|
if line then
|
|
Say(line)
|
|
else
|
|
Say(GOLD .. "guide finished." .. END .. " Now following " .. GOLD .. (nxt.title or nxt.name) .. END .. ".")
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Picks the step window back up after a login when a guide was running.
|
|
local starter = CreateFrame("Frame", "EasyRouteTrackerStarter")
|
|
starter:RegisterEvent("PLAYER_ENTERING_WORLD")
|
|
starter:SetScript("OnEvent", function()
|
|
this:UnregisterEvent("PLAYER_ENTERING_WORLD")
|
|
this.wait = 0
|
|
this:SetScript("OnUpdate", function()
|
|
this.wait = this.wait + arg1
|
|
if this.wait < 2 then return end
|
|
this:SetScript("OnUpdate", nil)
|
|
if ER.Steps.Running() or ER.Steps.Resume() then ER.ShowTracker() end
|
|
end)
|
|
end)
|
|
|
|
ER.Loaded("Tracker.lua")
|