From 95e593e59c64e3cefac092a6711c6535af127ec0 Mon Sep 17 00:00:00 2001 From: Kelsi Date: Sat, 9 May 2026 15:50:25 -0700 Subject: [PATCH] feat(pipeline): add WSKL (Wowee Skill Catalog) format MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Novel open replacement for Blizzard's SkillLine.dbc + SkillLineCategory.dbc + the AzerothCore-style player skill base tables. The 19th open format added to the editor. Defines every player-trackable skill: weapon proficiencies (Swords, Axes, Bows), professions (Mining, Alchemy, Cooking), languages (Common, Dwarvish), class specializations (Fire, Frost, Holy, Protection), armor proficiencies (Mail, Plate), and secondary skills (First Aid, Lockpicking, Riding). Cross-references with previously-added formats: WLCK.channel.targetId (kind=Lockpick) -> WSKL.entry.skillId WGOT.entry.requiredSkill -> WSKL.entry.skillId The starter preset's skillIds 186 (Mining) and 633 (Lockpicking) deliberately match the canonical IDs already referenced by WGOT.makeGather and WLCK.makeDungeon — so the demo content stack now wires together end-to-end: WGOT herb-node requires skill 186 -> WSKL Mining at rank 1+; WLCK bandit-strongbox channel requires skill 633 -> WSKL Lockpicking at rank 1+. Format: • magic "WSKL", version 1, little-endian • per skill: skillId / name / description / categoryId / canTrain / maxRank / rankPerLevel / iconPath Enums: • CategoryId (8): Weapon / Class / Profession / SecondaryProfession / Language / ArmorProficiency / Riding / WeaponSpec API: WoweeSkillLoader::save / load / exists / findById; presets makeStarter (5-skill demo with cross-referenced canonical IDs), makeProfessions (12 classic professions: 9 primary + 3 secondary), makeWeapons (16 weapon skills with canonical SkillLine IDs and rankPerLevel=5 auto-grow). CLI added (5 flags, 528 documented total now): --gen-skills / --gen-skills-professions / --gen-skills-weapons --info-wskl / --validate-wskl Validator catches: skillId=0 + duplicates, empty name, maxRank=0, unknown categoryId, suspicious maxRank=1 on non-Language skill (only languages cap at 1), weapon skill with rankPerLevel=0 (won't auto-grow on use). --- CMakeLists.txt | 3 + include/pipeline/wowee_skills.hpp | 95 ++++++++++++ src/pipeline/wowee_skills.cpp | 225 +++++++++++++++++++++++++++ tools/editor/cli_arg_required.cpp | 2 + tools/editor/cli_dispatch.cpp | 2 + tools/editor/cli_help.cpp | 10 ++ tools/editor/cli_skills_catalog.cpp | 233 ++++++++++++++++++++++++++++ tools/editor/cli_skills_catalog.hpp | 11 ++ 8 files changed, 581 insertions(+) create mode 100644 include/pipeline/wowee_skills.hpp create mode 100644 src/pipeline/wowee_skills.cpp create mode 100644 tools/editor/cli_skills_catalog.cpp create mode 100644 tools/editor/cli_skills_catalog.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 522261a6..66ac1eaa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -606,6 +606,7 @@ set(WOWEE_SOURCES src/pipeline/wowee_objects.cpp src/pipeline/wowee_factions.cpp src/pipeline/wowee_locks.cpp + src/pipeline/wowee_skills.cpp src/pipeline/custom_zone_discovery.cpp src/pipeline/dbc_layout.cpp @@ -1358,6 +1359,7 @@ add_executable(wowee_editor tools/editor/cli_objects_catalog.cpp tools/editor/cli_factions_catalog.cpp tools/editor/cli_locks_catalog.cpp + tools/editor/cli_skills_catalog.cpp tools/editor/cli_quest_objective.cpp tools/editor/cli_quest_reward.cpp tools/editor/cli_clone.cpp @@ -1442,6 +1444,7 @@ add_executable(wowee_editor src/pipeline/wowee_objects.cpp src/pipeline/wowee_factions.cpp src/pipeline/wowee_locks.cpp + src/pipeline/wowee_skills.cpp src/pipeline/custom_zone_discovery.cpp src/pipeline/terrain_mesh.cpp diff --git a/include/pipeline/wowee_skills.hpp b/include/pipeline/wowee_skills.hpp new file mode 100644 index 00000000..746728b4 --- /dev/null +++ b/include/pipeline/wowee_skills.hpp @@ -0,0 +1,95 @@ +#pragma once + +#include +#include +#include + +namespace wowee { +namespace pipeline { + +// Wowee Open Skill Catalog (.wskl) — novel replacement for +// Blizzard's SkillLine.dbc + SkillLineCategory.dbc + the +// AzerothCore-style player_classlevelstats / skill base +// tables. The 19th open format added to the editor. +// +// Defines every player-trackable skill: weapon proficiencies +// (Swords, Axes, Bows), professions (Mining, Alchemy, +// Cooking), languages (Common, Dwarvish), class +// specializations (Fire, Frost, Holy, Protection), +// armor proficiencies (Mail, Plate), and secondary skills +// (First Aid, Lockpicking, Riding). +// +// Cross-references with previously-added formats: +// WLCK.channel.targetId (kind=Lockpick) → WSKL.entry.skillId +// WGOT.entry.requiredSkill → WSKL.entry.skillId +// +// Binary layout (little-endian): +// magic[4] = "WSKL" +// version (uint32) = current 1 +// nameLen + name (catalog label) +// entryCount (uint32) +// entries (each): +// skillId (uint32) +// nameLen + name +// descLen + description +// categoryId (uint8) / canTrain (uint8) / pad[2] +// maxRank (uint16) / rankPerLevel (uint16) +// iconLen + iconPath +struct WoweeSkill { + enum CategoryId : uint8_t { + Weapon = 0, + Class = 1, // class spec trees (Fire, Holy, ...) + Profession = 2, // primary: Mining, Alchemy + SecondaryProfession = 3, // First Aid, Cooking, Fishing + Language = 4, + ArmorProficiency = 5, // Mail, Plate, Shields + Riding = 6, + WeaponSpec = 7, // class weapon-specialization talents + }; + + struct Entry { + uint32_t skillId = 0; + std::string name; + std::string description; + uint8_t categoryId = Profession; + uint8_t canTrain = 1; // 1 = requires trainer + uint16_t maxRank = 300; // typical classic profession cap + uint16_t rankPerLevel = 0; // weapon skills auto-grow + std::string iconPath; + }; + + std::string name; + std::vector entries; + + bool isValid() const { return !entries.empty(); } + + // Lookup by skillId — nullptr if not present. + const Entry* findById(uint32_t skillId) const; + + static const char* categoryName(uint8_t c); +}; + +class WoweeSkillLoader { +public: + static bool save(const WoweeSkill& cat, + const std::string& basePath); + static WoweeSkill load(const std::string& basePath); + static bool exists(const std::string& basePath); + + // Preset emitters used by --gen-skills* variants. + // + // makeStarter — minimal: Swords + Lockpicking + Mining + + // First Aid + Common (one per category that + // the runtime uses immediately). + // makeProfessions — full primary + secondary profession + // set (the 12 classic gathering / + // crafting professions). + // makeWeapons — every weapon-skill slot with WoW's + // canonical max-rank scaling (rankPerLevel=5). + static WoweeSkill makeStarter(const std::string& catalogName); + static WoweeSkill makeProfessions(const std::string& catalogName); + static WoweeSkill makeWeapons(const std::string& catalogName); +}; + +} // namespace pipeline +} // namespace wowee diff --git a/src/pipeline/wowee_skills.cpp b/src/pipeline/wowee_skills.cpp new file mode 100644 index 00000000..9bda205c --- /dev/null +++ b/src/pipeline/wowee_skills.cpp @@ -0,0 +1,225 @@ +#include "pipeline/wowee_skills.hpp" + +#include +#include +#include + +namespace wowee { +namespace pipeline { + +namespace { + +constexpr char kMagic[4] = {'W', 'S', 'K', 'L'}; +constexpr uint32_t kVersion = 1; + +template +void writePOD(std::ofstream& os, const T& v) { + os.write(reinterpret_cast(&v), sizeof(T)); +} + +template +bool readPOD(std::ifstream& is, T& v) { + is.read(reinterpret_cast(&v), sizeof(T)); + return is.gcount() == static_cast(sizeof(T)); +} + +void writeStr(std::ofstream& os, const std::string& s) { + uint32_t n = static_cast(s.size()); + writePOD(os, n); + if (n > 0) os.write(s.data(), n); +} + +bool readStr(std::ifstream& is, std::string& s) { + uint32_t n = 0; + if (!readPOD(is, n)) return false; + if (n > (1u << 20)) return false; + s.resize(n); + if (n > 0) { + is.read(s.data(), n); + if (is.gcount() != static_cast(n)) { + s.clear(); + return false; + } + } + return true; +} + +std::string normalizePath(std::string base) { + if (base.size() < 5 || base.substr(base.size() - 5) != ".wskl") { + base += ".wskl"; + } + return base; +} + +} // namespace + +const WoweeSkill::Entry* WoweeSkill::findById(uint32_t skillId) const { + for (const auto& e : entries) { + if (e.skillId == skillId) return &e; + } + return nullptr; +} + +const char* WoweeSkill::categoryName(uint8_t c) { + switch (c) { + case Weapon: return "weapon"; + case Class: return "class"; + case Profession: return "profession"; + case SecondaryProfession: return "secondary"; + case Language: return "language"; + case ArmorProficiency: return "armor"; + case Riding: return "riding"; + case WeaponSpec: return "weapon-spec"; + default: return "unknown"; + } +} + +bool WoweeSkillLoader::save(const WoweeSkill& cat, + const std::string& basePath) { + std::ofstream os(normalizePath(basePath), std::ios::binary); + if (!os) return false; + os.write(kMagic, 4); + writePOD(os, kVersion); + writeStr(os, cat.name); + uint32_t entryCount = static_cast(cat.entries.size()); + writePOD(os, entryCount); + for (const auto& e : cat.entries) { + writePOD(os, e.skillId); + writeStr(os, e.name); + writeStr(os, e.description); + writePOD(os, e.categoryId); + writePOD(os, e.canTrain); + uint8_t pad[2] = {0, 0}; + os.write(reinterpret_cast(pad), 2); + writePOD(os, e.maxRank); + writePOD(os, e.rankPerLevel); + writeStr(os, e.iconPath); + } + return os.good(); +} + +WoweeSkill WoweeSkillLoader::load(const std::string& basePath) { + WoweeSkill out; + std::ifstream is(normalizePath(basePath), std::ios::binary); + if (!is) return out; + char magic[4]; + is.read(magic, 4); + if (std::memcmp(magic, kMagic, 4) != 0) return out; + uint32_t version = 0; + if (!readPOD(is, version) || version != kVersion) return out; + if (!readStr(is, out.name)) return out; + uint32_t entryCount = 0; + if (!readPOD(is, entryCount)) return out; + if (entryCount > (1u << 20)) return out; + out.entries.resize(entryCount); + for (auto& e : out.entries) { + if (!readPOD(is, e.skillId)) { out.entries.clear(); return out; } + if (!readStr(is, e.name) || !readStr(is, e.description)) { + out.entries.clear(); return out; + } + if (!readPOD(is, e.categoryId) || + !readPOD(is, e.canTrain)) { + out.entries.clear(); return out; + } + uint8_t pad[2]; + is.read(reinterpret_cast(pad), 2); + if (is.gcount() != 2) { out.entries.clear(); return out; } + if (!readPOD(is, e.maxRank) || + !readPOD(is, e.rankPerLevel)) { + out.entries.clear(); return out; + } + if (!readStr(is, e.iconPath)) { + out.entries.clear(); return out; + } + } + return out; +} + +bool WoweeSkillLoader::exists(const std::string& basePath) { + std::ifstream is(normalizePath(basePath), std::ios::binary); + return is.good(); +} + +WoweeSkill WoweeSkillLoader::makeStarter(const std::string& catalogName) { + WoweeSkill c; + c.name = catalogName; + auto add = [&](uint32_t id, const char* name, uint8_t cat, + uint16_t maxRank, uint16_t perLevel, + uint8_t train) { + WoweeSkill::Entry e; + e.skillId = id; e.name = name; + e.categoryId = cat; e.maxRank = maxRank; + e.rankPerLevel = perLevel; e.canTrain = train; + c.entries.push_back(e); + }; + add(43, "Swords", WoweeSkill::Weapon, 300, 5, 1); + add(98, "Common", WoweeSkill::Language, 1, 0, 0); + add(129, "First Aid", WoweeSkill::SecondaryProfession, 300, 0, 1); + // SkillId 186 = Mining, 633 = Lockpicking — the canonical + // values that WGOT.makeGather and WLCK.makeDungeon already + // reference. + add(186, "Mining", WoweeSkill::Profession, 300, 0, 1); + add(633, "Lockpicking", WoweeSkill::SecondaryProfession, 300, 0, 1); + return c; +} + +WoweeSkill WoweeSkillLoader::makeProfessions(const std::string& catalogName) { + WoweeSkill c; + c.name = catalogName; + auto add = [&](uint32_t id, const char* name, uint8_t cat) { + WoweeSkill::Entry e; + e.skillId = id; e.name = name; + e.categoryId = cat; e.maxRank = 300; e.canTrain = 1; + c.entries.push_back(e); + }; + // Primary professions (canonical SkillLine IDs). + add(164, "Blacksmithing", WoweeSkill::Profession); + add(165, "Leatherworking", WoweeSkill::Profession); + add(171, "Alchemy", WoweeSkill::Profession); + add(182, "Herbalism", WoweeSkill::Profession); + add(186, "Mining", WoweeSkill::Profession); + add(197, "Tailoring", WoweeSkill::Profession); + add(202, "Engineering", WoweeSkill::Profession); + add(333, "Enchanting", WoweeSkill::Profession); + add(393, "Skinning", WoweeSkill::Profession); + // Secondary professions. + add(129, "First Aid", WoweeSkill::SecondaryProfession); + add(185, "Cooking", WoweeSkill::SecondaryProfession); + add(356, "Fishing", WoweeSkill::SecondaryProfession); + return c; +} + +WoweeSkill WoweeSkillLoader::makeWeapons(const std::string& catalogName) { + WoweeSkill c; + c.name = catalogName; + auto add = [&](uint32_t id, const char* name) { + WoweeSkill::Entry e; + e.skillId = id; e.name = name; + e.categoryId = WoweeSkill::Weapon; + e.maxRank = 300; // matches character-level cap × 5 + e.rankPerLevel = 5; // weapon skill auto-grows by 5/level + e.canTrain = 0; // weapons train via use, not trainer + c.entries.push_back(e); + }; + // Canonical SkillLine IDs from WoW classic. + add( 43, "Swords"); + add( 44, "Axes"); + add( 45, "Bows"); + add( 46, "Guns"); + add( 54, "Maces"); + add( 55, "Two-Handed Swords"); + add( 95, "Defense"); + add(118, "Daggers"); + add(136, "Staves"); + add(160, "Two-Handed Maces"); + add(172, "Two-Handed Axes"); + add(173, "Polearms"); + add(176, "Thrown"); + add(226, "Crossbows"); + add(228, "Wands"); + add(473, "Fist Weapons"); + return c; +} + +} // namespace pipeline +} // namespace wowee diff --git a/tools/editor/cli_arg_required.cpp b/tools/editor/cli_arg_required.cpp index 08cee5f4..0ce5a00f 100644 --- a/tools/editor/cli_arg_required.cpp +++ b/tools/editor/cli_arg_required.cpp @@ -52,6 +52,8 @@ const char* const kArgRequired[] = { "--export-wfac-json", "--import-wfac-json", "--gen-locks", "--gen-locks-dungeon", "--gen-locks-professions", "--info-wlck", "--validate-wlck", + "--gen-skills", "--gen-skills-professions", "--gen-skills-weapons", + "--info-wskl", "--validate-wskl", "--gen-weather-temperate", "--gen-weather-arctic", "--gen-weather-desert", "--gen-weather-stormy", "--gen-zone-atmosphere", diff --git a/tools/editor/cli_dispatch.cpp b/tools/editor/cli_dispatch.cpp index 7b1072d1..10fabbd1 100644 --- a/tools/editor/cli_dispatch.cpp +++ b/tools/editor/cli_dispatch.cpp @@ -46,6 +46,7 @@ #include "cli_objects_catalog.hpp" #include "cli_factions_catalog.hpp" #include "cli_locks_catalog.hpp" +#include "cli_skills_catalog.hpp" #include "cli_quest_objective.hpp" #include "cli_quest_reward.hpp" #include "cli_clone.hpp" @@ -133,6 +134,7 @@ constexpr DispatchFn kDispatchTable[] = { handleObjectsCatalog, handleFactionsCatalog, handleLocksCatalog, + handleSkillsCatalog, handleQuestObjective, handleQuestReward, handleClone, diff --git a/tools/editor/cli_help.cpp b/tools/editor/cli_help.cpp index 11a3a920..aae61b68 100644 --- a/tools/editor/cli_help.cpp +++ b/tools/editor/cli_help.cpp @@ -961,6 +961,16 @@ void printUsage(const char* argv0) { std::printf(" Print WLCK lock entries with per-channel detail (kind / target / required skill rank)\n"); std::printf(" --validate-wlck [--json]\n"); std::printf(" Static checks: lockId>0+unique, at least 1 active channel, item/spell/lockpick need targetId\n"); + std::printf(" --gen-skills [name]\n"); + std::printf(" Emit .wskl starter: Swords + Common + First Aid + Mining (id=186) + Lockpicking (id=633) — matches WGOT/WLCK\n"); + std::printf(" --gen-skills-professions [name]\n"); + std::printf(" Emit .wskl 12 classic professions (9 primary + 3 secondary) with canonical SkillLine IDs\n"); + std::printf(" --gen-skills-weapons [name]\n"); + std::printf(" Emit .wskl all 16 weapon skills with rankPerLevel=5 auto-grow (use-trained, not trainer-trained)\n"); + std::printf(" --info-wskl [--json]\n"); + std::printf(" Print WSKL entries (id / category / max rank / per-level grow / trainer-required / name)\n"); + std::printf(" --validate-wskl [--json]\n"); + std::printf(" Static checks: skillId>0+unique, name not empty, maxRank>0, weapon needs rankPerLevel>0\n"); std::printf(" --gen-weather-temperate [zoneName]\n"); std::printf(" Emit .wow weather schedule: clear-dominant + occasional rain + fog (forest / grassland)\n"); std::printf(" --gen-weather-arctic [zoneName]\n"); diff --git a/tools/editor/cli_skills_catalog.cpp b/tools/editor/cli_skills_catalog.cpp new file mode 100644 index 00000000..de4a17dd --- /dev/null +++ b/tools/editor/cli_skills_catalog.cpp @@ -0,0 +1,233 @@ +#include "cli_skills_catalog.hpp" +#include "cli_arg_parse.hpp" +#include "cli_box_emitter.hpp" + +#include "pipeline/wowee_skills.hpp" +#include + +#include +#include +#include +#include +#include +#include + +namespace wowee { +namespace editor { +namespace cli { + +namespace { + +std::string stripWsklExt(std::string base) { + stripExt(base, ".wskl"); + return base; +} + +bool saveOrError(const wowee::pipeline::WoweeSkill& c, + const std::string& base, const char* cmd) { + if (!wowee::pipeline::WoweeSkillLoader::save(c, base)) { + std::fprintf(stderr, "%s: failed to save %s.wskl\n", + cmd, base.c_str()); + return false; + } + return true; +} + +void printGenSummary(const wowee::pipeline::WoweeSkill& c, + const std::string& base) { + std::printf("Wrote %s.wskl\n", base.c_str()); + std::printf(" catalog : %s\n", c.name.c_str()); + std::printf(" skills : %zu\n", c.entries.size()); +} + +int handleGenStarter(int& i, int argc, char** argv) { + std::string base = argv[++i]; + std::string name = "StarterSkills"; + if (parseOptArg(i, argc, argv)) name = argv[++i]; + base = stripWsklExt(base); + auto c = wowee::pipeline::WoweeSkillLoader::makeStarter(name); + if (!saveOrError(c, base, "gen-skills")) return 1; + printGenSummary(c, base); + return 0; +} + +int handleGenProfessions(int& i, int argc, char** argv) { + std::string base = argv[++i]; + std::string name = "ProfessionSkills"; + if (parseOptArg(i, argc, argv)) name = argv[++i]; + base = stripWsklExt(base); + auto c = wowee::pipeline::WoweeSkillLoader::makeProfessions(name); + if (!saveOrError(c, base, "gen-skills-professions")) return 1; + printGenSummary(c, base); + return 0; +} + +int handleGenWeapons(int& i, int argc, char** argv) { + std::string base = argv[++i]; + std::string name = "WeaponSkills"; + if (parseOptArg(i, argc, argv)) name = argv[++i]; + base = stripWsklExt(base); + auto c = wowee::pipeline::WoweeSkillLoader::makeWeapons(name); + if (!saveOrError(c, base, "gen-skills-weapons")) 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 = stripWsklExt(base); + if (!wowee::pipeline::WoweeSkillLoader::exists(base)) { + std::fprintf(stderr, "WSKL not found: %s.wskl\n", base.c_str()); + return 1; + } + auto c = wowee::pipeline::WoweeSkillLoader::load(base); + if (jsonOut) { + nlohmann::json j; + j["wskl"] = base + ".wskl"; + j["name"] = c.name; + j["count"] = c.entries.size(); + nlohmann::json arr = nlohmann::json::array(); + for (const auto& e : c.entries) { + arr.push_back({ + {"skillId", e.skillId}, + {"name", e.name}, + {"description", e.description}, + {"categoryId", e.categoryId}, + {"categoryName", wowee::pipeline::WoweeSkill::categoryName(e.categoryId)}, + {"canTrain", e.canTrain}, + {"maxRank", e.maxRank}, + {"rankPerLevel", e.rankPerLevel}, + {"iconPath", e.iconPath}, + }); + } + j["entries"] = arr; + std::printf("%s\n", j.dump(2).c_str()); + return 0; + } + std::printf("WSKL: %s.wskl\n", base.c_str()); + std::printf(" catalog : %s\n", c.name.c_str()); + std::printf(" skills : %zu\n", c.entries.size()); + if (c.entries.empty()) return 0; + std::printf(" id category max /lvl train name\n"); + for (const auto& e : c.entries) { + std::printf(" %4u %-11s %3u %2u %s %s\n", + e.skillId, + wowee::pipeline::WoweeSkill::categoryName(e.categoryId), + e.maxRank, e.rankPerLevel, + e.canTrain ? "yes" : "no ", + e.name.c_str()); + } + return 0; +} + +int handleValidate(int& i, int argc, char** argv) { + std::string base = argv[++i]; + bool jsonOut = consumeJsonFlag(i, argc, argv); + base = stripWsklExt(base); + if (!wowee::pipeline::WoweeSkillLoader::exists(base)) { + std::fprintf(stderr, + "validate-wskl: WSKL not found: %s.wskl\n", base.c_str()); + return 1; + } + auto c = wowee::pipeline::WoweeSkillLoader::load(base); + std::vector errors; + std::vector warnings; + if (c.entries.empty()) { + warnings.push_back("catalog has zero entries"); + } + std::vector idsSeen; + idsSeen.reserve(c.entries.size()); + for (size_t k = 0; k < c.entries.size(); ++k) { + const auto& e = c.entries[k]; + std::string ctx = "entry " + std::to_string(k) + + " (id=" + std::to_string(e.skillId); + if (!e.name.empty()) ctx += " " + e.name; + ctx += ")"; + if (e.skillId == 0) { + errors.push_back(ctx + ": skillId is 0"); + } + if (e.name.empty()) { + errors.push_back(ctx + ": name is empty"); + } + if (e.maxRank == 0) { + errors.push_back(ctx + ": maxRank is 0"); + } + if (e.categoryId > wowee::pipeline::WoweeSkill::WeaponSpec) { + errors.push_back(ctx + ": categoryId " + + std::to_string(e.categoryId) + " not in 0..7"); + } + // Languages have maxRank=1 (you either know it or you don't); + // anything else with maxRank=1 is suspicious. + if (e.maxRank == 1 && + e.categoryId != wowee::pipeline::WoweeSkill::Language) { + warnings.push_back(ctx + + ": maxRank=1 on non-Language skill (only languages cap at 1)"); + } + // Weapon skills should auto-grow (rankPerLevel > 0). + if (e.categoryId == wowee::pipeline::WoweeSkill::Weapon && + e.rankPerLevel == 0) { + warnings.push_back(ctx + + ": weapon skill with rankPerLevel=0 (won't auto-grow on use)"); + } + for (uint32_t prev : idsSeen) { + if (prev == e.skillId) { + errors.push_back(ctx + ": duplicate skillId"); + break; + } + } + idsSeen.push_back(e.skillId); + } + bool ok = errors.empty(); + if (jsonOut) { + nlohmann::json j; + j["wskl"] = base + ".wskl"; + 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-wskl: %s.wskl\n", base.c_str()); + if (ok && warnings.empty()) { + std::printf(" OK — %zu skills, all skillIds unique\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 handleSkillsCatalog(int& i, int argc, char** argv, int& outRc) { + if (std::strcmp(argv[i], "--gen-skills") == 0 && i + 1 < argc) { + outRc = handleGenStarter(i, argc, argv); return true; + } + if (std::strcmp(argv[i], "--gen-skills-professions") == 0 && i + 1 < argc) { + outRc = handleGenProfessions(i, argc, argv); return true; + } + if (std::strcmp(argv[i], "--gen-skills-weapons") == 0 && i + 1 < argc) { + outRc = handleGenWeapons(i, argc, argv); return true; + } + if (std::strcmp(argv[i], "--info-wskl") == 0 && i + 1 < argc) { + outRc = handleInfo(i, argc, argv); return true; + } + if (std::strcmp(argv[i], "--validate-wskl") == 0 && i + 1 < argc) { + outRc = handleValidate(i, argc, argv); return true; + } + return false; +} + +} // namespace cli +} // namespace editor +} // namespace wowee diff --git a/tools/editor/cli_skills_catalog.hpp b/tools/editor/cli_skills_catalog.hpp new file mode 100644 index 00000000..82a33836 --- /dev/null +++ b/tools/editor/cli_skills_catalog.hpp @@ -0,0 +1,11 @@ +#pragma once + +namespace wowee { +namespace editor { +namespace cli { + +bool handleSkillsCatalog(int& i, int argc, char** argv, int& outRc); + +} // namespace cli +} // namespace editor +} // namespace wowee