It moves the guide on only when that quest is on the step you are on, and no other quest of the step is marked as hard.
611 lines
25 KiB
Lua
611 lines
25 KiB
Lua
-- Easy Route: the advice. It watches how levelling goes and says what is worth knowing in the tips box
|
|
-- (Simple.lua), and it rates enemies on their tooltip.
|
|
-- * The guide leaves out quests too easy for you (Steps.lua); this says how many, now and then.
|
|
-- * When you have outlevelled the guide it asks whether to move on to one that fits your level.
|
|
-- * Once per character it asks whether you have money on another character, to leave out the money-farming steps.
|
|
-- * It reminds you to visit your class trainer when new spells have been waiting a couple of levels, and says what
|
|
-- the big levels (10, 20, 30, 40) bring.
|
|
-- * In simple mode (no step box) the warnings for the step you are on (a cave, dangerous enemies, "try to avoid ...") and
|
|
-- quests above your comfort show here too; with the step box they show in the box.
|
|
-- * Walking into a mine, cave or crypt while a guide runs says so once in the tips box.
|
|
-- * Enemies get Easy, Medium or Hard at the bottom of their tooltip: their level against yours and your difficulty,
|
|
-- elites, and the guide's warnings.
|
|
|
|
local ER = EasyRoute
|
|
local GOLD, GREY, WHITE, RED, GREEN, END = ER.GOLD, ER.GREY, ER.WHITE, ER.RED, ER.GREEN, ER.END
|
|
|
|
-- What is remembered per character: { money = true/false/nil (not asked), trained = level of the last trainer visit,
|
|
-- stay = { [guide key] = true } guides you chose to stay in, told = { [key] = true } things said once,
|
|
-- shift = -2..2 (how you answered "how is it going"), asked = the last level mark asked about,
|
|
-- deaths = { [quest id] = deaths on it }, hard = { [quest id] = "died", "skip" or "rated" } quests that count as Hard for you }.
|
|
local function Mine()
|
|
if not ER.db then return nil end
|
|
if type(ER.db.adapt) ~= "table" then ER.db.adapt = {} end
|
|
local c = ER.Char()
|
|
local a = ER.db.adapt[c]
|
|
if type(a) ~= "table" then
|
|
a = {}
|
|
ER.db.adapt[c] = a
|
|
end
|
|
if type(a.stay) ~= "table" then a.stay = {} end
|
|
if type(a.told) ~= "table" then a.told = {} end
|
|
if type(a.deaths) ~= "table" then a.deaths = {} end
|
|
if type(a.hard) ~= "table" then a.hard = {} end
|
|
local shift = tonumber(a.shift) or 0
|
|
a.shift = math.floor(math.max(-2, math.min(2, shift)))
|
|
a.asked = tonumber(a.asked) or 0
|
|
return a
|
|
end
|
|
|
|
local function Tip(key, text, buttons, life)
|
|
if ER.AddTip then ER.AddTip(key, text, buttons, life) end
|
|
end
|
|
|
|
local function Simple()
|
|
return ER.SimpleShown and ER.SimpleShown()
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- Money on another character
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
function ER.HasMoney()
|
|
local a = Mine()
|
|
return a and a.money == true or false
|
|
end
|
|
|
|
function ER.SetHasMoney(on)
|
|
local a = Mine()
|
|
if not a then return end
|
|
a.money = on and true or false
|
|
ER.Print(on and "the steps that only farm money are left out now (untick it in Settings to keep them)."
|
|
or "the money-farming steps are kept.")
|
|
if ER.Steps and ER.Steps.Running() then ER.Steps.Check() end
|
|
end
|
|
|
|
local askedNow = {} -- questions asked this session (closing the box without an answer is not asked again today)
|
|
|
|
local function AskMoney()
|
|
local a = Mine()
|
|
if not a or a.money ~= nil or askedNow.money then return end
|
|
askedNow.money = true
|
|
Tip("money", "Do you have money on another character you can mail over? Then I can leave out the steps that only " ..
|
|
"farm money (\"loot them until you have 10 copper\").", {
|
|
{ label = "Yes, leave them out", fn = function() ER.SetHasMoney(true) end },
|
|
{ label = "No", fn = function() ER.SetHasMoney(false) end },
|
|
})
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- Too hard for you now
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
-- The first quest in a step that is above your comfort: id, title, its level, how far above you. Only quests you
|
|
-- are doing; picking one up early is fine (RestedXP often takes quests for later).
|
|
local function HardQuest(step)
|
|
local Steps = ER.Steps
|
|
for _, e in ipairs(step.elements) do
|
|
if (e.kind == "C" or e.kind == "K") and e.id and e.id ~= 0 then
|
|
local done = Steps.ElementDone(step, e)
|
|
local over = done == false and Steps.TooHard(e.id)
|
|
if over then return e.id, Steps.QuestTitle(e.id) or ("quest " .. e.id), Steps.QuestLevel(e.id), over end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- The red line in the step box for a quest above your comfort; nil when the step is fine.
|
|
function ER.HardLine(step)
|
|
local id, title, level = HardQuest(step)
|
|
if not id then return nil end
|
|
return RED .. "Hard for your level: " .. END .. title .. " is level " .. level .. ", you are " .. (UnitLevel("player") or 1) ..
|
|
". Kill a few mobs on the way first, or Skip it."
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- How hard is this quest? A line in the step box with the addon's guess or your own answer; click to change it
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
-- The quest the step is about: the first one in your log that it finishes, kills for or hands in.
|
|
local function StepQuest(step)
|
|
local Steps = ER.Steps
|
|
for _, e in ipairs(step.elements) do
|
|
if (e.kind == "C" or e.kind == "K" or e.kind == "T") and e.id and e.id ~= 0 then
|
|
local title, row = Steps.QuestTitle(e.id), Steps.InLog(e.id)
|
|
if title and row then return title, row, e.id end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Enough about the quest for the guess (the full details are only gathered when you change it).
|
|
local function QuickInfo(title, row, id)
|
|
local a = ER.Recorder.Active()[title]
|
|
return { qlevel = row.qlevel or ER.Steps.QuestLevel(id), tag = row.tag, pfid = row.pfid or (a and a.pfid),
|
|
deaths = (a and a.deaths) or 0, close = (a and a.close) or 0 }
|
|
end
|
|
|
|
-- { text, rate = { title, row, rating, mine, why } } for the step box, or nil when the step has no quest of yours.
|
|
function ER.QuestRateLine(step)
|
|
if not (ER.Recorder and ER.Recorder.Active) then return nil end
|
|
local title, row, id = StepQuest(step)
|
|
if not title then return nil end
|
|
local info = QuickInfo(title, row, id)
|
|
local mine = ER.GetRating(title, info.pfid)
|
|
local rating, why, reason
|
|
if mine and mine.rating then
|
|
rating = mine.rating
|
|
else
|
|
local learned = ER.LearnedHard(id)
|
|
if learned == "died" then
|
|
rating, reason = "hard", "you died twice on it"
|
|
elseif learned == "skip" then
|
|
rating, reason = "hard", "you skipped it"
|
|
else
|
|
local _
|
|
rating, _, why = ER.Suggest(info)
|
|
if string.find(ER.Steps.Kinds(id), "h", 1, true) then rating, reason = "hard", "friends found it hard" end
|
|
end
|
|
end
|
|
local whose = mine and "your answer" or "my guess"
|
|
if reason then whose = whose .. ": " .. reason end
|
|
return {
|
|
text = GREY .. "How hard: " .. END .. ER.Coloured(rating) .. GREY .. " (" .. whose .. ", click to change)" .. END,
|
|
rate = { title = title, row = row, rating = rating, mine = mine and true or false, why = why, id = id },
|
|
}
|
|
end
|
|
|
|
-- Clicking the line: Easy -> Medium -> Hard -> Easy. Saved like a rating from the quest log, so it goes in the
|
|
-- notebook and in "Send feedback".
|
|
function ER.NextQuestRating(r)
|
|
local order = { easy = "medium", medium = "hard", hard = "easy", skip = "easy" }
|
|
local rating = order[r.rating] or "medium"
|
|
local info = ER.Recorder.InfoFor(r.title, r.row)
|
|
local old = ER.GetRating(r.title, info.pfid)
|
|
ER.SetRating(r.title, rating, old and old.tags, old and old.note, info)
|
|
local a = Mine()
|
|
if a and r.id then
|
|
if rating == "hard" then
|
|
a.hard[r.id] = a.hard[r.id] or "rated"
|
|
elseif a.hard[r.id] == "rated" then
|
|
a.hard[r.id] = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- Check-in every 3 levels
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
local MARK_STEP, MARK_FIRST, MARK_LAST = 3, 6, 57 -- asked at levels 6, 9, 12 ... 57
|
|
local SHIFT_MAX = 2 -- the comfort line moves at most this far either way
|
|
local ASK_LIFE = 300 -- seconds the question waits; no answer changes nothing
|
|
local CONFIRM_LIFE = 10
|
|
|
|
-- How many levels the comfort line moves for this character: the sum of the answers, -2 to +2.
|
|
function ER.AdaptShift()
|
|
local a = Mine()
|
|
return a and a.shift or 0
|
|
end
|
|
|
|
-- The level mark to ask about, or nil: the highest mark at or below your level that was not asked yet.
|
|
local function DueMark(level, asked)
|
|
local m = math.floor(level / MARK_STEP) * MARK_STEP
|
|
if m < MARK_FIRST or m > MARK_LAST or m <= asked then return nil end
|
|
return m
|
|
end
|
|
|
|
local function Levels(n) return n .. (n == 1 and " level" or " levels") end
|
|
|
|
local function Confirm(lead)
|
|
Tip("checkin:ok", lead .. "quests up to " .. Levels(ER.Steps.Comfort()) .. " above you.", nil, CONFIRM_LIFE)
|
|
end
|
|
|
|
-- The next harder (up) or easier difficulty than the one you are on; nil at the end of the list.
|
|
local function NeighbourMode(up)
|
|
local now = ER.Mode()
|
|
for i, key in ipairs(ER.MODE_ORDER) do
|
|
if key == now then return ER.MODE_ORDER[i + (up and 1 or -1)] end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function Answer(delta)
|
|
local a = Mine()
|
|
if not a then return end
|
|
ER.RemoveTip("checkin")
|
|
local new = math.max(-SHIFT_MAX, math.min(SHIFT_MAX, a.shift + delta))
|
|
local key = delta ~= 0 and new == a.shift and NeighbourMode(delta > 0)
|
|
if key then
|
|
local label = ER.MODES[key].label
|
|
Tip("checkin", "Try " .. label .. "?", {
|
|
{ label = "Switch", fn = function()
|
|
ER.RemoveTip("checkin")
|
|
a.shift = 0
|
|
ER.SetMode(key, true)
|
|
Confirm("Got it: " .. label .. " from now on, ")
|
|
end },
|
|
{ label = "No", fn = function() ER.RemoveTip("checkin") end },
|
|
}, ASK_LIFE)
|
|
return
|
|
end
|
|
a.shift = new
|
|
Confirm("Got it: ")
|
|
if ER.Steps.Running() then
|
|
ER.Steps.Check()
|
|
if ER.StepsChanged then ER.StepsChanged() end
|
|
end
|
|
end
|
|
|
|
local function CheckIn(a)
|
|
local m = DueMark(UnitLevel("player") or 1, a.asked)
|
|
if not m then return end
|
|
if ER.db.tipsOff or ER.db.checkinOff then
|
|
a.asked = m
|
|
return
|
|
end
|
|
if UnitAffectingCombat("player") or UnitIsDeadOrGhost("player") or UnitOnTaxi("player") then return end
|
|
a.asked = m
|
|
Tip("checkin", "Level " .. m .. ": how is it going?", {
|
|
{ label = "Too easy", fn = function() Answer(1) end },
|
|
{ label = "About right", fn = function() Answer(0) end },
|
|
{ label = "Too hard", fn = function() Answer(-1) end },
|
|
}, ASK_LIFE)
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- Learning from deaths and skips
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
local DEATHS_HARD = 2 -- deaths on one quest before it counts as Hard for you
|
|
local SKIP_TIP_LIFE = 20
|
|
local DIED_TIP_LIFE = 300
|
|
|
|
-- Quest ids in the steps (the current one and the side steps) on the lines of these kinds that are not done yet.
|
|
local function Unfinished(steps, kinds)
|
|
local out, seen = {}, {}
|
|
for _, step in ipairs(steps) do
|
|
for _, e in ipairs(step.elements) do
|
|
local id = tonumber(e.id)
|
|
if id and id ~= 0 and string.find(kinds, e.kind, 1, true) and not seen[id] and ER.Steps.ElementDone(step, e) == false then
|
|
seen[id] = true
|
|
table.insert(out, id)
|
|
end
|
|
end
|
|
end
|
|
return out
|
|
end
|
|
|
|
-- Is quest id worked on (a C or K line) in this step?
|
|
local function OnStep(step, id)
|
|
if not step then return false end
|
|
for _, e in ipairs(step.elements) do
|
|
if (e.kind == "C" or e.kind == "K") and tonumber(e.id) == id then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local function OnDeath()
|
|
local Steps = ER.Steps
|
|
if not Steps.Running() or (IsInInstance and IsInInstance()) then return end
|
|
local a = Mine()
|
|
if not a then return end
|
|
local steps = { Steps.Current() }
|
|
for _, s in ipairs(Steps.Side()) do table.insert(steps, s) end
|
|
for _, id in ipairs(Unfinished(steps, "CK")) do
|
|
local row = Steps.InLog(id)
|
|
if row and not row.complete then
|
|
a.deaths[id] = (tonumber(a.deaths[id]) or 0) + 1
|
|
if a.deaths[id] >= DEATHS_HARD and not a.hard[id] then
|
|
a.hard[id] = "died"
|
|
Tip("died:" .. id, "You died twice on " .. (Steps.QuestTitle(id) or "this quest") ..
|
|
". I will count it as Hard from now on. You can abandon it in your quest log.", {
|
|
{ label = "Skip it", fn = function()
|
|
ER.RemoveTip("died:" .. id)
|
|
-- Only the quest you died on: the step moves on when that quest is still on the step you are on (a plain page
|
|
-- on, so the step's other quests are not marked). The quest itself is already marked Hard ("died").
|
|
if Steps.Running() and OnStep(Steps.Current(), id) then Steps.Next() end
|
|
end },
|
|
{ label = "Keep going", fn = function() ER.RemoveTip("died:" .. id) end },
|
|
}, DIED_TIP_LIFE)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- "A", "A and B", "A, B and C"
|
|
local function JoinTitles(list)
|
|
local n = table.getn(list)
|
|
if n == 1 then return list[1] end
|
|
return table.concat(list, ", ", 1, n - 1) .. " and " .. list[n]
|
|
end
|
|
|
|
-- A step left before it was done: the quests it picks up or works on count as Hard for you from now on.
|
|
function ER.OnStepSkipped(step)
|
|
local a = Mine()
|
|
if not a then return end
|
|
local titles = {}
|
|
for _, id in ipairs(Unfinished({ step }, "ACK")) do
|
|
if not a.hard[id] then
|
|
a.hard[id] = "skip"
|
|
table.insert(titles, ER.Steps.QuestTitle(id) or ("quest " .. id))
|
|
end
|
|
end
|
|
if table.getn(titles) > 0 then
|
|
Tip("skip", "Left out from now on: " .. JoinTitles(titles) .. " (you skipped them).", nil, SKIP_TIP_LIFE)
|
|
end
|
|
end
|
|
|
|
-- Why a quest counts as Hard for you: "died", "skip" or "rated" (you rated it Hard yourself); nil when it does not.
|
|
function ER.LearnedHard(id)
|
|
local a = Mine()
|
|
id = tonumber(id)
|
|
if not a or not id then return nil end
|
|
if a.hard[id] == "died" or a.hard[id] == "skip" then return a.hard[id] end
|
|
local title = ER.Steps and ER.Steps.QuestTitle(id)
|
|
local mine = title and ER.GetRating and ER.GetRating(title, id)
|
|
if mine and mine.rating == "hard" then return "rated" end
|
|
return nil
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- Looking every few seconds while a guide runs
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
local lastStep, easyTotal = nil, 0
|
|
|
|
-- A warning line with the gold colour on its "Heads up:" words.
|
|
local function ColourHeadsUp(line)
|
|
if string.sub(line, 1, 9) == "Heads up:" then return GOLD .. "Heads up: " .. END .. string.sub(line, 11) end
|
|
return GOLD .. line .. END
|
|
end
|
|
|
|
local function StepTips()
|
|
local Steps = ER.Steps
|
|
local cur = Steps.Current()
|
|
local key = (Simple() and "list:" or "box:") .. (cur and cur.n or 0)
|
|
for _, s in ipairs(Steps.Side()) do key = key .. "+" .. s.n end
|
|
if key == lastStep then return end
|
|
lastStep = key
|
|
ER.RemoveTips("warn:")
|
|
ER.RemoveTips("hard:")
|
|
ER.RemoveTips("chain:")
|
|
-- With the step box up these are in the box already.
|
|
if not Simple() then return end
|
|
for i, w in ipairs(Steps.Warnings()) do
|
|
if i > 2 then break end
|
|
Tip("warn:" .. i, ColourHeadsUp(w.line))
|
|
end
|
|
if cur then
|
|
local id, title, level = HardQuest(cur)
|
|
if id then
|
|
Tip("hard:" .. id, RED .. "Hard for your level: " .. END .. title .. " is level " .. level .. ", you are " ..
|
|
(UnitLevel("player") or 1) .. ". Kill a few mobs on the way first, or press Skip.")
|
|
end
|
|
local chain = ER.ChainLine and ER.ChainLine(cur)
|
|
if chain then Tip("chain:" .. cur.n, GREY .. chain .. END) end
|
|
end
|
|
end
|
|
|
|
local function GuideTips()
|
|
local Steps = ER.Steps
|
|
local a = Mine()
|
|
if not a then return end
|
|
local info = Steps.Info()
|
|
local key = Steps.Key(info)
|
|
local level = UnitLevel("player") or 1
|
|
|
|
-- Quests left out for being too easy.
|
|
local n = Steps.TakeEasySkipped()
|
|
if n > 0 then
|
|
easyTotal = easyTotal + n
|
|
Tip("easy", "Left out " .. easyTotal .. " quest" .. (easyTotal == 1 and "" or "s") ..
|
|
" that give next to no experience at your level.", nil, 20)
|
|
end
|
|
|
|
-- Outlevelled: ask whether to move on (once a session per guide; "Stay here" for good).
|
|
if Steps.Outlevelled() and not a.stay[key] and not askedNow["move:" .. key] then
|
|
askedNow["move:" .. key] = true
|
|
local nxt = Steps.NextGuide()
|
|
if not nxt or level >= nxt.hi + 2 then nxt = Steps.Suggest()[1] end
|
|
if nxt and nxt ~= info then
|
|
Tip("move", "You are level " .. level .. " and this guide is for " .. info.lo .. "-" .. info.hi ..
|
|
": most of what is left gives little experience. Move on to " .. GOLD .. (nxt.title or nxt.name) .. END .. "?", {
|
|
{ label = "Move on", fn = function() ER.StartGuide(Steps.Key(nxt)) end },
|
|
{ label = "Stay here", fn = function() a.stay[key] = true end },
|
|
})
|
|
end
|
|
end
|
|
|
|
StepTips()
|
|
AskMoney()
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- The class trainer
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
-- What the big levels bring. Class lines are the usual classic ones; Turtle WoW keeps them.
|
|
local MILESTONES = {
|
|
[10] = { all = "Your first talent point: spend it (press N).",
|
|
HUNTER = "Hunters can now tame a pet: ask your class trainer.",
|
|
WARLOCK = "Your trainer has the Voidwalker quest.",
|
|
DRUID = "Your trainer has the Bear Form quest.",
|
|
WARRIOR = "Your trainer has the Defensive Stance quest.",
|
|
SHAMAN = "Your trainer has the fire totem quest." },
|
|
[20] = { all = "Lots of new ranks of your spells.",
|
|
ROGUE = "Your trainer has the poisons quest.",
|
|
DRUID = "Cat Form is ready at your trainer.",
|
|
WARLOCK = "Your trainer has the Succubus quest.",
|
|
SHAMAN = "Your trainer has the water totem quest." },
|
|
[30] = { all = "A big round of new spells.",
|
|
WARRIOR = "Your trainer has the Berserker Stance quest.",
|
|
DRUID = "Travel Form is ready at your trainer.",
|
|
WARLOCK = "Your trainer has the Felhunter quest.",
|
|
SHAMAN = "Your trainer has the air totem quest." },
|
|
[40] = { all = "Riding and your first mount, if you have the gold.",
|
|
HUNTER = "You can wear mail armor now.", SHAMAN = "You can wear mail armor now.",
|
|
WARRIOR = "You can wear plate armor now.", PALADIN = "You can wear plate armor now." },
|
|
}
|
|
|
|
local function OnLevelUp(level)
|
|
local a = Mine()
|
|
if not a then return end
|
|
a.trained = a.trained or (level - 1)
|
|
local _, class = UnitClass("player")
|
|
local m = MILESTONES[level]
|
|
if m then
|
|
local text = GOLD .. "Level " .. level .. "! " .. END .. m.all
|
|
if class and m[class] then text = text .. " " .. m[class] end
|
|
text = text .. " Visit your class trainer for the new spells."
|
|
Tip("trainer", text, nil, 240)
|
|
elseif math.mod(level, 2) == 0 and level - a.trained >= 2 then
|
|
Tip("trainer", "New spells have been waiting since level " .. (a.trained + 1) ..
|
|
". A visit to your class trainer makes the fights easier.", nil, 180)
|
|
end
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- Enemies on the tooltip
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
-- Easy, Medium or Hard for an enemy, and why: { word, why, r, g, b }. nil for players, friends and the dead.
|
|
function ER.RateEnemy(unit)
|
|
if not UnitExists(unit) or UnitIsPlayer(unit) or not UnitCanAttack("player", unit) or UnitIsDead(unit) then return nil end
|
|
local Steps = ER.Steps
|
|
local level = UnitLevel(unit) or 0
|
|
local me = UnitLevel("player") or 1
|
|
local kind = UnitClassification and UnitClassification(unit) or "normal"
|
|
local name = Steps.Singular(UnitName(unit))
|
|
local warned
|
|
if Steps.Running() then
|
|
for _, w in ipairs(Steps.WarnedEnemies()) do
|
|
if w.name == name then warned = true break end
|
|
end
|
|
end
|
|
local hardAt = Steps.Comfort()
|
|
local diff = level - me
|
|
if level <= 0 then return { "Hard", "far above you", 1, 0.25, 0.25 } end
|
|
if kind == "worldboss" or kind == "elite" or kind == "rareelite" then return { "Hard", "elite", 1, 0.25, 0.25 } end
|
|
if warned then return { "Hard", "the guide says to watch out", 1, 0.25, 0.25 } end
|
|
if diff >= hardAt then return { "Hard", diff .. " levels above you", 1, 0.25, 0.25 } end
|
|
if diff >= 1 and diff >= hardAt - 2 then
|
|
return { "Medium", diff .. (diff == 1 and " level" or " levels") .. " above you", 1, 0.82, 0 }
|
|
end
|
|
if kind == "rare" then return { "Medium", "rare", 1, 0.82, 0 } end
|
|
if level <= Steps.GreyLevel(me) then return { "Easy", "no experience", 0.6, 0.6, 0.6 } end
|
|
return { "Easy", nil, 0.25, 0.85, 0.25 }
|
|
end
|
|
|
|
-- Adds the line to the tooltip of the enemy under the mouse, once.
|
|
local function RateTooltip()
|
|
if not (ER.db and not ER.db.rateOff) then return end
|
|
if not UnitExists("mouseover") then return end
|
|
local first = getglobal("GameTooltipTextLeft1")
|
|
if not first or first:GetText() ~= UnitName("mouseover") then return end
|
|
local lines = GameTooltip:NumLines() or 0
|
|
for i = 2, lines do
|
|
local line = getglobal("GameTooltipTextLeft" .. i)
|
|
local text = line and line:GetText()
|
|
if text == "Easy" or text == "Medium" or text == "Hard" then return end
|
|
end
|
|
local r = ER.RateEnemy("mouseover")
|
|
if not r then return end
|
|
-- Just the word, in its colour (the reason stays in ER.RateEnemy).
|
|
GameTooltip:AddLine(r[1], r[3], r[4], r[5])
|
|
GameTooltip:Show()
|
|
end
|
|
|
|
-- A frame inside the tooltip is shown each time the tooltip is, the way pfQuest adds its lines; the mouseover event
|
|
-- catches going straight from one enemy to the next, when the tooltip never hides in between.
|
|
local hook = CreateFrame("Frame", "EasyRouteTooltipHook", GameTooltip)
|
|
hook:SetScript("OnShow", RateTooltip)
|
|
hook:RegisterEvent("UPDATE_MOUSEOVER_UNIT")
|
|
hook:SetScript("OnEvent", function()
|
|
if GameTooltip:IsVisible() then RateTooltip() end
|
|
end)
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- Caves you walk into
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
local CAVE_TIP_LIFE = 30 -- seconds the heads-up stays in the tips box
|
|
|
|
-- Lower-case sub-zone name -> "mine", "crypt" or "cave", built once from DataSurvival.lua (every zone's lines are "name, a tab, word").
|
|
local caveMap
|
|
local function CaveMap()
|
|
if caveMap then return caveMap end
|
|
caveMap = {}
|
|
local zones = type(EasyRoute_Survival) == "table" and EasyRoute_Survival.caves
|
|
if type(zones) ~= "table" then return caveMap end
|
|
for _, lines in pairs(zones) do
|
|
if type(lines) == "string" then
|
|
for line in string.gfind(lines, "[^\n]+") do
|
|
local _, _, name, word = string.find(line, "^(.-)\t(.+)$")
|
|
local key = name and string.lower(name)
|
|
if key and not caveMap[key] then caveMap[key] = word end
|
|
end
|
|
end
|
|
end
|
|
return caveMap
|
|
end
|
|
|
|
-- The sub-zone you are in, from the zone text or else the minimap's.
|
|
local function SubZone()
|
|
local sub = GetSubZoneText and GetSubZoneText()
|
|
if (not sub or sub == "") and GetMinimapZoneText then sub = GetMinimapZoneText() end
|
|
return sub or ""
|
|
end
|
|
|
|
-- The place you were in at the last look; the heads-up comes once each time you walk into a cave.
|
|
local lastCaveSub
|
|
local function CaveWatch()
|
|
local sub = SubZone()
|
|
if sub == lastCaveSub then return end
|
|
lastCaveSub = sub
|
|
local word = sub ~= "" and CaveMap()[string.lower(sub)]
|
|
if word and ER.Steps and ER.Steps.CaveLine then
|
|
Tip("cave:" .. sub, ColourHeadsUp(ER.Steps.CaveLine(word)), nil, CAVE_TIP_LIFE)
|
|
end
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- Events
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
local watch = CreateFrame("Frame", "EasyRouteAdapt")
|
|
watch:RegisterEvent("PLAYER_LEVEL_UP")
|
|
watch:RegisterEvent("TRAINER_SHOW")
|
|
watch:RegisterEvent("PLAYER_ENTERING_WORLD")
|
|
watch:RegisterEvent("PLAYER_DEAD")
|
|
watch:SetScript("OnEvent", function()
|
|
local a = Mine()
|
|
if not a then return end
|
|
if event == "PLAYER_LEVEL_UP" then
|
|
OnLevelUp(tonumber(arg1) or (UnitLevel("player") or 1))
|
|
elseif event == "TRAINER_SHOW" then
|
|
a.trained = UnitLevel("player") or 1
|
|
if ER.RemoveTip then ER.RemoveTip("trainer") end
|
|
elseif event == "PLAYER_ENTERING_WORLD" then
|
|
a.trained = a.trained or (UnitLevel("player") or 1)
|
|
elseif event == "PLAYER_DEAD" then
|
|
OnDeath()
|
|
end
|
|
end)
|
|
watch.wait = 0
|
|
watch:SetScript("OnUpdate", function()
|
|
this.wait = this.wait + arg1
|
|
if this.wait < 2 then return end
|
|
this.wait = 0
|
|
if not (ER.db and ER.Steps and ER.Steps.Running() and ER.AddTip) then
|
|
lastCaveSub = nil
|
|
return
|
|
end
|
|
CaveWatch()
|
|
GuideTips()
|
|
local a = Mine()
|
|
if a then CheckIn(a) end
|
|
end)
|
|
|
|
ER.Loaded("Adapt.lua")
|