Files
EasyRoute/Director.lua
T
notforever-ship-it 100b66222d Release 0.5.2: wizard opens on a new character, easier Casual, credit on every window
The guide wizard opens by itself the first time on each character and starts with the difficulty question. Casual never offers quests above your level (Medium up to 2 above, Hard up to 4). Every window says Made by stealthzi and the version at the bottom.
2026-10-07 21:38:31 +01:00

534 lines
21 KiB
Lua

-- Easy Route director: instead of one fixed route, it looks at where you are and what level you are and says
-- what is worth doing here, in what order, which chains are worth following, where to grind for a break
-- and when the area is used up. No windows in this file, only decisions, so it can be tested away from the game.
--
-- The facts come from Data\Zones.lua (quests by zone), Data\Mobs.lua (where ordinary mobs of each level stand)
-- and Data\Quests.lua (the order a leveling route does things in, used as a hint of which quests are good).
local ER = EasyRoute
-- The three moods. behind and ahead: how far below and above your level a quest may be. leaveAt: when this many
-- or fewer quests are left that fit, the director asks whether to move on. elites: quests with a group-sized kill
-- target stay in the list. travel: how much a long walk counts against a quest. prefer: the quest level, compared
-- with yours, that ranks best (Casual likes quests a little below you, Hard a little above).
ER.MODES = {
casual = { label = "Casual", behind = 6, ahead = 0, prefer = -1, leaveAt = 2, elites = false, hard = false, travel = 0.10,
tip = "No stress. Nothing above your level, and nothing hard, grouped or crowded. Does nearly everything in an area before moving on." },
medium = { label = "Medium", behind = 4, ahead = 2, prefer = 0.5, leaveAt = 4, elites = false, hard = true, travel = 0.07,
tip = "A good few quests per area, a little above your level for some challenge, still no group quests." },
normal = { label = "Hard", behind = 2, ahead = 4, prefer = 1, leaveAt = 6, elites = true, hard = true, travel = 0.05,
tip = "Harder quests, fewer per area, and it moves on sooner. Group quests are listed with a warning." },
}
ER.MODE_ORDER = { "casual", "medium", "normal" }
-- Mobs for the grind suggestions: never more than this far below you, and this far above.
ER.GRIND_BEHIND = 1
ER.GRIND_AHEAD = 2
-- Places that are not for leveling a character: dungeons, raids, cities, and the game masters' island.
local NOT_LEVELING = {
["razorfen kraul"] = true, ["gnomeregan"] = true, ["blackfathom deeps"] = true, ["razorfen downs"] = true,
["zul'farrak"] = true, ["uldaman"] = true, ["the temple of atal'hakkar"] = true, ["blackrock spire"] = true,
["blackrock depths"] = true, ["blackrock mountain"] = true, ["zul'gurub"] = true, ["stratholme"] = true,
["maraudon"] = true, ["ragefire chasm"] = true, ["dire maul"] = true, ["alterac valley"] = true,
["blackwing lair"] = true, ["ahn'qiraj"] = true, ["tower of karazhan"] = true, ["scarlet monastery graveyard"] = true,
["gm island"] = true, ["deeprun tram"] = true, ["stormwind city"] = true, ["ironforge"] = true, ["orgrimmar"] = true,
["undercity"] = true, ["deadwind pass"] = true, ["moonglade"] = true, ["winter veil vale"] = true,
["lapidis isle"] = true, ["gillijim's isle"] = true,
}
------------------------------------------------------------------------------------------------------
-- Who you are
------------------------------------------------------------------------------------------------------
local RACE_BITS = { Human = 1, Orc = 2, Dwarf = 4, NightElf = 8, Scourge = 16, Undead = 16, Tauren = 32, Gnome = 64, Troll = 128,
Goblin = 256, HighElf = 512 }
local CLASS_BITS = { WARRIOR = 1, PALADIN = 2, HUNTER = 4, ROGUE = 8, PRIEST = 16, SHAMAN = 64, MAGE = 128, WARLOCK = 256, DRUID = 1024 }
local RACE_LIST = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 }
local ALLIANCE_MASK = 1 + 4 + 8 + 64 + 512
local HORDE_MASK = 2 + 16 + 32 + 128 + 256
local function HasBit(mask, bit)
if not mask or not bit or bit == 0 then return false end
return math.mod(math.floor(mask / bit), 2) == 1
end
-- Race bit, class bit and the mask of the whole faction for the character playing.
function ER.PlayerMasks()
local _, raceToken = UnitRace("player")
local _, classToken = UnitClass("player")
local faction = UnitFactionGroup("player")
local factionMask = faction == "Horde" and HORDE_MASK or ALLIANCE_MASK
return RACE_BITS[raceToken or ""] or 0, CLASS_BITS[classToken or ""] or 0, factionMask
end
-- Can this character take the quest at all? A quest for another race or class is not offered. A race this
-- file does not know falls back to the faction.
local function ForMe(q, raceBit, classBit, factionMask)
if q.r then
if raceBit ~= 0 then
if not HasBit(q.r, raceBit) then return false end
else
local ok = false
for _, bit in ipairs(RACE_LIST) do
if HasBit(factionMask, bit) and HasBit(q.r, bit) then ok = true end
end
if not ok then return false end
end
end
if q.c and classBit ~= 0 and not HasBit(q.c, classBit) then return false end
return true
end
------------------------------------------------------------------------------------------------------
-- What you have already done, and what you said no to
------------------------------------------------------------------------------------------------------
local function DoneTable()
if not ER.db then return {} end
if type(ER.db.done) ~= "table" then ER.db.done = {} end
local char = ER.Char()
if type(ER.db.done[char]) ~= "table" then
ER.db.done[char] = {}
-- First time: learn from the journal what this character already handed in.
for _, e in ipairs(ER.db.journal or {}) do
if e.t == "turnin" and e.char == char and e.title then
ER.db.done[char][e.pfid or e.title] = true
ER.db.done[char][e.title] = true
end
end
end
return ER.db.done[char]
end
function ER.MarkDone(title, pfid)
local done = DoneTable()
if title then done[title] = true end
if pfid then done[pfid] = true end
end
-- Remember every hand-in from now on (the recorder logs them as "turnin").
local plainLog = ER.Log
function ER.Log(kind, fields)
local entry = plainLog(kind, fields)
if kind == "turnin" and entry and entry.title then ER.MarkDone(entry.title, entry.pfid) end
return entry
end
function ER.IsDone(q)
local done = DoneTable()
return done[q.id] or done[q.n] or false
end
local function Skipped(q)
return ER.db and type(ER.db.skipped) == "table" and ER.db.skipped[q.id] or false
end
-- "Not today": the director stops suggesting this quest. /er unskip brings them all back.
function ER.SkipQuest(id)
if not ER.db then return end
if type(ER.db.skipped) ~= "table" then ER.db.skipped = {} end
ER.db.skipped[id] = true
end
function ER.ClearSkipped()
if ER.db then ER.db.skipped = {} end
end
local function InLog(q)
local known = ER.Recorder and ER.Recorder.Known and ER.Recorder.Known()
return known and known[q.n] or false
end
------------------------------------------------------------------------------------------------------
-- Zones and chains
------------------------------------------------------------------------------------------------------
local zoneByName, byId, followers
local function BuildIndex()
if zoneByName then return end
zoneByName, byId, followers = {}, {}, {}
for zid, z in pairs(EasyRoute_Zones or {}) do
zoneByName[string.lower(z.name)] = zid
for i = 1, table.getn(z.q) do
local q = z.q[i]
q.zone = zid
byId[q.id] = q
if q.p then
if not followers[q.p] then followers[q.p] = {} end
table.insert(followers[q.p], q.id)
end
end
end
end
function ER.ZoneId(name)
BuildIndex()
if not name then return nil end
return zoneByName[string.lower(name)]
end
function ER.ZoneRows(zid)
local z = EasyRoute_Zones and EasyRoute_Zones[zid]
return z and z.q or {}, z and z.name
end
-- A quest's place in its chain: { first = id, ids = {all, in order}, pos = this one's step, len = how many }.
-- nil when it stands alone.
function ER.ChainOf(id)
BuildIndex()
local q = byId[id]
if not q then return nil end
local seen, first, steps = { [id] = true }, id, 0
while byId[first] and byId[first].p and byId[byId[first].p] and not seen[byId[first].p] and steps < 40 do
first = byId[first].p
seen[first] = true
steps = steps + 1
end
local ids, cur, guard = { first }, first, 0
while followers[cur] and guard < 40 do
local nxt
for _, f in ipairs(followers[cur]) do
if not nxt or (byId[f] and byId[f].zone == byId[first].zone) then nxt = f end
end
if not nxt then break end
table.insert(ids, nxt)
cur = nxt
guard = guard + 1
end
if table.getn(ids) < 2 then return nil end
local pos
for i, v in ipairs(ids) do if v == id then pos = i end end
return { first = first, ids = ids, pos = pos or 1, len = table.getn(ids) }
end
-- The database has a few absurd experience numbers (custom quests); a quest is never counted for more than
-- a generous amount for its level.
local function XP(q)
if not q.xp then return 0 end
return math.min(q.xp, q.l * 120 + 300)
end
ER.QuestXP = XP
-- The chain's total: levels it spans, experience (when known), and whether anything in it gives an item.
function ER.ChainSummary(chain)
BuildIndex()
local lo, hi, xp, rewards, names = 99, 0, 0, false, {}
for _, id in ipairs(chain.ids) do
local q = byId[id]
if q then
if q.l < lo then lo = q.l end
if q.l > hi then hi = q.l end
xp = xp + XP(q)
if q.rw then rewards = true end
table.insert(names, q.n)
end
end
return { lo = lo, hi = hi, xp = xp, rewards = rewards, names = names }
end
------------------------------------------------------------------------------------------------------
-- Which quests, and in what order
------------------------------------------------------------------------------------------------------
local function Colour(diff)
if diff >= 5 then return "red" elseif diff >= 3 then return "orange" elseif diff >= -2 then return "yellow" end
return "green"
end
ER.QuestColour = Colour
-- A set of the quest ids the leveling route (Data\Quests.lua) does: a hint that a quest is a good one.
local onRoute
local function RouteSet(faction)
if onRoute then return onRoute end
onRoute = {}
local guides = EasyRoute_Quests and EasyRoute_Quests[faction]
if guides then
for _, g in ipairs(guides) do
for _, q in ipairs(g.quests) do onRoute[q.id] = true end
end
end
return onRoute
end
-- Ratings you gave in the notebook count: skip is never offered, hard is left out in casual, easy goes first.
local function Opinion(q, mode)
local r = ER.db and ER.db.ratings and ER.db.ratings[q.n]
if not r then return 0 end
if r.rating == "skip" then return nil end
local tags = r.tags or {}
if mode.elites == false and tags.group then return nil end
local score = 0
if r.rating == "hard" then
if not mode.hard then return nil end
score = score - 3
elseif r.rating == "easy" then
score = score + 2
end
if tags.nocombat then score = score + 1.5 end
if tags.walk then score = score - 2 end
if tags.crowded and not mode.hard then score = score - 2 end
return score
end
local function Distance(ax, ay, bx, by)
if not ax or not bx then return 0 end
local dx, dy = ax - bx, ay - by
return math.sqrt(dx * dx + dy * dy)
end
-- The list of quests worth doing in a zone: { q = row, score, diff, colour, chain }, best first.
-- px, py: where you stand (map percent), so nearby quests rank higher. Pass nil to ignore distance.
function ER.Candidates(zid, level, modeKey, px, py)
local mode = ER.MODES[modeKey] or ER.MODES.casual
local rows = ER.ZoneRows(zid)
local raceBit, classBit, factionMask = ER.PlayerMasks()
local faction = factionMask == HORDE_MASK and "Horde" or "Alliance"
local route = RouteSet(faction)
local out = {}
for i = 1, table.getn(rows) do
local q = rows[i]
local diff = q.l - level
if diff <= mode.ahead and diff >= -mode.behind and (q.m or 1) <= level
and ForMe(q, raceBit, classBit, factionMask) and not ER.IsDone(q) and not Skipped(q) and not InLog(q)
and (mode.elites or not q.e) then
local opinion = Opinion(q, mode)
if opinion then
-- Closer to your level is better; a quest above you counts a little less than one below.
local score = 10 - math.abs(diff - (mode.prefer or 0.5)) * 1.5 + opinion
local chain = ER.ChainOf(q.id)
if chain then
if chain.len >= 3 then score = score + 2 end
-- A middle step is only worth it if the earlier steps are done or already in hand.
if chain.pos > 1 then
local prev = byId[chain.ids[chain.pos - 1]]
if prev and not ER.IsDone(prev) then score = score - 6 end
end
end
if route[q.id] then score = score + 1.5 end
if q.rw then score = score + (q.rw >= 10 and 2 or 1) end
if q.xp then score = score + math.log(1 + XP(q)) / 4 end
if q.e then score = score - 4 end
score = score - Distance(px, py, q.x, q.y) * mode.travel
table.insert(out, { q = q, score = score, diff = diff, colour = Colour(diff), chain = chain })
end
end
end
table.sort(out, function(a, b) return a.score > b.score end)
return out
end
-- Quests handed out close together make a "stop": gather them all in one visit. Hubs are listed best first.
-- Each hub: { x, y, giver, items = {candidates}, score, xp }.
function ER.Hubs(candidates, px, py, modeKey)
local mode = ER.MODES[modeKey] or ER.MODES.casual
local hubs = {}
for _, c in ipairs(candidates) do
local home
for _, h in ipairs(hubs) do
if Distance(h.x, h.y, c.q.x, c.q.y) <= 7 then home = h break end
end
if not home then
home = { x = c.q.x, y = c.q.y, giver = c.q.g or "somebody", items = {}, score = 0, xp = 0 }
table.insert(hubs, home)
end
table.insert(home.items, c)
-- Only the best few at a stop count for its score, so a huge pile does not outweigh a better place.
if table.getn(home.items) <= 6 then home.score = home.score + c.score end
home.xp = home.xp + XP(c.q)
end
for _, h in ipairs(hubs) do
h.score = h.score - Distance(px, py, h.x, h.y) * mode.travel * 3
end
table.sort(hubs, function(a, b) return a.score > b.score end)
return hubs
end
-- Other zones that suit this level and mode, for when this one is used up. The leveling route's own next
-- zone gets a lift. Each: { zid, name, count, xp, giver, x, y }.
function ER.WhereNext(level, modeKey, fromZone)
BuildIndex()
local mode = ER.MODES[modeKey] or ER.MODES.casual
local _, _, factionMask = ER.PlayerMasks()
local faction = factionMask == HORDE_MASK and "Horde" or "Alliance"
local routeZone = {}
local guides = EasyRoute_Quests and EasyRoute_Quests[faction]
if guides then
for _, g in ipairs(guides) do
-- Inside the band, not at its very end: a zone you are about to finish is not where to go next.
if level >= g.lo and level < g.hi then routeZone[string.lower(g.zone)] = true end
end
end
local out = {}
for zid, z in pairs(EasyRoute_Zones or {}) do
if zid ~= fromZone and not NOT_LEVELING[string.lower(z.name)] then
local list = ER.Candidates(zid, level, modeKey, nil, nil)
local n, xp = table.getn(list), 0
if n >= 3 then
local hubs = ER.Hubs(list, nil, nil, modeKey)
local best = hubs[1]
for _, h in ipairs(hubs) do xp = xp + h.xp end
local score = math.min(n, 25) + (routeZone[string.lower(z.name)] and 10 or 0)
table.insert(out, { zid = zid, name = z.name, count = n, xp = xp, giver = best.giver, x = best.x, y = best.y, score = score })
end
end
end
table.sort(out, function(a, b) return a.score > b.score end)
return out
end
-- Chains worth following, from what is on offer here: three or more quests, best first. A chain with a
-- reward at its end, more quests and more experience counts for more. Each: { name, len, lo, hi, xp,
-- rewards, start = the candidate to begin (or carry on) with }.
function ER.ChainIdeas(candidates, want)
local best = {}
for _, c in ipairs(candidates) do
if c.chain and c.chain.len >= 3 then
local have = best[c.chain.first]
if not have or c.chain.pos < have.chain.pos then best[c.chain.first] = c end
end
end
local out = {}
for first, c in pairs(best) do
local sum = ER.ChainSummary(c.chain)
local root = byId[first]
table.insert(out, { name = root and root.n or c.q.n, len = c.chain.len, lo = sum.lo, hi = sum.hi, xp = sum.xp,
rewards = sum.rewards, start = c, value = c.chain.len + (sum.rewards and 4 or 0) + math.min(sum.xp, 6000) / 1000 })
end
table.sort(out, function(a, b) return a.value > b.value end)
local trimmed = {}
for i = 1, math.min(want or 3, table.getn(out)) do table.insert(trimmed, out[i]) end
return trimmed
end
------------------------------------------------------------------------------------------------------
-- Grinding for a break
------------------------------------------------------------------------------------------------------
local mobCache = {}
local function MobGroups(zid)
if mobCache[zid] then return mobCache[zid] end
local groups = {}
local text = EasyRoute_Mobs and EasyRoute_Mobs[zid]
if text then
for entry in string.gfind(text, "([^;]+)") do
local _, _, name, lo, hi, x, y, n = string.find(entry, "^(.-),(%d+),(%d+),([%d%.]+),([%d%.]+),(%d+)$")
if name then
table.insert(groups, { name = name, lo = tonumber(lo), hi = tonumber(hi), x = tonumber(x), y = tonumber(y), n = tonumber(n) })
end
end
end
mobCache[zid] = groups
return groups
end
-- Where to grind between quests: groups of ordinary mobs from one level below you to two above, with
-- no elites. Nearby groups join into one spot. Returns up to `want` spots, best first:
-- { x, y, lo, hi, count, mobs = {names, most common first}, distance }.
function ER.GrindSpots(zid, level, px, py, want)
local behind, ahead = ER.GRIND_BEHIND, ER.GRIND_AHEAD
local spots = {}
for _, g in ipairs(MobGroups(zid)) do
if g.lo >= level - behind and g.hi <= level + ahead then
local home
for _, s in ipairs(spots) do
if Distance(s.x, s.y, g.x, g.y) <= 9 then home = s break end
end
if not home then
home = { x = g.x, y = g.y, lo = g.lo, hi = g.hi, count = 0, tally = {} }
table.insert(spots, home)
end
-- The spot's centre drifts toward where the most mobs are.
home.x = (home.x * home.count + g.x * g.n) / (home.count + g.n)
home.y = (home.y * home.count + g.y * g.n) / (home.count + g.n)
home.count = home.count + g.n
if g.lo < home.lo then home.lo = g.lo end
if g.hi > home.hi then home.hi = g.hi end
home.tally[g.name] = (home.tally[g.name] or 0) + g.n
end
end
for _, s in ipairs(spots) do
s.distance = Distance(px, py, s.x, s.y)
s.mobs = {}
for name, n in pairs(s.tally) do table.insert(s.mobs, { name = name, n = n }) end
table.sort(s.mobs, function(a, b) return a.n > b.n end)
local names = {}
for i = 1, math.min(3, table.getn(s.mobs)) do table.insert(names, s.mobs[i].name) end
s.mobs = names
s.tally = nil
-- Plenty of mobs, close to you, and at your level rather than below it.
s.score = math.min(s.count, 30) - s.distance * 0.5 + (s.lo >= level and 3 or 0)
end
table.sort(spots, function(a, b) return a.score > b.score end)
local out = {}
for i = 1, math.min(want or 3, table.getn(spots)) do table.insert(out, spots[i]) end
return out
end
------------------------------------------------------------------------------------------------------
-- Putting it together
------------------------------------------------------------------------------------------------------
-- Everything the director window needs for where you stand: the zone's stops, whether it is time to move
-- on (and where to), and grind spots for a break. zoneName, level, modeKey, px, py default to now.
function ER.Plan(zoneName, level, modeKey, px, py)
level = level or UnitLevel("player") or 1
modeKey = modeKey or ER.Mode()
if not zoneName then
local zone, _, x, y = ER.Where()
zoneName, px, py = zone, px or x, py or y
end
local zid = ER.ZoneId(zoneName)
local plan = { zone = zoneName, zid = zid, level = level, mode = modeKey, hubs = {}, count = 0, grind = {}, next = {}, chains = {} }
if not zid then return plan end
local list = ER.Candidates(zid, level, modeKey, px, py)
plan.count = table.getn(list)
plan.hubs = ER.Hubs(list, px, py, modeKey)
plan.chains = ER.ChainIdeas(list, 3)
plan.grind = ER.GrindSpots(zid, level, px, py, 3)
local mode = ER.MODES[modeKey]
plan.leave = plan.count <= mode.leaveAt
if plan.leave then plan.next = ER.WhereNext(level, modeKey, zid) end
return plan
end
-- A quest's row in the data, by id, and whether it is in your quest log now (the wizard uses both).
function ER.QuestRow(id)
BuildIndex()
return byId[id]
end
ER.InLog = InLog
function ER.Mode()
local key = ER.db and ER.db.mode
if ER.MODES[key] then return key end
return "casual"
end
function ER.SetMode(key)
if not ER.MODES[key] then return end
ER.db.mode = key
ER.Print("mode is now " .. ER.GOLD .. ER.MODES[key].label .. ER.END .. ". " .. ER.MODES[key].tip)
if ER.RefreshDirector then ER.RefreshDirector() end
end
-- A sentence about one suggestion: why it is on the list.
function ER.WhyQuest(c)
local q = c.q
local parts = {}
local d = c.diff
if d == 0 then table.insert(parts, "your level")
elseif d > 0 then table.insert(parts, d .. " above you")
else table.insert(parts, (-d) .. " below you") end
if c.chain then
table.insert(parts, "step " .. c.chain.pos .. " of a " .. c.chain.len .. "-quest chain")
end
if q.xp then table.insert(parts, XP(q) .. " xp") end
if q.rw then table.insert(parts, q.rw >= 10 and "choose a reward" or "gives an item") end
if q.e then table.insert(parts, "needs a group") end
return table.concat(parts, ", ")
end