A leveling guide for WoW 1.12 players of pfQuest, based on Easy Route by stealthzi (MIT). See README.md and CHANGES.md. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XfR1apt9f3R7SxBKB2FF2D
337 lines
20 KiB
Lua
337 lines
20 KiB
Lua
-- [PFUI=1] texlua bethink.lua <addon> <race> <class> 1 casual
|
|
-- VanillaGuide's guides (Joana's and Brian Kopps'): their own groups in the guide menu after Bethink's, a guide for your
|
|
-- race's start, steps in the guide's words with its quest names matched to quests, and playing through into the next.
|
|
local here = arg[0]:match("^(.*)/") or "."
|
|
dofile(here .. "/lib.lua")
|
|
local W, ER, S, P = H.W, H.ER, H.S, H.P
|
|
local fails = 0
|
|
local function check(ok, what) if not ok then fails = fails + 1; P("FAIL " .. what) else P("ok " .. what) end end
|
|
local function strip(s) return (L53.gsub(L53.gsub(s or "", "|c%x%x%x%x%x%x%x%x", ""), "|r", "")) end
|
|
local function F(n) return _G["pfQuest_xpGuide" .. n] end
|
|
local function settle() W.Fire("QUEST_LOG_UPDATE"); W.Tick(0.4, 4); W.Tick(3, 1); ER.StepsChanged() end
|
|
local function logIdx(title) for i, q in ipairs(W.log) do if q.title == title then return i end end end
|
|
W.Tick(3, 3)
|
|
check(type(pfQuest_xpGuide_VanillaGuide) == "table" and table.getn(ER.MissingFiles()) == 0, "Data\\VanillaGuide.lua loaded (" .. tostring(pfQuest_xpGuide_VanillaGuide and pfQuest_xpGuide_VanillaGuide.guides) .. " guides)")
|
|
-- the groups: casual, fast routes, then Bethink's by level
|
|
local groups = S.Groups()
|
|
local names = {}
|
|
for _, g in ipairs(groups) do table.insert(names, ER.GroupLabel(g.name) .. "(" .. table.getn(g.guides) .. ")") end
|
|
P("note groups: " .. table.concat(names, ", "))
|
|
local firstB, lastBethink
|
|
for i, g in ipairs(groups) do
|
|
if g.guides[1].vanilla then firstB = firstB or i elseif g.guides[1].bethink then lastBethink = i end
|
|
end
|
|
check(firstB and lastBethink and firstB > lastBethink and groups[firstB].name == "VanillaGuide 1-20" and groups[table.getn(groups)].guides[1].vanilla, "VanillaGuide groups come last, after Bethink's, from 1-20")
|
|
local _, _, faction = UnitFactionGroup and UnitFactionGroup("player")
|
|
for _, g in ipairs(groups) do for _, x in ipairs(g.guides) do
|
|
if x.vanilla then check(x.faction == (UnitFactionGroup("player")), " ...only your faction's") break end
|
|
end end
|
|
-- the menu shows them all
|
|
ER.ShowGuideMenu()
|
|
local shown = 0
|
|
for i = 1, 16 do local r = F("GuideMenuGroup" .. i) if r and r:IsShown() and r.grp then shown = shown + 1 end end
|
|
check(shown == table.getn(groups), "the guide menu lists every group (" .. shown .. " of " .. table.getn(groups) .. ")")
|
|
F("Settings"):Hide()
|
|
-- the starting zone guide for your race
|
|
local _, race = UnitRace("player")
|
|
local start
|
|
for _, g in ipairs(S.Guides()) do if g.vanilla and g.lo == 1 and S.Applies(g.defaultFor) then start = g end end
|
|
check(start ~= nil, "a VanillaGuide guide for your race's start: " .. tostring(start and start.title))
|
|
if not start then P(fails .. " FAILED") REPORT() return end
|
|
check(ER.StartGuide(S.Key(start), true, true), " ...it starts")
|
|
ER.ShowTracker(); settle()
|
|
local function boxLines() local t = {} for j = 1, 12 do local b = F("GuideLine" .. j) if b and b:IsShown() then table.insert(t, strip(b.text._text)) end end return t end
|
|
-- a step in Bethink's words, quest names filled in, no {q...} left
|
|
local wordsSeen, tagsLeft, sampleAll = 0, 0, ""
|
|
for _, it in ipairs(S.All()) do
|
|
for _, e in ipairs(it.step.elements) do
|
|
local l = S.Line(it.step, e)
|
|
if l and e.kind == "I" then
|
|
wordsSeen = wordsSeen + 1
|
|
if string.find(l.text, "{q", 1, true) then tagsLeft = tagsLeft + 1 end
|
|
sampleAll = sampleAll .. l.text
|
|
end
|
|
end
|
|
end
|
|
check(wordsSeen > 10 and tagsLeft == 0 and not string.find(sampleAll or "", "#", 1, true), "steps keep the guide's words (" .. wordsSeen .. " lines), its tags turned into colours")
|
|
local sample
|
|
for _, it in ipairs(S.All()) do for _, e in ipairs(it.step.elements) do if e.kind == "I" and e.text and string.find(e.text, "|cffffd100", 1, true) and not sample then sample = S.Line(it.step, e).text end end end
|
|
local tracked = 0
|
|
for _, it in ipairs(S.All()) do for _, e in ipairs(it.step.elements) do if e.kind == "A" or e.kind == "C" or e.kind == "T" then tracked = tracked + 1 end end end
|
|
check(tracked > 10, "its quests are followed in the quest log (" .. tracked .. " pick-ups, objectives and hand-ins)")
|
|
P("note e.g. \"" .. strip(sample or "") .. "\"")
|
|
-- the arrow follows the step part by part: the quest giver for a quest to pick up, the guide's spot once it is accepted
|
|
do
|
|
-- the first step that picks up a quest (a guide may open with a few words only)
|
|
for _, it in ipairs(S.All()) do
|
|
local has = false
|
|
for _, e in ipairs(it.step.elements) do if e.kind == "A" then has = true end end
|
|
if has then if it.step.n ~= S.Position() then S.Jump(it.step.n) settle() end break end
|
|
end
|
|
local first = S.Current()
|
|
local qa, spot
|
|
for _, e in ipairs(first.elements) do
|
|
if e.kind == "A" and not qa then qa = e.id end
|
|
if e.kind == "G" then spot = e end
|
|
end
|
|
local row = qa and ER.QuestRow(qa)
|
|
local tg = S.Target()
|
|
local gx, gy, gname
|
|
if row then gx, gy, gname = row.x, row.y, row.g
|
|
else local _, px, py = ER.RoutePickUpPlace(qa) gx, gy, gname = px, py, "" end
|
|
check(gx and tg and math.abs(tg.x - gx) < 0.01 and math.abs(tg.y - gy) < 0.01 and strip(tg.text or ""):find(gname or "?", 1, true),
|
|
"the first step's arrow points at the quest giver: " .. strip(tg and tg.text or "none") .. " (" .. (tg and (tg.x .. ", " .. tg.y) or "?") .. ")")
|
|
local hasC = false
|
|
for _, e in ipairs(first.elements) do if e.kind == "C" then hasC = true end end
|
|
if hasC and spot then
|
|
table.insert(W.log, { id = qa, title = S.QuestTitle(qa), level = S.QuestLevel(qa) or 1, objs = { { text = "x: 0/1", done = false } } })
|
|
settle()
|
|
tg = S.Target()
|
|
check(S.Current() == first and tg and math.abs(tg.x - spot.x) < 0.01 and math.abs(tg.y - spot.y) < 0.01,
|
|
" ...accepted, it points at the guide's spot for doing it (" .. (tg and (tg.x .. ", " .. tg.y) or "?") .. ")")
|
|
table.remove(W.log, logIdx(S.QuestTitle(qa))); settle()
|
|
S.Jump(first.n); settle()
|
|
end
|
|
end
|
|
-- every pick-up step of every guide of this faction: the arrow at the quest giver (when the quest data has the giver in
|
|
-- the step's zone)
|
|
do
|
|
local sizes = pfQuest_xpGuide_ZoneSizes or {}
|
|
local checked, off = 0, {}
|
|
local keep = S.Key(S.Info())
|
|
for _, g in ipairs(S.Guides()) do
|
|
if g.vanilla and ER.StartGuide(S.Key(g), true, true) then
|
|
for _, it in ipairs(S.All()) do
|
|
local st = it.step
|
|
local qa, quests = nil, 0
|
|
for _, e in ipairs(st.elements) do
|
|
if (e.kind == "A" or e.kind == "C" or e.kind == "T") then quests = quests + 1 qa = qa or e end
|
|
end
|
|
if qa and quests == 1 and qa.kind == "A" and not S.InLog(qa.id) and not S.TurnedIn(qa.id) then
|
|
local row = ER.QuestRow(qa.id)
|
|
local z = row and pfQuest_xpGuide_Zones[row.zone]
|
|
local tg = S.PartPlace(st)
|
|
if row and z and tg and tg.zone == z.name then
|
|
checked = checked + 1
|
|
if math.abs(tg.x - row.x) > 0.01 or math.abs(tg.y - row.y) > 0.01 then table.insert(off, g.title .. " " .. st.n) end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
check(checked > 50 and table.getn(off) == 0, "every pick-up step points at its quest giver (" .. checked .. " steps" .. (table.getn(off) > 0 and (", off: " .. table.concat(off, ", ")) or "") .. ")")
|
|
ER.StartGuide(keep, true, true); settle()
|
|
end
|
|
-- a quest the guide only says to "go do" (no tag) is not passed over: before its follow-up is picked up, there is a
|
|
-- "Finish" step for it and its hand-in (Teldrassil: The Balance of Nature, then its part 2)
|
|
if S.Info().title == "1-6 Teldrassil" then
|
|
local function stepOf(kind, id) for _, it in ipairs(S.All()) do for _, e in ipairs(it.step.elements) do if e.kind == kind and tonumber(e.id) == id then return it.step end end end end
|
|
local a1, c1, t1, a2 = stepOf("A", 456), stepOf("C", 456), stepOf("T", 456), stepOf("A", 457)
|
|
check(a1 and c1 and t1 and a2 and a1.n < c1.n and c1.n < a2.n and t1.n <= a2.n,
|
|
"The Balance of Nature: pick up (" .. tostring(a1 and a1.n) .. "), finish (" .. tostring(c1 and c1.n) .. "), hand in (" .. tostring(t1 and t1.n) .. ") before part 2 (" .. tostring(a2 and a2.n) .. ")")
|
|
S.Jump(a1.n); settle()
|
|
table.insert(W.log, { id = 456, title = S.QuestTitle(456), level = S.QuestLevel(456) or 2, objs = { { text = "Young Nightsaber slain: 0/7", done = false } } })
|
|
settle()
|
|
check(S.Position() == c1.n, " ...accepted, the guide waits at its Finish step (" .. S.Position() .. ")")
|
|
local tg = S.Target()
|
|
check(tg and tg.zone == "Teldrassil" and strip(tg.text or ""):find("Finish", 1, true), " ...the arrow at where it is done: " .. strip(tg and tg.text or "none") .. " (" .. (tg and (tg.x .. ", " .. tg.y) or "?") .. ")")
|
|
local i = logIdx(S.QuestTitle(456)); W.log[i].complete = true; W.log[i].objs[1].done = true; settle()
|
|
check(S.Position() == t1.n, " ...done, it goes to the step that hands it in and picks up part 2 (" .. S.Position() .. ")")
|
|
W_TITLE = S.QuestTitle(456); GetQuestReward(0); table.remove(W.log, logIdx(S.QuestTitle(456))); settle()
|
|
check(S.TurnedIn(456), " ...handed in")
|
|
-- a class quest the guide gives everyone ("Etched Sigil" is the Hunter's) is only kept for that class
|
|
local _, class = UnitClass("player")
|
|
local sig = stepOf("A", 3117)
|
|
check((class == "HUNTER") == (sig ~= nil), "\"Etched Sigil\" (the Hunter's quest) is only a step for Hunters (" .. class .. ": " .. tostring(sig ~= nil) .. ")")
|
|
for k = table.getn(W.log), 1, -1 do table.remove(W.log, k) end
|
|
if ER.db.done then ER.db.done[ER.Char()] = {} end
|
|
S.Load(S.Key(S.Info()), true); settle()
|
|
end
|
|
-- play it through: pick up, do, hand in as the steps say; unknown quests are ticked by hand
|
|
local unknown, byHandTicks, g0 = 0, 0, 0
|
|
local infoName = S.Info().name
|
|
while g0 < 400 and S.Info() and S.Info().name == infoName and S.Current() do
|
|
local st = S.Current()
|
|
for _, e in ipairs(st.elements) do
|
|
local id = tonumber(e.id); local title = id and S.QuestTitle(id)
|
|
if id and not title and (e.kind == "A" or e.kind == "C" or e.kind == "T") then unknown = unknown + 1 end
|
|
if title and e.kind == "A" and not logIdx(title) and not S.TurnedIn(id) then table.insert(W.log, { id = id, title = title, level = S.QuestLevel(id) or W.level, objs = { { text = "x: 0/1", done = false } } }) end
|
|
if title and e.kind == "C" and logIdx(title) then local q = W.log[logIdx(title)] q.complete = true q.objs[1].done = true end
|
|
if title and e.kind == "T" and logIdx(title) then W_TITLE = title; GetQuestReward(0); table.remove(W.log, logIdx(title)) end
|
|
if e.kind == "X" and tonumber(e.level) and W.level < tonumber(e.level) then W.level = tonumber(e.level) end
|
|
if e.kind == "G" then W.zone = e.zone; W.x = e.x / 100; W.y = e.y / 100; W.Fire("ZONE_CHANGED_NEW_AREA") end
|
|
end
|
|
settle()
|
|
if S.Current() == st then
|
|
if S.ByHand(st) then byHandTicks = byHandTicks + 1 S.Tick(st.n) else S.Next() end
|
|
settle()
|
|
end
|
|
g0 = g0 + 1
|
|
end
|
|
P("note played " .. g0 .. " rounds of " .. infoName .. ": " .. byHandTicks .. " steps ticked by hand, " .. unknown .. " quest lines the addon has no name for")
|
|
check(g0 < 400, "played the whole guide through (" .. g0 .. " rounds)")
|
|
local nxt = S.Info() and S.Info().name
|
|
check(nxt and nxt ~= infoName and S.Info().vanilla, " ...and went on to the next guide: " .. tostring(nxt))
|
|
-- the arrow has a place on most steps
|
|
local placed, total = 0, 0
|
|
for _, it in ipairs(S.All()) do
|
|
total = total + 1
|
|
for _, e in ipairs(it.step.elements) do if e.kind == "G" then placed = placed + 1 break end end
|
|
end
|
|
P("note " .. placed .. " of " .. total .. " steps of " .. tostring(nxt) .. " have their own place (others use the quest giver's)")
|
|
-- a "do it, then run back and turn it in" line: its hand-in is a step of its own after the objective, not skipped
|
|
-- once the objective is done (The Woodland Protector pt.2 in Teldrassil)
|
|
do
|
|
local tg
|
|
for _, g in ipairs(S.Guides()) do if g.vanilla and string.find(g.title, "Teldrassil", 1, true) and g.lo == 1 then tg = g end end
|
|
if tg and ER.StartGuide(S.Key(tg), true, true) then
|
|
local cStep, tStep
|
|
for _, it in ipairs(S.All()) do
|
|
for _, e in ipairs(it.step.elements) do
|
|
if e.id == 459 and e.kind == "C" then cStep = it.step end
|
|
if e.id == 459 and e.kind == "T" and cStep and not tStep then tStep = it.step end
|
|
end
|
|
end
|
|
check(cStep and tStep and tStep.n > cStep.n, "The Woodland Protector pt.2: a Finish step, then a hand-in step (" ..
|
|
tostring(cStep and cStep.n) .. ", " .. tostring(tStep and tStep.n) .. ")")
|
|
if cStep and tStep then
|
|
-- a clean start, then play the guide as a player would up to the objective step
|
|
if ER.db.done then ER.db.done[ER.Char()] = {} end
|
|
pfQuest_history = nil
|
|
for i = table.getn(W.log), 1, -1 do table.remove(W.log, i) end
|
|
settle()
|
|
ER.StartGuide(S.Key(tg), true, true); S.Load(S.Key(tg), true); settle()
|
|
P("note playing " .. tostring(S.Info() and S.Info().title) .. " from step " .. S.Position())
|
|
local guard = 0
|
|
while S.Current() and S.Position() < cStep.n and guard < 40 do
|
|
local st = S.Current()
|
|
-- stand where the step is, as a player would
|
|
for _, e in ipairs(st.elements) do if e.kind == "G" and e.x then W.zone, W.x, W.y = e.zone, e.x / 100, e.y / 100 end end
|
|
for _, e in ipairs(st.elements) do
|
|
local id = tonumber(e.id); local title = id and S.QuestTitle(id)
|
|
if title and e.kind == "T" and logIdx(title) then W_TITLE = title; GetQuestReward(0); table.remove(W.log, logIdx(title)); settle() end
|
|
if title and e.kind == "A" and not logIdx(title) and not S.TurnedIn(id) then table.insert(W.log, { id = id, title = title, level = S.QuestLevel(id), objs = { { text = "x: 0/1", done = false } } }) end
|
|
if title and e.kind == "C" and logIdx(title) then local q = W.log[logIdx(title)] q.complete = true q.objs[1].done = true end
|
|
end
|
|
settle()
|
|
if S.Current() == st then S.Next() settle() end
|
|
guard = guard + 1
|
|
end
|
|
check(S.Position() == cStep.n and S.InLog(459) and not S.TurnedIn(459),
|
|
" ...played up to it: pt.1 handed in, pt.2 (same title) in the log (step " .. S.Position() .. ")")
|
|
local q = W.log[logIdx(S.QuestTitle(459))]
|
|
q.complete = true q.objs[1].done = true
|
|
settle()
|
|
W.x, W.y = 0.20, 0.80 -- walked off somewhere, as after killing the last mob
|
|
settle()
|
|
check(S.Position() == tStep.n, " ...the objective done, the guide moves to the hand-in step, not past it (now step " .. S.Position() .. ")")
|
|
local tgt = S.Target()
|
|
check(tgt and math.abs(tgt.x - 57) < 2 and math.abs(tgt.y - 45) < 2, " ...and the arrow points at where to hand it in (" .. (tgt and (tgt.x .. ", " .. tgt.y) or "?") .. ")")
|
|
W_TITLE = S.QuestTitle(459); GetQuestReward(0); table.remove(W.log, logIdx(W_TITLE)); settle()
|
|
check(S.Position() > tStep.n and S.TurnedIn(459), " ...handed in, it goes on (now step " .. S.Position() .. ")")
|
|
end
|
|
end
|
|
end
|
|
-- a quest to do goes where the line's own words say it is done, not the line's one map spot
|
|
local function report(want, found)
|
|
for _, w in ipairs(want) do
|
|
if found[w[1]] then
|
|
check(found[w[1]] == true, "Finish " .. w[1] .. " points at (" .. w[2] .. ", " .. w[3] .. ") as the line says " .. (found[w[1]] == true and "" or found[w[1]]))
|
|
end
|
|
end
|
|
end
|
|
do
|
|
local want = {
|
|
{ "Webwood Egg", 57, 26 }, -- "... (57, 32). Get Webwood Egg for Webwood Egg at (57, 26)": spot (57, 36)
|
|
{ "Iverron's Antidote", 57, 32 },
|
|
{ "Extinguish the Firegut", 81, 42 }, -- "at (81, 42) for Extinguish the Firegut then run back to (84, 68)"
|
|
{ "The Jasperlode Mine", 60, 50 }, -- the place of the same name at (61, 53) is not the quest
|
|
{ "Water Elementals", 20, 23 }, -- "(20, 23) ... for Water Elementals You should ... (33, 39)"
|
|
}
|
|
local found = {}
|
|
for _, g in ipairs(S.Guides()) do
|
|
if g.vanilla and ER.StartGuide(S.Key(g), true, true) then
|
|
for _, it in ipairs(S.All()) do
|
|
local spot
|
|
for _, e in ipairs(it.step.elements) do if e.kind == "G" then spot = e end end
|
|
for _, e in ipairs(it.step.elements) do
|
|
if e.kind == "C" and spot then
|
|
local t = S.QuestTitle(e.id)
|
|
for _, w in ipairs(want) do
|
|
if t == w[1] then
|
|
local x, y = S.TextPlace(it.step, t, spot.zone)
|
|
found[t] = found[t] or "(" .. tostring(x) .. ", " .. tostring(y) .. "; line spot " .. spot.x .. ", " .. spot.y .. ")"
|
|
if x == w[2] and y == w[3] then found[t] = true end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
report(want, found)
|
|
end
|
|
-- a line with two stops ("turn in A, accept B, then run up the tree and hand it in ... accept C") is a step per stop
|
|
do
|
|
local function find(pred)
|
|
for _, g in ipairs(S.Guides()) do
|
|
if g.vanilla and ER.StartGuide(S.Key(g), true, true) then
|
|
for k, it in ipairs(S.All()) do if pred(it.step) then return it.step, S.All()[k + 1] and S.All()[k + 1].step end end
|
|
end
|
|
end
|
|
end
|
|
local function has(step, kind, id) for _, e in ipairs(step.elements) do if e.kind == kind and e.id == id then return true end end end
|
|
local function spot(step) for _, e in ipairs(step.elements) do if e.kind == "G" then return e end end end
|
|
local a, b = find(function(st) return has(st, "T", 917) end)
|
|
if not a then P("skip the Teldrassil split checks (Alliance guides, not shown to this race)") else
|
|
check(a and has(a, "A", 920) and not has(a, "A", 921), "Webwood Egg: its hand-in step takes Tenaron's Summons, not Crown of the Earth")
|
|
check(b and has(b, "T", 920) and not has(b, "A", 921), " ...the next step only hands in Tenaron's Summons")
|
|
local g = b and spot(b)
|
|
check(g and math.abs(g.x - 59) < 1 and math.abs(g.y - 39) < 1, " ...at the top of the tree (59, 39)")
|
|
local _, c = find(function(st) return has(st, "T", 920) end)
|
|
local gc = c and spot(c)
|
|
check(c and has(c, "A", 921) and gc and math.abs(gc.x - 59) < 1 and math.abs(gc.y - 39) < 1, " ...and Crown of the Earth is the step after that, in the same place")
|
|
local z1, z2 = find(function(st) return has(st, "T", 488) and has(st, "A", 489) end)
|
|
check(z1 == nil, "Zenn's Bidding: the hand-in no longer carries Seek Redemption!")
|
|
local z = find(function(st) return has(st, "T", 488) end)
|
|
local _, zn = find(function(st) return has(st, "T", 488) end)
|
|
check(z and zn and has(zn, "A", 489), " ...it is the step after")
|
|
end
|
|
end
|
|
-- steps as a short action line and a tip: a step with no quest of its own is named by its first clause, nothing is left
|
|
-- that only repeats what the step's quest lines say, and no step is an empty or a one-character line
|
|
do
|
|
local steps, named, bare, junk, longTitle, repeated = 0, 0, 0, 0, 0, 0
|
|
for _, g in ipairs(S.Guides()) do
|
|
if g.vanilla and ER.StartGuide(S.Key(g), true, true) then
|
|
for _, it in ipairs(S.All()) do
|
|
local st = it.step
|
|
steps = steps + 1
|
|
local quest, text = false, nil
|
|
for _, e in ipairs(st.elements) do
|
|
if e.kind == "A" or e.kind == "T" or e.kind == "C" then quest = true end
|
|
if e.kind == "I" and e.text then text = e.text end
|
|
end
|
|
if text and string.len(strip(text)) < 3 then junk = junk + 1 end
|
|
if not quest and text then
|
|
if st.flags.title and st.flags.title ~= "" then named = named + 1 else bare = bare + 1 end
|
|
if st.flags.title and string.len(st.flags.title) > 70 then longTitle = longTitle + 1 end
|
|
end
|
|
-- "Turn in X" and nothing more, beside the T line that says the same
|
|
if quest and text then
|
|
for _, e in ipairs(st.elements) do
|
|
local title = e.kind == "T" and S.QuestTitle(e.id)
|
|
if title and (strip(text) == "Turn in " .. title or strip(text) == "Turn in " .. title .. ".") then repeated = repeated + 1 break end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
check(junk == 0, "no step is a bare '.' (" .. junk .. ")")
|
|
check(named > 300 and bare < named / 4, "steps with no quest line are named by their first clause (" .. named .. " named, " .. bare .. " not)")
|
|
check(longTitle == 0, "those titles are short")
|
|
check(repeated == 0, "a tip that only says 'Turn in X' beside the hand-in line is left out (" .. repeated .. " left)")
|
|
end
|
|
P(fails == 0 and "ALL PASSED" or (fails .. " FAILED"))
|
|
REPORT()
|