phaneron/Kelsidavis-WoWee
1
0
Fork 0
mirror of https://github.com/Kelsidavis/WoWee.git synced 2026-05-11 11:33:52 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

feat(pipeline): WQGR quest graph catalog (132nd open format)

Browse source 
Novel representation of quest-chain dependencies that vanilla
WoW carried implicitly in QuestRelations.dbc (the prequest
column) + per-quest server scripts. Each WQGR entry binds one
quest to its display name, level/class/race gating,
prerequisite quest list (must be completed first), follow-up
quest hints (next-quest suggestions for the journal UI), and
quest type flags (Normal / Daily / Repeatable / Group / Raid).

Three presets:
  --gen-qgr-starter   5-quest linear chain (Northshire human-
                      starter Q100..Q104, levels 1..8) with
                      chainHeadHint=1 on Q100
  --gen-qgr-branched  4-quest converging DAG (Q200 unlocks
                      both Q201 + Q202, both required for Q203)
                      — demonstrates true DAG semantics, not
                      just linear lists
  --gen-qgr-dailies   3 standalone daily quests (Daily type,
                      no prereqs, no followups)

Validator catches: id+name required, questType 0..4,
factionAccess 0..3, maxLevel >= minLevel, no self-prereq
(catch-22), no missing prereq questId, full DFS cycle detection
on prevQuestIds (progression deadlock — quests would be
unreachable). Reuses the proven cycle-extraction pattern from
WMOD addon manifest (extracts back-edge path so the editor sees
the loop). Warns on followup hint to self/missing-id (advisory
only — followups are hints not contracts) and on
chainHeadHint=1 with non-empty prereqs (contradicts chain-head
semantics).

Format count 131 -> 132. CLI flag count 1382 -> 1389.
This commit is contained in:
Kelsi 2026-05-10 04:22:13 -07:00
parent 25ecdb0813
commit 76cda20297
10 changed files with 847 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

371
tools/editor/cli_quest_graph_catalog.cpp Normal file
View file

@ -0,0 +1,371 @@
#include "cli_quest_graph_catalog.hpp"
#include "cli_arg_parse.hpp"
#include "cli_box_emitter.hpp"
#include "pipeline/wowee_quest_graph.hpp"
#include <nlohmann/json.hpp>
#include <algorithm>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <map>
#include <set>
#include <string>
#include <vector>
namespace wowee {
namespace editor {
namespace cli {
namespace {
std::string stripWqgrExt(std::string base) {
stripExt(base, ".wqgr");
return base;
}
const char* questTypeName(uint8_t t) {
using G = wowee::pipeline::WoweeQuestGraph;
switch (t) {
case G::Normal: return "normal";
case G::Daily: return "daily";
case G::Repeatable: return "repeatable";
case G::Group: return "group";
case G::Raid: return "raid";
default: return "?";
}
}
const char* factionAccessName(uint8_t f) {
using G = wowee::pipeline::WoweeQuestGraph;
switch (f) {
case G::Both: return "both";
case G::Alliance: return "alliance";
case G::Horde: return "horde";
case G::Neutral: return "neutral";
default: return "?";
}
}
bool saveOrError(const wowee::pipeline::WoweeQuestGraph& c,
const std::string& base, const char* cmd) {
if (!wowee::pipeline::WoweeQuestGraphLoader::save(c, base)) {
std::fprintf(stderr, "%s: failed to save %s.wqgr\n",
cmd, base.c_str());
return false;
}
return true;
}
void printGenSummary(const wowee::pipeline::WoweeQuestGraph& c,
const std::string& base) {
std::printf("Wrote %s.wqgr\n", base.c_str());
std::printf(" catalog : %s\n", c.name.c_str());
std::printf(" quests : %zu\n", c.entries.size());
}
int handleGenStarter(int& i, int argc, char** argv) {
std::string base = argv[++i];
std::string name = "NorthshireStarterChain";
if (parseOptArg(i, argc, argv)) name = argv[++i];
base = stripWqgrExt(base);
auto c = wowee::pipeline::WoweeQuestGraphLoader::
makeStarterChain(name);
if (!saveOrError(c, base, "gen-qgr-starter")) return 1;
printGenSummary(c, base);
return 0;
}
int handleGenBranched(int& i, int argc, char** argv) {
std::string base = argv[++i];
std::string name = "BranchedConvergingChain";
if (parseOptArg(i, argc, argv)) name = argv[++i];
base = stripWqgrExt(base);
auto c = wowee::pipeline::WoweeQuestGraphLoader::
makeBranchedChain(name);
if (!saveOrError(c, base, "gen-qgr-branched")) return 1;
printGenSummary(c, base);
return 0;
}
int handleGenDailies(int& i, int argc, char** argv) {
std::string base = argv[++i];
std::string name = "DailyQuests";
if (parseOptArg(i, argc, argv)) name = argv[++i];
base = stripWqgrExt(base);
auto c = wowee::pipeline::WoweeQuestGraphLoader::
makeDailies(name);
if (!saveOrError(c, base, "gen-qgr-dailies")) return 1;
printGenSummary(c, base);
return 0;
}
int handleInfo(int& i, int argc, char** argv) {
std::string base = argv[++i];
bool jsonOut = consumeJsonFlag(i, argc, argv);
base = stripWqgrExt(base);
if (!wowee::pipeline::WoweeQuestGraphLoader::exists(base)) {
std::fprintf(stderr, "WQGR not found: %s.wqgr\n",
base.c_str());
return 1;
}
auto c = wowee::pipeline::WoweeQuestGraphLoader::load(base);
if (jsonOut) {
nlohmann::json j;
j["wqgr"] = base + ".wqgr";
j["name"] = c.name;
j["count"] = c.entries.size();
nlohmann::json arr = nlohmann::json::array();
for (const auto& e : c.entries) {
arr.push_back({
{"questId", e.questId},
{"name", e.name},
{"minLevel", e.minLevel},
{"maxLevel", e.maxLevel},
{"questType", e.questType},
{"questTypeName", questTypeName(e.questType)},
{"factionAccess", e.factionAccess},
{"factionAccessName",
factionAccessName(e.factionAccess)},
{"classRestriction", e.classRestriction},
{"raceRestriction", e.raceRestriction},
{"zoneId", e.zoneId},
{"chainHeadHint", e.chainHeadHint != 0},
{"prevQuestIds", e.prevQuestIds},
{"followupQuestIds", e.followupQuestIds},
});
}
j["entries"] = arr;
std::printf("%s\n", j.dump(2).c_str());
return 0;
}
std::printf("WQGR: %s.wqgr\n", base.c_str());
std::printf(" catalog : %s\n", c.name.c_str());
std::printf(" quests : %zu\n", c.entries.size());
if (c.entries.empty()) return 0;
std::printf(" id minL maxL type fact zone head prev fup name\n");
for (const auto& e : c.entries) {
std::printf(" %4u %3u %3u %-10s %-8s %4u %s %4zu %3zu %s\n",
e.questId, e.minLevel, e.maxLevel,
questTypeName(e.questType),
factionAccessName(e.factionAccess),
e.zoneId,
e.chainHeadHint ? "Y" : "n",
e.prevQuestIds.size(),
e.followupQuestIds.size(),
e.name.c_str());
}
return 0;
}
// DFS cycle detection over prevQuestIds — same
// stack-based pattern as WMOD addon manifest. A
// cycle in quest prereqs means the quest is
// unreachable (player would need to complete Q1 to
// start Q2, but Q1 prereq is Q2).
std::vector<uint32_t> findFirstCycle(
const wowee::pipeline::WoweeQuestGraph& c) {
std::map<uint32_t, std::vector<uint32_t>> graph;
std::set<uint32_t> known;
for (const auto& e : c.entries) {
graph[e.questId] = e.prevQuestIds;
known.insert(e.questId);
}
enum Color : uint8_t { White = 0, Gray = 1, Black = 2 };
std::map<uint32_t, Color> color;
for (uint32_t id : known) color[id] = White;
std::vector<uint32_t> path;
std::vector<uint32_t> cycle;
std::function<bool(uint32_t)> dfs = [&](uint32_t node) -> bool {
color[node] = Gray;
path.push_back(node);
for (uint32_t prev : graph[node]) {
if (!known.count(prev)) continue;
if (color[prev] == Gray) {
auto it = std::find(path.begin(), path.end(), prev);
cycle.assign(it, path.end());
cycle.push_back(prev);
return true;
}
if (color[prev] == White) {
if (dfs(prev)) return true;
}
}
color[node] = Black;
path.pop_back();
return false;
};
for (uint32_t id : known) {
if (color[id] == White && dfs(id)) return cycle;
}
return {};
}
int handleValidate(int& i, int argc, char** argv) {
std::string base = argv[++i];
bool jsonOut = consumeJsonFlag(i, argc, argv);
base = stripWqgrExt(base);
if (!wowee::pipeline::WoweeQuestGraphLoader::exists(base)) {
std::fprintf(stderr,
"validate-wqgr: WQGR not found: %s.wqgr\n",
base.c_str());
return 1;
}
auto c = wowee::pipeline::WoweeQuestGraphLoader::load(base);
std::vector<std::string> errors;
std::vector<std::string> warnings;
if (c.entries.empty()) {
warnings.push_back("catalog has zero entries");
}
std::set<uint32_t> idsSeen;
std::set<uint32_t> knownIds;
for (const auto& e : c.entries) knownIds.insert(e.questId);
for (size_t k = 0; k < c.entries.size(); ++k) {
const auto& e = c.entries[k];
std::string ctx = "entry " + std::to_string(k) +
" (questId=" + std::to_string(e.questId);
if (!e.name.empty()) ctx += " " + e.name;
ctx += ")";
if (e.questId == 0)
errors.push_back(ctx + ": questId is 0");
if (e.name.empty())
errors.push_back(ctx + ": name is empty");
if (e.questType > 4) {
errors.push_back(ctx + ": questType " +
std::to_string(e.questType) +
" out of range (0..4)");
}
if (e.factionAccess > 3) {
errors.push_back(ctx + ": factionAccess " +
std::to_string(e.factionAccess) +
" out of range (0..3)");
}
if (e.maxLevel != 0 && e.maxLevel < e.minLevel) {
errors.push_back(ctx + ": maxLevel " +
std::to_string(e.maxLevel) +
" < minLevel " +
std::to_string(e.minLevel));
}
// Self-prereq: a quest listing itself in
// its own prereqs is unreachable (catch-22).
for (uint32_t prev : e.prevQuestIds) {
if (prev == e.questId) {
errors.push_back(ctx +
": quest depends on itself "
"(unreachable — catch-22)");
}
if (!knownIds.count(prev)) {
errors.push_back(ctx +
": prereq questId=" +
std::to_string(prev) +
" not found in catalog");
}
}
// Followup hints to unknown ids: NOT an
// error — followups are advisory hints,
// the missing target may live in a sibling
// catalog. Just warn.
for (uint32_t fol : e.followupQuestIds) {
if (fol == e.questId) {
warnings.push_back(ctx +
": followup hint points to self "
"(no-op — prune)");
}
if (!knownIds.count(fol)) {
warnings.push_back(ctx +
": followup hint points to "
"questId=" + std::to_string(fol) +
" not in this catalog (may live "
"in a sibling catalog)");
}
}
// chainHeadHint=1 with non-empty prereqs is a
// contradiction — a chain head BY DEFINITION
// has no prereqs. Warn.
if (e.chainHeadHint && !e.prevQuestIds.empty()) {
warnings.push_back(ctx +
": chainHeadHint=1 but quest has " +
std::to_string(e.prevQuestIds.size()) +
" prereq(s) — chain heads should have "
"no prereqs");
}
if (!idsSeen.insert(e.questId).second) {
errors.push_back(ctx + ": duplicate questId");
}
}
// DFS cycle on prevQuestIds — same pattern as WMOD.
auto cycle = findFirstCycle(c);
if (!cycle.empty()) {
std::string trail;
for (size_t k = 0; k < cycle.size(); ++k) {
if (k > 0) trail += " -> ";
trail += std::to_string(cycle[k]);
}
errors.push_back("prereq cycle detected: " + trail +
" — quests would be unreachable "
"(progression deadlock)");
}
bool ok = errors.empty();
if (jsonOut) {
nlohmann::json j;
j["wqgr"] = base + ".wqgr";
j["ok"] = ok;
j["errors"] = errors;
j["warnings"] = warnings;
std::printf("%s\n", j.dump(2).c_str());
return ok ? 0 : 1;
}
std::printf("validate-wqgr: %s.wqgr\n", base.c_str());
if (ok && warnings.empty()) {
std::printf(" OK — %zu quests, all questIds unique, "
"questType 0..4, factionAccess 0..3, no "
"self-prereq, no missing prereq questId, "
"no DFS cycle (no progression deadlock)\n",
c.entries.size());
return 0;
}
if (!warnings.empty()) {
std::printf(" warnings (%zu):\n", warnings.size());
for (const auto& w : warnings)
std::printf(" - %s\n", w.c_str());
}
if (!errors.empty()) {
std::printf(" ERRORS (%zu):\n", errors.size());
for (const auto& e : errors)
std::printf(" - %s\n", e.c_str());
}
return ok ? 0 : 1;
}
} // namespace
bool handleQuestGraphCatalog(int& i, int argc, char** argv,
int& outRc) {
if (std::strcmp(argv[i], "--gen-qgr-starter") == 0 &&
i + 1 < argc) {
outRc = handleGenStarter(i, argc, argv); return true;
}
if (std::strcmp(argv[i], "--gen-qgr-branched") == 0 &&
i + 1 < argc) {
outRc = handleGenBranched(i, argc, argv); return true;
}
if (std::strcmp(argv[i], "--gen-qgr-dailies") == 0 &&
i + 1 < argc) {
outRc = handleGenDailies(i, argc, argv); return true;
}
if (std::strcmp(argv[i], "--info-wqgr") == 0 && i + 1 < argc) {
outRc = handleInfo(i, argc, argv); return true;
}
if (std::strcmp(argv[i], "--validate-wqgr") == 0 &&
i + 1 < argc) {
outRc = handleValidate(i, argc, argv); return true;
}
return false;
}
} // namespace cli
} // namespace editor
} // namespace wowee