diff --git a/CMakeLists.txt b/CMakeLists.txt index c55b5396..1f30e462 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -734,6 +734,7 @@ set(WOWEE_SOURCES src/pipeline/wowee_chat_commands.cpp src/pipeline/wowee_camera_presets.cpp src/pipeline/wowee_combat_formulas.cpp + src/pipeline/wowee_chat_links.cpp src/pipeline/custom_zone_discovery.cpp src/pipeline/dbc_layout.cpp @@ -1631,6 +1632,7 @@ add_executable(wowee_editor tools/editor/cli_chat_commands_catalog.cpp tools/editor/cli_camera_presets_catalog.cpp tools/editor/cli_combat_formulas_catalog.cpp + tools/editor/cli_chat_links_catalog.cpp tools/editor/cli_catalog_pluck.cpp tools/editor/cli_catalog_find.cpp tools/editor/cli_catalog_by_name.cpp @@ -1847,6 +1849,7 @@ add_executable(wowee_editor src/pipeline/wowee_chat_commands.cpp src/pipeline/wowee_camera_presets.cpp src/pipeline/wowee_combat_formulas.cpp + src/pipeline/wowee_chat_links.cpp src/pipeline/custom_zone_discovery.cpp src/pipeline/terrain_mesh.cpp diff --git a/include/pipeline/wowee_chat_links.hpp b/include/pipeline/wowee_chat_links.hpp new file mode 100644 index 00000000..7aa2d4d9 --- /dev/null +++ b/include/pipeline/wowee_chat_links.hpp @@ -0,0 +1,134 @@ +#pragma once + +#include +#include +#include + +namespace wowee { +namespace pipeline { + +// Wowee Open Chat Hyperlink Templates catalog +// (.wlnk) — novel replacement for the implicit +// chat-link format templates vanilla WoW carried +// in client-side LUA (each link kind — item / +// quest / spell / achievement / talent / trade- +// skill — had a hard-coded sprintf template baked +// into ChatFrame_OnHyperlinkClick with no formal +// data-driven extension point). Each WLNK entry +// binds one hyperlink kind to its sprintf-style +// chat-link template, tooltip-popup template, +// quality color, and server-lookup requirement. +// +// Cross-references with previously-added formats: +// WIT: kind=Item link templates reference WIT +// items by itemId (the first %d in the +// template). +// WSPL: kind=Spell templates reference WSPL +// spells. +// WQTM: kind=Quest templates reference WQTM +// quests. +// WACH: kind=Achievement templates reference +// the achievements catalog. +// +// Binary layout (little-endian): +// magic[4] = "WLNK" +// version (uint32) = current 1 +// nameLen + name (catalog label) +// entryCount (uint32) +// entries (each): +// linkId (uint32) +// nameLen + name +// linkKind (uint8) — 0=Item / +// 1=Quest / +// 2=Spell / +// 3=Achievement +// /4=Talent / +// 5=Trade +// requireServerLookup (uint8) — 0/1 — client +// calls server +// to fetch +// tooltip data +// pad0 (uint16) +// colorRGBA (uint32) — link text +// color (typical +// quality color) +// templateLen + linkTemplate — sprintf with +// %d / %s placeholders +// tooltipLen + tooltipTemplate — first-line +// tooltip header +// iconRuleLen + iconRule — string +// describing +// icon source +// ("inv", "spell", +// "achievement" +// etc.) +struct WoweeChatLinks { + enum LinkKind : uint8_t { + Item = 0, + Quest = 1, + Spell = 2, + Achievement = 3, + Talent = 4, + Trade = 5, + }; + + struct Entry { + uint32_t linkId = 0; + std::string name; + uint8_t linkKind = Item; + uint8_t requireServerLookup = 0; + uint16_t pad0 = 0; + uint32_t colorRGBA = 0; + std::string linkTemplate; + std::string tooltipTemplate; + std::string iconRule; + }; + + std::string name; + std::vector entries; + + bool isValid() const { return !entries.empty(); } + + const Entry* findById(uint32_t linkId) const; + + // Returns the template for a given hyperlink + // kind. Used by the chat-link composer when a + // player shift-clicks an item/spell/quest into + // chat — picks the matching template and + // sprintf-fills the parameters. + const Entry* findByKind(uint8_t linkKind) const; +}; + +class WoweeChatLinksLoader { +public: + static bool save(const WoweeChatLinks& cat, + const std::string& basePath); + static WoweeChatLinks load(const std::string& basePath); + static bool exists(const std::string& basePath); + + // Preset emitters used by --gen-lnk* variants. + // + // makeStandardLinks — 4 standard link kinds + // (Item with 4 %d for + // rune slots / Quest / + // Spell / Achievement) + // with quality-color + // defaults. + // makeTalentTrade — 2 less-common link kinds + // (Talent / Trade-skill + // recipe) with green + + // orange colors. + // makeColorVariants — 3 Item-kind variants for + // different quality + // colors (Common gray / + // Epic purple / Legendary + // orange) demonstrating + // per-quality template + // differentiation. + static WoweeChatLinks makeStandardLinks(const std::string& catalogName); + static WoweeChatLinks makeTalentTrade(const std::string& catalogName); + static WoweeChatLinks makeColorVariants(const std::string& catalogName); +}; + +} // namespace pipeline +} // namespace wowee diff --git a/src/pipeline/wowee_chat_links.cpp b/src/pipeline/wowee_chat_links.cpp new file mode 100644 index 00000000..a6246d19 --- /dev/null +++ b/src/pipeline/wowee_chat_links.cpp @@ -0,0 +1,259 @@ +#include "pipeline/wowee_chat_links.hpp" + +#include +#include +#include + +namespace wowee { +namespace pipeline { + +namespace { + +constexpr char kMagic[4] = {'W', 'L', 'N', 'K'}; +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) != ".wlnk") { + base += ".wlnk"; + } + return base; +} + +} // namespace + +const WoweeChatLinks::Entry* +WoweeChatLinks::findById(uint32_t linkId) const { + for (const auto& e : entries) + if (e.linkId == linkId) return &e; + return nullptr; +} + +const WoweeChatLinks::Entry* +WoweeChatLinks::findByKind(uint8_t linkKind) const { + for (const auto& e : entries) + if (e.linkKind == linkKind) return &e; + return nullptr; +} + +bool WoweeChatLinksLoader::save(const WoweeChatLinks& 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.linkId); + writeStr(os, e.name); + writePOD(os, e.linkKind); + writePOD(os, e.requireServerLookup); + writePOD(os, e.pad0); + writePOD(os, e.colorRGBA); + writeStr(os, e.linkTemplate); + writeStr(os, e.tooltipTemplate); + writeStr(os, e.iconRule); + } + return os.good(); +} + +WoweeChatLinks WoweeChatLinksLoader::load( + const std::string& basePath) { + WoweeChatLinks 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.linkId)) { + out.entries.clear(); return out; + } + if (!readStr(is, e.name)) { + out.entries.clear(); return out; + } + if (!readPOD(is, e.linkKind) || + !readPOD(is, e.requireServerLookup) || + !readPOD(is, e.pad0) || + !readPOD(is, e.colorRGBA)) { + out.entries.clear(); return out; + } + if (!readStr(is, e.linkTemplate) || + !readStr(is, e.tooltipTemplate) || + !readStr(is, e.iconRule)) { + out.entries.clear(); return out; + } + } + return out; +} + +bool WoweeChatLinksLoader::exists(const std::string& basePath) { + std::ifstream is(normalizePath(basePath), std::ios::binary); + return is.good(); +} + +namespace { + +WoweeChatLinks::Entry makeLink( + uint32_t linkId, const char* name, + uint8_t linkKind, uint8_t serverLookup, + uint32_t colorRGBA, + const char* linkTemplate, + const char* tooltipTemplate, + const char* iconRule) { + WoweeChatLinks::Entry e; + e.linkId = linkId; e.name = name; + e.linkKind = linkKind; + e.requireServerLookup = serverLookup; + e.colorRGBA = colorRGBA; + e.linkTemplate = linkTemplate; + e.tooltipTemplate = tooltipTemplate; + e.iconRule = iconRule; + return e; +} + +} // namespace + +WoweeChatLinks WoweeChatLinksLoader::makeStandardLinks( + const std::string& catalogName) { + using L = WoweeChatLinks; + WoweeChatLinks c; + c.name = catalogName; + // Item link: classic 4-rune-slot template + // |cffFFFFFF|Hitem:itemId:enchant:gem1:gem2|h + // [Name]|h|r. Quality color is white default; + // quality variants override (see makeColor + // Variants). + c.entries.push_back(makeLink( + 1, "Item Hyperlink (Common)", + L::Item, 1 /* server lookup for item data */, + 0xFFFFFFFFu /* white */, + "|cffffffff|Hitem:%d:%d:%d:%d|h[%s]|h|r", + "%s", + "inv")); + // Quest link: |cff808080|Hquest:questId:level|h + // [Name]|h|r. Gray color for completable quests. + c.entries.push_back(makeLink( + 2, "Quest Hyperlink", + L::Quest, 0, + 0xFFFFFF00u /* yellow — quest color */, + "|cffffff00|Hquest:%d:%d|h[%s]|h|r", + "Level %d quest", + "questmark")); + // Spell link. + c.entries.push_back(makeLink( + 3, "Spell Hyperlink", + L::Spell, 0, + 0xFFFFFFFFu /* white */, + "|cffffffff|Hspell:%d|h[%s]|h|r", + "%s", + "spell")); + // Achievement link. + c.entries.push_back(makeLink( + 4, "Achievement Hyperlink", + L::Achievement, 1 /* server lookup for + completion state */, + 0xFFFFFF00u /* yellow */, + "|cffffff00|Hachievement:%d:%s:%d:%d:%d:%d:%d:%d:%d|h[%s]|h|r", + "%s (%d points)", + "achievement")); + return c; +} + +WoweeChatLinks WoweeChatLinksLoader::makeTalentTrade( + const std::string& catalogName) { + using L = WoweeChatLinks; + WoweeChatLinks c; + c.name = catalogName; + // Talent link: green color (passive enhancements). + c.entries.push_back(makeLink( + 10, "Talent Hyperlink", + L::Talent, 0, + 0xFF00FF00u /* green */, + "|cff00ff00|Htalent:%d:%d|h[%s]|h|r", + "%s (rank %d)", + "talent")); + // Trade-skill recipe: orange color (rare-quality + // recipe). + c.entries.push_back(makeLink( + 11, "Trade Recipe Hyperlink", + L::Trade, 1 /* server lookup for ingredients + list */, + 0xFFFFA500u /* orange */, + "|cffffa500|Htrade:%d:%d:%d:%s|h[%s]|h|r", + "%s — requires %d %s skill", + "trade")); + return c; +} + +WoweeChatLinks WoweeChatLinksLoader::makeColorVariants( + const std::string& catalogName) { + using L = WoweeChatLinks; + WoweeChatLinks c; + c.name = catalogName; + // Three Item-kind variants distinguished by + // quality color. The chat composer picks which + // variant by item quality at link time. + c.entries.push_back(makeLink( + 20, "Item Common (gray)", + L::Item, 1, 0xFF9D9D9D /* gray quality */, + "|cff9d9d9d|Hitem:%d:%d:%d:%d|h[%s]|h|r", + "%s", + "inv")); + c.entries.push_back(makeLink( + 21, "Item Epic (purple)", + L::Item, 1, 0xFFA335EE /* purple */, + "|cffa335ee|Hitem:%d:%d:%d:%d|h[%s]|h|r", + "%s (Epic)", + "inv")); + c.entries.push_back(makeLink( + 22, "Item Legendary (orange)", + L::Item, 1, 0xFFFF8000 /* orange */, + "|cffff8000|Hitem:%d:%d:%d:%d|h[%s]|h|r", + "%s (Legendary)", + "inv")); + return c; +} + +} // namespace pipeline +} // namespace wowee diff --git a/tools/editor/cli_arg_required.cpp b/tools/editor/cli_arg_required.cpp index 59f0338f..8eff620e 100644 --- a/tools/editor/cli_arg_required.cpp +++ b/tools/editor/cli_arg_required.cpp @@ -446,6 +446,8 @@ const char* const kArgRequired[] = { "--gen-cfr-warrior", "--gen-cfr-mage", "--gen-cfr-rogue", "--info-wcfr", "--validate-wcfr", "--export-wcfr-json", "--import-wcfr-json", + "--gen-lnk-std", "--gen-lnk-talent", "--gen-lnk-quality", + "--info-wlnk", "--validate-wlnk", "--gen-weather-temperate", "--gen-weather-arctic", "--gen-weather-desert", "--gen-weather-stormy", "--gen-zone-atmosphere", diff --git a/tools/editor/cli_chat_links_catalog.cpp b/tools/editor/cli_chat_links_catalog.cpp new file mode 100644 index 00000000..b3647319 --- /dev/null +++ b/tools/editor/cli_chat_links_catalog.cpp @@ -0,0 +1,313 @@ +#include "cli_chat_links_catalog.hpp" +#include "cli_arg_parse.hpp" +#include "cli_box_emitter.hpp" + +#include "pipeline/wowee_chat_links.hpp" +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace wowee { +namespace editor { +namespace cli { + +namespace { + +std::string stripWlnkExt(std::string base) { + stripExt(base, ".wlnk"); + return base; +} + +const char* linkKindName(uint8_t k) { + using L = wowee::pipeline::WoweeChatLinks; + switch (k) { + case L::Item: return "item"; + case L::Quest: return "quest"; + case L::Spell: return "spell"; + case L::Achievement: return "achievement"; + case L::Talent: return "talent"; + case L::Trade: return "trade"; + default: return "?"; + } +} + +bool saveOrError(const wowee::pipeline::WoweeChatLinks& c, + const std::string& base, const char* cmd) { + if (!wowee::pipeline::WoweeChatLinksLoader::save(c, base)) { + std::fprintf(stderr, "%s: failed to save %s.wlnk\n", + cmd, base.c_str()); + return false; + } + return true; +} + +void printGenSummary(const wowee::pipeline::WoweeChatLinks& c, + const std::string& base) { + std::printf("Wrote %s.wlnk\n", base.c_str()); + std::printf(" catalog : %s\n", c.name.c_str()); + std::printf(" links : %zu\n", c.entries.size()); +} + +int handleGenStandard(int& i, int argc, char** argv) { + std::string base = argv[++i]; + std::string name = "StandardChatLinks"; + if (parseOptArg(i, argc, argv)) name = argv[++i]; + base = stripWlnkExt(base); + auto c = wowee::pipeline::WoweeChatLinksLoader:: + makeStandardLinks(name); + if (!saveOrError(c, base, "gen-lnk-std")) return 1; + printGenSummary(c, base); + return 0; +} + +int handleGenTalentTrade(int& i, int argc, char** argv) { + std::string base = argv[++i]; + std::string name = "TalentTradeChatLinks"; + if (parseOptArg(i, argc, argv)) name = argv[++i]; + base = stripWlnkExt(base); + auto c = wowee::pipeline::WoweeChatLinksLoader:: + makeTalentTrade(name); + if (!saveOrError(c, base, "gen-lnk-talent")) return 1; + printGenSummary(c, base); + return 0; +} + +int handleGenColorVariants(int& i, int argc, char** argv) { + std::string base = argv[++i]; + std::string name = "ItemQualityColorVariants"; + if (parseOptArg(i, argc, argv)) name = argv[++i]; + base = stripWlnkExt(base); + auto c = wowee::pipeline::WoweeChatLinksLoader:: + makeColorVariants(name); + if (!saveOrError(c, base, "gen-lnk-quality")) 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 = stripWlnkExt(base); + if (!wowee::pipeline::WoweeChatLinksLoader::exists(base)) { + std::fprintf(stderr, "WLNK not found: %s.wlnk\n", + base.c_str()); + return 1; + } + auto c = wowee::pipeline::WoweeChatLinksLoader::load(base); + if (jsonOut) { + nlohmann::json j; + j["wlnk"] = base + ".wlnk"; + j["name"] = c.name; + j["count"] = c.entries.size(); + nlohmann::json arr = nlohmann::json::array(); + for (const auto& e : c.entries) { + arr.push_back({ + {"linkId", e.linkId}, + {"name", e.name}, + {"linkKind", e.linkKind}, + {"linkKindName", linkKindName(e.linkKind)}, + {"requireServerLookup", + e.requireServerLookup != 0}, + {"colorRGBA", e.colorRGBA}, + {"linkTemplate", e.linkTemplate}, + {"tooltipTemplate", e.tooltipTemplate}, + {"iconRule", e.iconRule}, + }); + } + j["entries"] = arr; + std::printf("%s\n", j.dump(2).c_str()); + return 0; + } + std::printf("WLNK: %s.wlnk\n", base.c_str()); + std::printf(" catalog : %s\n", c.name.c_str()); + std::printf(" links : %zu\n", c.entries.size()); + if (c.entries.empty()) return 0; + std::printf(" id kind srv color icon name\n"); + for (const auto& e : c.entries) { + std::printf(" %4u %-11s %s 0x%08X %-11s %s\n", + e.linkId, linkKindName(e.linkKind), + e.requireServerLookup ? "Y" : "n", + e.colorRGBA, + e.iconRule.c_str(), + e.name.c_str()); + } + return 0; +} + +// Counts %d / %s placeholder occurrences in a sprintf +// template. Used by the validator to catch templates +// with no placeholders (would never substitute the +// link parameters). +int countPlaceholders(const std::string& tpl) { + int count = 0; + for (size_t i = 0; i + 1 < tpl.size(); ++i) { + if (tpl[i] != '%') continue; + char c = tpl[i + 1]; + if (c == 'd' || c == 's' || c == 'u' || + c == 'i' || c == 'x' || c == 'X') { + ++count; + ++i; // skip the format char + } else if (c == '%') { + ++i; // literal %% — don't count + } + } + return count; +} + +int handleValidate(int& i, int argc, char** argv) { + std::string base = argv[++i]; + bool jsonOut = consumeJsonFlag(i, argc, argv); + base = stripWlnkExt(base); + if (!wowee::pipeline::WoweeChatLinksLoader::exists(base)) { + std::fprintf(stderr, + "validate-wlnk: WLNK not found: %s.wlnk\n", + base.c_str()); + return 1; + } + auto c = wowee::pipeline::WoweeChatLinksLoader::load(base); + std::vector errors; + std::vector warnings; + if (c.entries.empty()) { + warnings.push_back("catalog has zero entries"); + } + std::set idsSeen; + 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.linkId); + if (!e.name.empty()) ctx += " " + e.name; + ctx += ")"; + if (e.linkId == 0) + errors.push_back(ctx + ": linkId is 0"); + if (e.name.empty()) + errors.push_back(ctx + ": name is empty"); + if (e.linkTemplate.empty()) { + errors.push_back(ctx + + ": linkTemplate is empty — link " + "composer would have nothing to " + "format"); + } + if (e.linkKind > 5) { + errors.push_back(ctx + ": linkKind " + + std::to_string(e.linkKind) + + " out of range (0..5)"); + } + // CRITICAL: linkTemplate MUST contain at + // least one %d or %s placeholder. A template + // with no placeholders never substitutes link + // parameters — the chat composer would emit + // a static string regardless of which item / + // quest / spell was clicked. + int placeholderCount = countPlaceholders(e.linkTemplate); + if (!e.linkTemplate.empty() && + placeholderCount == 0) { + errors.push_back(ctx + + ": linkTemplate has no %%d / %%s " + "placeholders — composer would emit " + "a static string regardless of input " + "(every link would render identically)"); + } + // Warn on excessive placeholders (> 12) — + // the achievement template legitimately has + // 9 (achievementId + chardate + 5 progress + // criteria + completion state + name) but + // anything beyond ~12 is suspicious. + if (placeholderCount > 12) { + warnings.push_back(ctx + + ": linkTemplate has " + + std::to_string(placeholderCount) + + " placeholders — > 12 is unusual; " + "verify all are intentional"); + } + // colorRGBA = 0 means fully transparent — + // link text would be invisible. Warn. + if (e.colorRGBA == 0) { + warnings.push_back(ctx + + ": colorRGBA is 0 (fully transparent)" + " — link text would be invisible; " + "set a quality color"); + } + // requireServerLookup=true with no template + // %s for receiving server-side data is + // suspicious but not definitive (server may + // populate the tooltip rather than the link + // text). Warn. + if (e.requireServerLookup && + e.tooltipTemplate.empty()) { + warnings.push_back(ctx + + ": requireServerLookup=true but " + "tooltipTemplate is empty — server " + "data would not be displayed anywhere " + "(verify intentional)"); + } + if (!idsSeen.insert(e.linkId).second) { + errors.push_back(ctx + ": duplicate linkId"); + } + } + bool ok = errors.empty(); + if (jsonOut) { + nlohmann::json j; + j["wlnk"] = base + ".wlnk"; + 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-wlnk: %s.wlnk\n", base.c_str()); + if (ok && warnings.empty()) { + std::printf(" OK — %zu links, all linkIds unique, " + "linkKind 0..5, linkTemplate non-empty " + "with at least one %%d/%%s placeholder, " + "non-zero colorRGBA\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 handleChatLinksCatalog(int& i, int argc, char** argv, + int& outRc) { + if (std::strcmp(argv[i], "--gen-lnk-std") == 0 && + i + 1 < argc) { + outRc = handleGenStandard(i, argc, argv); return true; + } + if (std::strcmp(argv[i], "--gen-lnk-talent") == 0 && + i + 1 < argc) { + outRc = handleGenTalentTrade(i, argc, argv); return true; + } + if (std::strcmp(argv[i], "--gen-lnk-quality") == 0 && + i + 1 < argc) { + outRc = handleGenColorVariants(i, argc, argv); return true; + } + if (std::strcmp(argv[i], "--info-wlnk") == 0 && i + 1 < argc) { + outRc = handleInfo(i, argc, argv); return true; + } + if (std::strcmp(argv[i], "--validate-wlnk") == 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_chat_links_catalog.hpp b/tools/editor/cli_chat_links_catalog.hpp new file mode 100644 index 00000000..e0995ade --- /dev/null +++ b/tools/editor/cli_chat_links_catalog.hpp @@ -0,0 +1,12 @@ +#pragma once + +namespace wowee { +namespace editor { +namespace cli { + +bool handleChatLinksCatalog(int& i, int argc, char** argv, + int& outRc); + +} // namespace cli +} // namespace editor +} // namespace wowee diff --git a/tools/editor/cli_dispatch.cpp b/tools/editor/cli_dispatch.cpp index ad38343e..f11d9ffa 100644 --- a/tools/editor/cli_dispatch.cpp +++ b/tools/editor/cli_dispatch.cpp @@ -190,6 +190,7 @@ #include "cli_chat_commands_catalog.hpp" #include "cli_camera_presets_catalog.hpp" #include "cli_combat_formulas_catalog.hpp" +#include "cli_chat_links_catalog.hpp" #include "cli_catalog_pluck.hpp" #include "cli_catalog_find.hpp" #include "cli_catalog_by_name.hpp" @@ -425,6 +426,7 @@ constexpr DispatchFn kDispatchTable[] = { handleChatCommandsCatalog, handleCameraPresetsCatalog, handleCombatFormulasCatalog, + handleChatLinksCatalog, handleCatalogPluck, handleCatalogFind, handleCatalogByName, diff --git a/tools/editor/cli_format_table.cpp b/tools/editor/cli_format_table.cpp index abd93c1b..156bf72c 100644 --- a/tools/editor/cli_format_table.cpp +++ b/tools/editor/cli_format_table.cpp @@ -148,6 +148,7 @@ constexpr FormatMagicEntry kFormats[] = { {{'W','C','M','D'}, ".wcmd", "chat", "--info-wcmd", "Chat slash command catalog"}, {{'W','C','A','M'}, ".wcam", "camera", "--info-wcam", "Camera preset catalog"}, {{'W','C','F','R'}, ".wcfr", "stats", "--info-wcfr", "Combat formula catalog"}, + {{'W','L','N','K'}, ".wlnk", "chat", "--info-wlnk", "Chat hyperlink template catalog"}, {{'W','F','A','C'}, ".wfac", "factions", nullptr, "Faction catalog"}, {{'W','L','C','K'}, ".wlck", "locks", nullptr, "Lock catalog"}, {{'W','S','K','L'}, ".wskl", "skills", nullptr, "Skill catalog"}, diff --git a/tools/editor/cli_help.cpp b/tools/editor/cli_help.cpp index e2b05ea1..3f60d932 100644 --- a/tools/editor/cli_help.cpp +++ b/tools/editor/cli_help.cpp @@ -2797,6 +2797,16 @@ void printUsage(const char* argv0) { std::printf(" Export binary .wcfr to a human-editable JSON sidecar (defaults to .wcfr.json; emits both outputStatKind and inputStatKind as int + name string)\n"); std::printf(" --import-wcfr-json [out-base]\n"); std::printf(" Import a .wcfr.json sidecar back into binary .wcfr (outputStatKind int OR \"ap\"/\"sp\"/\"crit\"/\"dodge\"/\"parry\"/\"hit\"/\"spellcrit\"/\"haste\"; inputStatKind int OR \"str\"/\"agi\"/\"sta\"/\"int\"/\"spi\"; conversionRatio fp_x100 preserved)\n"); + std::printf(" --gen-lnk-std [name]\n"); + std::printf(" Emit .wlnk 4 standard hyperlink kinds (Item with 4-rune-slot template / Quest yellow / Spell white / Achievement with 9 placeholders)\n"); + std::printf(" --gen-lnk-talent [name]\n"); + std::printf(" Emit .wlnk 2 less-common link kinds (Talent green for passive enhancements / Trade-skill recipe orange with server lookup)\n"); + std::printf(" --gen-lnk-quality [name]\n"); + std::printf(" Emit .wlnk 3 Item-kind variants distinguished by quality color (Common gray 0x9D9D9D / Epic purple 0xA335EE / Legendary orange 0xFF8000)\n"); + std::printf(" --info-wlnk [--json]\n"); + std::printf(" Print WLNK entries (id / kind / requireServerLookup / colorRGBA hex / iconRule / name)\n"); + std::printf(" --validate-wlnk [--json]\n"); + std::printf(" Static checks: id+name+linkTemplate required, linkKind 0..5, no duplicate linkIds; CRITICAL: linkTemplate MUST contain at least one %%d/%%s placeholder — composer would emit a static string regardless of input (every link would render identically). Warns on > 12 placeholders (unusual; verify intentional), colorRGBA=0 (fully transparent — link text invisible), and requireServerLookup=true with empty tooltipTemplate (server data would not be displayed anywhere)\n"); std::printf(" --catalog-pluck [--json]\n"); std::printf(" Extract one entry by id from any registered catalog format. Auto-detects magic, dispatches to the per-format --info-* handler internally, then prints just the matching entry. Primary-key field is auto-detected (first *Id field, or first numeric)\n"); std::printf(" --catalog-find [--magic ] [--json]\n"); diff --git a/tools/editor/cli_list_formats.cpp b/tools/editor/cli_list_formats.cpp index 1a5a8ecb..cdd72963 100644 --- a/tools/editor/cli_list_formats.cpp +++ b/tools/editor/cli_list_formats.cpp @@ -170,6 +170,7 @@ constexpr FormatRow kFormats[] = { {"WCMD", ".wcmd", "chat", "ChatFrame.lua + per-command CommandHandler","Chat slash command catalog (security-gated registry + aliases + throttle)"}, {"WCAM", ".wcam", "camera", "CameraMgr hard-coded camera profiles","Camera preset catalog (per-purpose FOV/distance/pitch/damping)"}, {"WCFR", ".wcfr", "stats", "gtChanceTo*.dbc + StatSystem constants","Combat formula catalog (per-class stat conversion ratios in fixed-point)"}, + {"WLNK", ".wlnk", "chat", "ChatFrame_OnHyperlinkClick LUA", "Chat hyperlink template catalog (sprintf-style %d/%s link composition)"}, // Additional pipeline catalogs without the alternating // gen/info/validate CLI surface (loaded by the engine