phaneron/Kelsidavis-WoWee
1
0
Fork 0
mirror of https://github.com/Kelsidavis/WoWee.git synced 2026-05-10 19:13:52 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2
Kelsidavis-WoWee/tools/editor/cli_arg_required.cpp

457 lines
23 KiB
C++
Raw Normal View History

refactor(editor): extract kArgRequired + meta handlers into cli modules Splits the 138-line static-local kArgRequired array (the list of flags requiring positional args) into a new cli_arg_required.{hpp,cpp} module with extern linkage. Then moves the three meta handlers that depended on it out of main.cpp into cli_introspect.cpp: - --validate-cli-help (uses the array for self-check) - --version / -v (3-line printf) - --help / -h (1-line passthrough) main.cpp shrinks by 191 lines (677 to 486). Both the early missing-argument detector in main() and --validate-cli-help in cli_introspect.cpp now share one source of truth for the arg-required list.
2026-05-09 10:08:14 -07:00
#include "cli_arg_required.hpp"
namespace wowee {
namespace editor {
namespace cli {
const char* const kArgRequired[] = {
"--data", "--info", "--info-batches", "--info-textures", "--info-doodads",
"--info-attachments", "--info-particles", "--info-sequences",
"--info-bones", "--export-bones-dot",
"--list-zone-meshes", "--list-zone-audio", "--list-zone-textures",
"--list-project-meshes", "--list-project-audio",
"--list-project-textures",
"--info-zone-models-total", "--info-project-models-total",
"--list-zone-meshes-detail", "--list-project-meshes-detail", "--info-mesh",
feat(editor): add --info-mesh-stats geometric audit Reports total surface area, per-triangle area histogram (min/max/mean/median), edge analysis (boundary / manifold / non-manifold counts), watertight check, and degenerate triangle count for a single WOM. Watertightness here is the topological notion: every edge must be shared by exactly 2 triangles via shared vertex indices. This is what collision bakes and physics queries actually need — visually-closed primitives whose adjacent faces don't weld vertices will (correctly) report as non-watertight. Already caught a real defect in handleTent's door-fan triangulation: the fan covers the door cutout area with a stray triangle and leaves a vertex unreferenced. Edge analysis is gated by triCount <= 2M to keep the unordered_map bounded for huge baked terrain meshes.
2026-05-09 10:41:58 -07:00
"--info-mesh-storage-budget", "--info-mesh-stats",
feat(editor): --info-wob-stats + fix weld hash collision bug Add --info-wob-stats reporting per-group + aggregate triangle counts, surface area, edge analysis, and watertight check for WOB buildings. Same flag surface as --info-mesh-stats including --weld <eps> for true topological closure check on per-face-vertex meshes. Also fixes a correctness bug in the weld implementation of --info-mesh-stats: the previous code used a 64-bit hash of the quantized position as the equality key, which gave false-positive collisions that incorrectly merged distinct vertices. A unit cube's 8 corners collapsed to 2 positions under the buggy hash. Replace with std::map keyed on the actual quantized (qx, qy, qz) tuple so equality is exact. Re-verified: cube 8→8 watertight YES; firepit 240→80 watertight YES (was wrongly reporting 56 unique with 48 non-manifold edges); tent_solid 18→6 watertight YES; tent_fixed 21→9 with 5 boundary edges at the door perimeter (correct — door is intentionally open).
2026-05-09 10:57:22 -07:00
"--info-wob", "--info-wob-stats", "--info-woc", "--info-wot",
feat(pipeline): add WOL validation + time-of-day sampling Three additions to the Wowee Open Light format that landed last commit: • WoweeLightLoader::sampleAtTime(light, timeMin) returns the linearly-interpolated keyframe at any time-of-day, correctly handling wrap-around between the last keyframe and the first (e.g. 21:00 blends from dusk toward midnight by going forward through 00:00). • --validate-wol <wol-base> [--json] walks every keyframe and reports structural problems: time bounds (must be [0, 1440)), strict-ascending sort order, fogEnd > fogStart, finite color components. Exit code 0 PASS / 1 FAIL — CI-friendly. • --info-wol-at <wol-base> <HH:MM|minutes> samples the interpolated state at a specific time of day. Useful for previewing what the renderer would feed in at a given moment, debugging keyframe gaps, or previewing a sub-range of the cycle. Smoke-tested: dawn-to-midnight blend at 03:00 yields a plausible mid-fade ambient (0.18, 0.16, 0.15) and dusk-to- midnight wrap at 21:00 yields the symmetric (0.19, 0.145, 0.14). The default 4-keyframe day/night cycle from makeDefaultDayNight passes --validate-wol cleanly.
2026-05-09 13:54:57 -07:00
"--info-wol", "--info-wol-at", "--validate-wol", "--gen-light",
feat(pipeline): add WOL preset variants for cave/dungeon/night Three new single-keyframe WOL presets complement the existing 4-keyframe day/night cycle from --gen-light: • --gen-light-cave — dim cool ambient (0.05, 0.05, 0.07) + heavy short-range fog (15..80) for cave / mine interiors • --gen-light-dungeon — warm torchlit ambient (0.18, 0.14, 0.10) + medium fog (25..200) for dungeon / crypt interiors • --gen-light-night — cold blue ambient (0.06, 0.07, 0.12) + moonlit directional + far fog (80..500) for always-night zones Each preset emits a single-keyframe WOL since enclosed / fixed-time scenes don't vary with time-of-day. All three share an emitLightPreset helper so adding more presets (e.g. --gen-light-tundra, --gen-light-volcanic) is one line of registration + a maker function. All four WOL outputs validate clean under --validate-wol (1 or 4 keyframe(s) valid).
2026-05-09 14:01:26 -07:00
"--gen-light-cave", "--gen-light-dungeon", "--gen-light-night",
feat(editor): add WOL JSON round-trip authoring workflow Two new commands enable a hand-edit authoring loop for the binary .wol format: • --export-wol-json <wol-base> [out.json] Dumps a .wol to a human-readable JSON sidecar (defaults to <base>.wol.json). Preserves every keyframe's time, ambient/directional/fog colors, directional vector, and fog distances. • --import-wol-json <json-path> [out-base] Reads a JSON sidecar and writes back binary .wol. Validates schema strictly — missing keyframes / wrong field types fail with a clear error message. Workflow: --gen-light → --export-wol-json → hand-edit values in any text editor → --import-wol-json → use in renderer. Round-trip verified byte-for-byte identical on the existing sunny.wol fixture: re-import produces the same 4 keyframes with the same colors, fog distances, and zone name.
2026-05-09 14:18:14 -07:00
"--export-wol-json", "--import-wol-json",
feat(editor): add WOW JSON round-trip authoring workflow Mirrors the WOL JSON pair from the previous batch — same hand-edit authoring loop for the binary .wow weather format: • --export-wow-json <wow-base> [out.json] Dumps a .wow to a human-readable JSON sidecar (defaults to <base>.wow.json). Each entry includes BOTH the raw typeId (0..6) and the human-friendly type name ("clear" / "rain" / "snow" / "storm" / "sandstorm" / "fog" / "blizzard"). • --import-wow-json <json-path> [out-base] Reads a JSON sidecar and writes back binary .wow. Accepts either typeId int OR type-name string (typeId wins if both present). Schema mismatches fail with a clear message. Workflow: --gen-weather-* → --export-wow-json → hand-edit weights / durations / intensities → --import-wow-json → use in runtime. Round-trip verified: elwynn.wow → elwynn.wow.json → elwynn_rt.wow shows byte-identical entries via --info-wow. Both atmosphere formats now have full JSON authoring support: WOL: --export-wol-json / --import-wol-json WOW: --export-wow-json / --import-wow-json
2026-05-09 14:25:41 -07:00
"--export-wow-json", "--import-wow-json",
feat(editor): add --validate-wow weather schedule audit Mirrors --validate-wol but for the .wow weather format. Walks every entry and reports structural problems: • unknown weather typeId (above the Blizzard sentinel) • intensity bounds outside [0, 1] or min > max • non-positive weight (would zero a row in weighted-random selection and warp probabilities) • zero or inverted duration bounds • non-finite floats Returns exit code 0 on PASS / 1 on FAIL — CI-friendly. JSON output via --json for tooling. All four built-in presets (--gen-weather-temperate / arctic / desert / stormy) validate clean. The WOW format now has parity with WOL on the inspect/validate front: WOL: --info-wol / --info-wol-at / --validate-wol WOW: --info-wow / --validate-wow Milestone: kArgRequired now at 440 documented flags.
2026-05-09 14:13:30 -07:00
"--info-wow", "--validate-wow",
feat(editor): add --validate-wom static sanity checker Adds a validator for .wom files mirroring --validate-wol / --validate-wow. Catches malformed hand-built or import- corrupted models before they reach the renderer (where bad data usually crashes or renders blank with no diagnostic). Hard errors (exit non-zero): • version not in 1..3 • empty vertex / index list • index count not a multiple of 3 • triangle indices referencing out-of-range vertices • boneIndices referencing out-of-range bones • parentBone referencing out-of-range bones • inverted AABB (boundMin > boundMax on any axis) • WOM3 batch.textureIndex out of range • WOM3 batch range past end of index buffer • animation has wrong number of bone tracks Warnings (informational, exit zero): • boneWeight slots not summing to 0 or 255 • triangles uncovered or double-covered by WOM3 batches • boundRadius <= 0 (frustum-cull failure) Adds 451st kArgRequired entry. Smoke test: 0/0/0 errors on all generated procedural primitives. Both text and --json output supported, mirroring the other validators.
2026-05-09 14:34:22 -07:00
"--validate-wom",
feat(pipeline): add WOMX (Wowee World Map index) format Novel open replacement for Blizzard's WDT (top-level world definition table). The 9th open format added to the editor. A WOMX file holds the manifest of which terrain tiles exist within a world plus a tiny bit of map-level metadata. The runtime consults it before attempting to load any individual tile (so missing tiles produce a clean "no data" result instead of a file-not-found error). Format: • magic "WMPX", version 1, little-endian • mapName + worldType (continent/instance/battleground/arena) • gridSize 1..128 (typically 64 for continents) • defaultLightId / defaultWeatherId (atmosphere preset refs, 0 if none — wires into the WOL/WOW pair) • packed bitmap, 1 bit per tile, row-major • A 64x64 manifest is exactly 512 bytes of bitmap API: WoweeWorldMapLoader::save / load / exists; presets makeContinent (64x64 full), makeInstance (4x4 full), makeArena (1x1 full). CLI added (5 flags, 456 total now): --gen-world-map <base> [name] (continent) --gen-world-map-instance <base> [name] (4x4) --gen-world-map-arena <base> [name] (1x1) --info-womx <base> [--json] --validate-womx <base> [--json] Round-trip verified: continent + instance + arena presets all save / load / re-validate to byte-identical state with correct tile counts.
2026-05-09 14:38:05 -07:00
"--gen-world-map", "--gen-world-map-instance",
"--gen-world-map-arena",
"--info-womx", "--validate-womx",
feat(editor): add WOMX JSON round-trip authoring workflow Mirrors the WOL/WOW JSON pair from earlier batches: gives hand-editable access to .womx world-map manifests for quick tile-bitmap edits without writing a binary patcher. Tile bitmap is represented as a JSON array of '1'/'0' row strings — one string per row of the grid. Visual layout makes missing-row patterns obvious at a glance: "tiles": [ "10000001", "01000010", "00100100", "00011000", ... ] Sparse [[x,y]] pair arrays were considered but rejected: 4× larger for a full continent (4096 tiles), and the dense visual layout is far easier to spot-read for typical edits like "carve out a hole in this region". The importer tolerates missing optional fields (uses WoweeWorldMap defaults), and accepts either worldType int or worldTypeName string so JSON can be authored by hand or by tools. Verified byte-identical round-trip on a 4x4 instance and a hand-authored 8x8 sparse continent (16/64 tiles, both defaultLightId and defaultWeatherId preserved through the JSON layer). Adds 2 flags to reach 458 documented kArgRequired entries. All 9 open formats now have established CLI tooling — WOM, WOB, WOC, WOT, JsonDBC, PNG, WOL, WOW, and WOMX.
2026-05-09 14:39:47 -07:00
"--export-womx-json", "--import-womx-json",
feat(pipeline): add WSND (Wowee Sound Catalog) format Novel open replacement for Blizzard's SoundEntries.dbc + SoundEntriesAdvanced.dbc. The 10th open format added to the editor — covers the audio-metadata gap (the previous 9 cover geometry, terrain, atmosphere, and world manifests, but no sound metadata). Format: • magic "WSND", version 1, little-endian • catalogName + entry count • per entry: soundId / kind / flags / volume / minDistance / maxDistance / filePath / label Kind enum (7 categories): sfx, music, ambient, ui, voice, spell, combat Flags packed (3 bits used, rest reserved): loop (0x01), 3d (0x02), stream (0x04) API: WoweeSoundLoader::save / load / exists; presets makeStarter (one entry per kind), makeAmbient (wilderness loops + footsteps), makeTavern (fire + crowd + drink + door + lute). CLI added (5 flags, 465 documented total now): --gen-sound-catalog <base> [name] --gen-sound-catalog-ambient <base> [name] --gen-sound-catalog-tavern <base> [name] --info-wsnd <base> [--json] --validate-wsnd <base> [--json] Validator catches: out-of-range kind, NaN/inf volume or distances, 3D sounds with bad min/max, duplicate sound IDs, empty filePaths. All 3 presets verified: save / load / validate clean on first run. Variable-length string fields use length- prefixed encoding with a 1 MiB sanity cap on read to prevent corrupted-file allocation blowups.
2026-05-09 14:47:16 -07:00
"--gen-sound-catalog", "--gen-sound-catalog-ambient",
"--gen-sound-catalog-tavern",
"--info-wsnd", "--validate-wsnd",
feat(editor): add WSND JSON round-trip authoring workflow Closes the WSND open-format loop with --export-wsnd-json / --import-wsnd-json, mirroring the WOL/WOW/WOMX JSON pairs from earlier batches. Each entry round-trips all 9 fields: soundId, kind (int + kindName string), flags (int + flagsList string array), volume, minDistance, maxDistance, filePath, label. Both kind and flags are emitted in dual form (int + named): • kind : 2, kindName : "ambient", • flags : 3, flagsList: ["loop", "3d"] The importer accepts either form per field, so a hand-author can write only the named string forms and skip the integer boilerplate. Missing optional fields fall back to WoweeSound::Entry defaults. Verified byte-identical round-trip on the tavern preset (5 entries with mixed flags and 3D distances). Adds 2 flags (467 kArgRequired entries total). All 4 binary formats added in recent batches now have full JSON round-trip: WOL, WOW, WOMX, WSND.
2026-05-09 14:51:44 -07:00
"--export-wsnd-json", "--import-wsnd-json",
feat(pipeline): add WSPN (Wowee Spawn Point catalog) format Novel open replacement for AzerothCore-style scattered creature_template / gameobject SQL spawn tables PLUS the ADT MDDF / MODF doodad-placement chunks. The 11th open format, and the first that covers the live world-content side (atmosphere + sounds + spawns now form the runtime "what fills this zone" picture). A WSPN file holds all spawn points for a zone in a single table, with kind discriminating creature vs game object vs static doodad. The same format powers: • server runtime — knows what NPCs / objects to spawn • editor — draws spawn markers • renderer — reads the doodad subset directly to draw static props without going through a server roundtrip Format: • magic "WSPN", version 1, little-endian • per entry: kind / entryId / position(3f) / rotation(3f) / scale / flags / respawnSec / factionId / questIdRequired / wanderRadius / label Flags packed: disabled (0x01), event-only (0x02), quest-phased (0x04). Reserved bits for future per-entry encoding extensions. API: WoweeSpawnsLoader::save / load / exists; presets makeStarter (1 each kind), makeCamp (4-bandit ring + chest + 2 tents), makeVillage (6 NPCs + 2 signs + 4 corner trees). CLI added (5 flags, 473 documented total now): --gen-spawns / --gen-spawns-camp / --gen-spawns-village --info-wspn / --validate-wspn Validator catches: out-of-range kind, NaN/inf coords, non-positive scale, doodad with non-zero respawn (static prop misuse), creature with respawn=0 (won't respawn after kill), entryId=0 (orphan reference). All 3 presets save / load / re-validate clean. Doodad and game-object entries explicitly set wanderRadius=0 so the generated catalogs are noise-free.
2026-05-09 14:57:53 -07:00
"--gen-spawns", "--gen-spawns-camp", "--gen-spawns-village",
"--info-wspn", "--validate-wspn",
feat(editor): add WSPN JSON round-trip authoring workflow Closes the WSPN open-format loop with --export-wspn-json / --import-wspn-json, mirroring the WOL/WOW/WOMX/WSND JSON pairs from earlier batches. All 5 binary formats added in recent batches now have full JSON round-trip authoring. Each entry round-trips all 12 fields: kind (int + kindName string), entryId, position[3], rotation[3], scale, flags (int + flagsList string array), respawnSec, factionId, questIdRequired, wanderRadius, label. Vector fields are emitted as 3-element arrays for natural JSON layout. Both kind and flags are emitted in dual form (int + named) so a hand-author can write the named string forms and skip the integer boilerplate. Missing optional fields fall back to WoweeSpawns::Entry defaults. Verified byte-identical round-trip on the village preset (12 entries: 6 creature + 2 object + 4 doodad). The position vec3 round-trips through floats with no precision loss for the typical small-coordinate test cases. Adds 2 flags (475 kArgRequired entries total).
2026-05-09 14:59:48 -07:00
"--export-wspn-json", "--import-wspn-json",
feat(pipeline): add WIT (Wowee Item Template) format Novel open replacement for Blizzard's Item.dbc + ItemDisplayInfo.dbc + the SQL item_template tables that AzerothCore-style servers store item definitions in. The 12th open format added to the editor. A WIT file holds the catalog of all items in a content pack: weapons, armor, consumables, quest items, trade goods. Each entry pairs gameplay metadata (stats, level reqs, flags, weapon damage / speed) with display metadata (displayId for icon / model, quality color), so the runtime can render inventory tooltips and equip slots from a single load. Format: • magic "WITM", version 1, little-endian • per item: itemId / displayId / quality / itemClass / itemSubClass / inventoryType / flags / requiredLevel / itemLevel / sellPrice / buyPrice / maxStack / durability / damageMin / damageMax / attackSpeedMs / statCount + stats[] / name / description Enums: • Quality: Poor..Heirloom (8 levels) • Class: Consumable, Weapon, Armor, Quest, ... (13) • InventoryType: Head..Cloak..Weapon2H (18 slots) • Flags: Unique, BoP, BoE, QuestItem, Conjured, ... • StatType: Stamina, Strength, Intellect, Defense, ... API: WoweeItemLoader::save / load / exists / findById; presets makeStarter (4-item demo), makeWeapons (5 items common -> legendary), makeArmor (6-piece mail set with BoE flag). CLI added (5 flags, 480 documented total now): --gen-items / --gen-items-weapons / --gen-items-armor --info-wit / --validate-wit Validator catches: itemId=0, duplicate itemIds, weapons with 0 damage or attackSpeed, weapons with non-weapon slot, equippables with durability=0 or maxStack>1, sell price >= buy price (vendor would lose money), out-of-range quality. All 3 presets save / load / re-validate clean. Info-table output includes a gold/silver/copper price formatter for hand-readability.
2026-05-09 15:04:48 -07:00
"--gen-items", "--gen-items-weapons", "--gen-items-armor",
"--info-wit", "--validate-wit",
feat(editor): add WIT JSON round-trip authoring workflow Closes the WIT open-format loop with --export-wit-json / --import-wit-json, mirroring the WOL/WOW/WOMX/WSND/WSPN JSON pairs. All 6 binary formats added since WOL now have full JSON round-trip authoring. Each entry round-trips all 18 scalar fields plus the variable-length stats array. Three enum-typed fields emit dual int + name forms so a hand-author can use either: • quality (poor..heirloom) • itemClass (consumable / weapon / armor / quest / ...) • inventoryType (head, chest, weapon-1h, ...) Stats round-trip with both type int + typeName string so "strength: 5" reads more naturally than "type=4, value=5" in hand-edit JSON. Verified byte-identical round-trip on the makeWeapons preset (5 items spanning common -> legendary, both 1H and 2H slots, full damage / speed / stat coverage). Adds 2 flags (488 documented total now).
2026-05-09 15:13:26 -07:00
"--export-wit-json", "--import-wit-json",
feat(pipeline): add WLOT (Wowee Loot Table) format Novel open replacement for AzerothCore-style creature_loot_template / gameobject_loot_template SQL tables. The 13th open format added to the editor. Pairs naturally with the WIT item catalog from the preceding commit: each loot drop's itemId references an entry in a WIT file, so a content pack ships both the item definitions and the loot tables that reference them. The runtime composes WIT + WLOT + WSPN to drive the full "creature dies, drops items" flow without any SQL. Format: • magic "WLOT", version 1, little-endian • per table: creatureId / flags / dropCount / moneyMin..Max / itemDropCount + drops[] • per drop: itemId / chancePercent (float, 0..100) / minQty / maxQty / drop_flags Table flags: QuestOnly, GroupOnly, Pickpocket Drop flags: QuestRequired, GroupRollOnly, AlwaysDrop dropCount is the slot budget — how many distinct drops to roll per kill. Each item drop is rolled independently against its chancePercent (so dropCount=2 with 4 candidate drops at varying chances gives the classic "up to 2 distinct items per kill" behavior). Drops with the AlwaysDrop flag bypass the slot budget — used for guaranteed quest items. API: WoweeLootLoader::save / load / exists / findByCreatureId; presets makeStarter (1 table, 1 drop), makeBandit (4 candidates, dropCount=2, matches the camp spawns from WSPN at creatureId=1000), makeBoss (6 candidates including guaranteed quest item via AlwaysDrop and a group-only epic at 5%). CLI added (5 flags, 486 documented total now): --gen-loot / --gen-loot-bandit / --gen-loot-boss --info-wlot / --validate-wlot Validator catches: creatureId=0, duplicates, chance not in 0..100, NaN chance, money min > max, minQty > maxQty, dropCount=0 with non-empty drops list (silent dead config). All 3 presets save / load / re-validate clean. The bandit table's creatureId=1000 deliberately matches WSPN's makeCamp creatureId so the open-format demo content pack already has working cross-references.
2026-05-09 15:11:08 -07:00
"--gen-loot", "--gen-loot-bandit", "--gen-loot-boss",
"--info-wlot", "--validate-wlot",
feat(editor): add WLOT JSON round-trip authoring workflow Closes the WLOT open-format loop with --export-wlot-json / --import-wlot-json, mirroring the WOL/WOW/WOMX/WSND/WSPN/WIT JSON pairs. All 7 binary formats added since WOL now have full JSON round-trip authoring. Each loot table round-trips: • table-level: creatureId, flags (int + flagsList strings), dropCount, money min/max (copper) • per-drop: itemId, chancePercent (float), minQty / maxQty, flags (int + flagsList) Both flag fields emit dual int + named string-array forms. A hand-author can write ["quest", "always"] instead of having to remember that QuestRequired|AlwaysDrop = 5. Verified byte-identical round-trip on the boss preset (6 drops including the QuestRequired+AlwaysDrop combo on the guaranteed quest item, group-only epic at 5%, mass-loot trade goods at 90%). Adds 2 flags (495 documented total now).
2026-05-09 15:20:05 -07:00
"--export-wlot-json", "--import-wlot-json",
feat(pipeline): add WCRT (Wowee Creature Template) format Novel open replacement for the AzerothCore-style creature_template SQL table PLUS the Blizzard CreatureTemplate / CreatureFamily / CreatureType.dbc trio. The 14th open format added to the editor. This is the canonical metadata side of creatures shared across every spawn instance: HP, level range, faction, behavior flags, NPC role bits (vendor / trainer / quest-giver / innkeeper), base damage, equipped gear references. Cross-references with the previously-added formats: WSPN.entry.entryId -> WCRT.entry.creatureId WLOT.entry.creatureId -> WCRT.entry.creatureId WCRT.entry.equipped* -> WIT.entry.itemId The 4-format set (WIT + WLOT + WSPN + WCRT) now lets a content pack define a complete RPG zone's creature ecosystem: what creatures are, where they spawn, what they drop, and what gear they carry — entirely in open formats with no SQL dependencies. Format: • magic "WCRT", version 1, little-endian • per entry: creatureId / displayId / name / subname / minLevel..maxLevel / baseHealth + healthPerLevel / baseMana + manaPerLevel / factionId / npcFlags / typeId / familyId / damageMin..Max / attackSpeedMs / baseArmor / walkSpeed + runSpeed / gossipId / equippedMain + equippedOffhand + equippedRanged / aiFlags Enums: • TypeId: Beast / Dragon / Demon / Elemental / Giant / Undead / Humanoid / Critter / Mechanical • FamilyId: Wolf / Cat / Bear / Boar / Raptor / Hyena / Spider / Gorilla / Crab (for Beast types) • NpcFlags: Vendor / QuestGiver / Trainer / Banker / Innkeeper / FlightMaster / Auctioneer / Repair / Stable • Behavior: Passive / Aggressive / FleeLowHp / CallHelp / NoLeash API: WoweeCreatureLoader::save / load / exists / findById; presets makeStarter (1 innkeeper), makeBandit (creatureId=1000 matches WSPN/WLOT bandit references, equips WIT itemId=1001 sword), makeMerchants (creatureIds 4001/4002/4003 match WSPN village labels). CLI added (5 flags, 493 documented total): --gen-creatures / --gen-creatures-bandit / --gen-creatures-merchants --info-wcrt / --validate-wcrt Validator catches: creatureId=0, duplicates, level=0, minLevel>maxLevel, baseHealth=0, damageMin>damageMax, attackSpeed=0, non-positive walk/runSpeed, behavior flag contradictions (passive+aggressive), vendor with aggressive behavior (player can't trade).
2026-05-09 15:18:44 -07:00
"--gen-creatures", "--gen-creatures-bandit", "--gen-creatures-merchants",
"--info-wcrt", "--validate-wcrt",
feat(editor): add WCRT JSON round-trip authoring workflow Closes the WCRT open-format loop with --export-wcrt-json / --import-wcrt-json, mirroring the WOL/WOW/WOMX/WSND/WSPN/ WIT/WLOT JSON pairs. All 8 binary formats added since WOL now have full JSON round-trip authoring. Each creature template round-trips all 22 scalar fields. Three enum-typed fields emit dual int + name forms so a hand-author can use either: • typeId (humanoid / beast / dragon / ...) • familyId (wolf / cat / bear / ... — for beasts) • npcFlags (vendor / quest / trainer / innkeeper / ...) • aiFlags (passive / aggressive / flee / call-help / no-leash) Both flag bitsets emit string-array forms so a hand-author can write ["vendor", "innkeeper", "repair"] instead of having to remember that those bits combine to 0x91. Verified byte-identical round-trip on the merchants preset (3 NPCs covering innkeeper / smith / alchemist with mixed flag combinations). Adds 2 flags (502 documented total now).
2026-05-09 15:27:12 -07:00
"--export-wcrt-json", "--import-wcrt-json",
feat(pipeline): add WQT (Wowee Quest Template) format Novel open replacement for AzerothCore-style quest_template SQL tables PLUS the Blizzard Quest.dbc / QuestObjective.dbc trio. The 15th open format added to the editor — and the last gameplay-graph piece the catalog needed. Cross-references with previously-added formats: WQT.giverCreatureId -> WCRT.entry.creatureId WQT.turninCreatureId -> WCRT.entry.creatureId WQT.objective.targetId -> WCRT (kill) / WIT (collect) / WOB (interact) WQT.rewardItem.itemId -> WIT.entry.itemId WQT.prevQuestId -> WQT.entry.questId (intra-format) WQT.nextQuestId -> WQT.entry.questId Together with WIT / WCRT / WLOT / WSPN / WOMX / WOL / WOW / WSND, a content pack can now ship a complete RPG zone (terrain + props + atmosphere + sounds + creatures + items + loot + spawns + quests) entirely in open formats with no SQL or .dbc dependencies. 15 of 15 expected slots filled. Format: • magic "WQTM", version 1, little-endian • per quest: questId / title / objective / description / minLevel..maxLevel + questLevel / requiredClass+RaceMask / prev+nextQuestId / giver+turninCreatureId / objectives[] / xpReward + moneyCopperReward / rewardItems[] / flags Per-objective: kind (kill/collect/interact/visit/escort/cast), targetId, quantity Per-reward: itemId, qty, pickFlags (AutoGiven / PlayerChoice) Quest flags: Daily / Weekly / Raid / Group / AutoComplete / AutoAccept / Repeatable / ClassQuest / Pvp API: WoweeQuestLoader::save / load / exists / findById; presets makeStarter (1 simple kill quest, references the bandit creatureId=1000), makeChain (3-quest chain with prev/next links + AutoComplete bridge + player-choice rewards), makeDaily (Daily+Repeatable+AutoAccept combo). CLI added (5 flags, 500 documented total — round milestone): --gen-quests / --gen-quests-chain / --gen-quests-daily --info-wqt / --validate-wqt Validator catches: questId=0+duplicates, level=0, maxLevel<minLevel, empty title, no objectives without AutoComplete (player can't finish), no rewards at all, Daily without Repeatable (incoherent), targetId=0, quantity=0, unknown objective kind, reward itemId=0 or qty=0. The 3-quest chain demo exercises every major feature: • multiple objective kinds (visit / collect / kill) • prev/next chain links • AutoComplete dialogue-bridge quest • PlayerChoice reward (1 of 2 weapons)
2026-05-09 15:25:02 -07:00
"--gen-quests", "--gen-quests-chain", "--gen-quests-daily",
"--info-wqt", "--validate-wqt",
feat(editor): add WQT JSON round-trip authoring workflow Closes the WQT open-format loop with --export-wqt-json / --import-wqt-json, mirroring the WOL/WOW/WOMX/WSND/WSPN/ WIT/WLOT/WCRT JSON pairs. All 9 binary formats added since WOL now have full JSON round-trip authoring. Each quest round-trips: • 13 scalar fields (id, level range, masks, chain links, giver/turnin, xp + money reward, flags) • 3 string fields (title, objective, description) • objectives array with dual int + name kindName • rewardItems array with dual int + name pickFlagsList The flag bitset emits string-array form so a hand-author can write ["daily", "repeatable", "auto-accept"] instead of having to remember the bit math. The objective kindName makes "visit/collect/kill" obvious without needing to know that kind=3 means VisitArea. Verified byte-identical round-trip on the 3-quest chain preset (full feature exercise: prev/next chain links, mixed objective kinds, AutoComplete bridge quest, player- choice rewards). Adds 2 flags (509 documented total now).
2026-05-09 15:33:21 -07:00
"--export-wqt-json", "--import-wqt-json",
feat(pipeline): add WGOT (Wowee Game Object Template) format Novel open replacement for AzerothCore-style gameobject_template SQL tables PLUS the Blizzard GameObjectDisplayInfo.dbc / GameObject types metadata. The 16th open format added to the editor. Game objects are the non-creature interactable scenery: chests (with loot), doors, buttons, mailboxes, herb / ore gathering nodes, fishing pools, signposts, mounts. Each has a displayId for the model, a typeId driving its interaction logic, and optional cross-references to a lock (future WLCK) and loot table (existing WLOT). Cross-references with previously-added formats: WSPN.entry.entryId (kind=GameObject) -> WGOT.entry.objectId WGOT.entry.lootTableId -> WLOT.entry.creatureId (loot tables are universal — chests and creatures both key by ID) The dungeon preset's Bandit Strongbox uses lootTableId=2000 to match WLOT's bandit chest table id, so the demo content stack already wires together: spawn (WSPN object kind 2000) -> object template (WGOT 2000) -> loot table (WLOT 2000). Format: • magic "WGOT", version 1, little-endian • per object: objectId / displayId / name / typeId / size / castBarCaption / requiredSkill + requiredSkillValue / lockId / lootTableId / minOpenTimeMs..maxOpenTimeMs / flags Enums: • TypeId (16): Door / Button / Chest / Container / QuestGiver / Text / Trap / Goober / Transport / Mailbox / MineralNode / HerbNode / FishingNode / Mount / Sign / Bonfire • Flags: Disabled / ScriptOnly / UsableFromMount / Despawn / Frozen / QuestGated API: WoweeGameObjectLoader::save / load / exists / findById; presets makeStarter (chest + mailbox + sign), makeDungeon (door + button + 2 chests + trap with proper WLOT cross-references), makeGather (Peacebloom herb + Tin Vein ore + fishing pool with skill requirements). CLI added (5 flags, 507 documented total now): --gen-objects / --gen-objects-dungeon / --gen-objects-gather --info-wgot / --validate-wgot Validator catches: objectId=0 + duplicates, size<=0, minOpenTime>maxOpenTime, gathering node without skill requirement (anyone can harvest — usually a typo), chest without loot table (script must populate), requiredSkillValue set without requiredSkill (incoherent).
2026-05-09 15:31:49 -07:00
"--gen-objects", "--gen-objects-dungeon", "--gen-objects-gather",
"--info-wgot", "--validate-wgot",
feat(editor): add WGOT JSON round-trip authoring workflow Closes the WGOT open-format loop with --export-wgot-json / --import-wgot-json, mirroring the JSON pairs added for every other novel binary format. All 10 binary formats added since WOL now have full JSON round-trip authoring. Each game object round-trips all 13 scalar fields plus dual int + name forms for typeId (16 enum values) and the flags bitset. The flag bitset emits string-array form so a hand-author can write ["despawn"] instead of having to remember that Despawn = 0x08. typeName makes "door/chest/herb-node/..." obvious without needing to know typeId=11 means HerbNode. Verified byte-identical round-trip on the dungeon preset (5 objects: door + button + 2 chests + trap with full WLOT cross-references and lockId fields preserved). Adds 2 flags (516 documented total now).
2026-05-09 15:39:50 -07:00
"--export-wgot-json", "--import-wgot-json",
feat(pipeline): add WFAC (Wowee Faction Catalog) format Novel open replacement for Blizzard's Faction.dbc + FactionTemplate.dbc + the AzerothCore-style reputation_reward / reputation_spillover SQL tables. The 17th open format added to the editor. Combines the "displayable Faction" (player-facing name + reputation thresholds for friendly/honored/revered/exalted) with the "FactionTemplate matrix" (which factions are hostile to which) into one entry. The runtime walks the catalog to answer two questions: • "Will faction A attack faction B on sight?" -> enemy list • "What rep tier is the player with X?" -> thresholds Cross-references with previously-added formats: WCRT.entry.factionId -> WFAC.entry.factionId WFAC.entry.parentFactionId -> WFAC.entry.factionId WFAC.entry.enemies[] -> WFAC.entry.factionId WFAC.entry.friends[] -> WFAC.entry.factionId The starter preset's factionId 35 (Friendly) and 14 (Hostile) deliberately match the WCRT preset defaults, so the demo content stack is consistent: WCRT.makeBandit's factionId=14 has a real entry in WFAC.makeStarter that declares it hostile to friendly NPCs (35) and players (1). Format: • magic "WFAC", version 1, little-endian • per faction: factionId / parentFactionId / name / description / reputationFlags / baseReputation / 7 ascending tier thresholds (hostile..exalted) / enemies[] / friends[] Enums: • ReputationFlags: VisibleOnTab / AtWarDefault / Hidden / NoReputation / IsHeader (group label) • Tier (canonical): Hated / Hostile / Unfriendly / Neutral / Friendly / Honored / Revered / Exalted API: WoweeFactionLoader::save / load / exists / findById + WoweeFaction::isHostile(a, b); presets makeStarter (3-faction demo matching WCRT defaults), makeAlliance (header + Stormwind / Darnassus / Ironforge with reciprocal friend lists + Defias enemy), makeWildlife (4 beast factions, each hostile to player but ignoring other beasts). CLI added (5 flags, 514 documented total now): --gen-factions / --gen-factions-alliance / --gen-factions-wildlife --info-wfac / --validate-wfac Validator catches: factionId=0 + duplicates, empty name, threshold ordering violations (hostile must be < unfriendly < neutral < ... < exalted), self-listed as enemy or friend, faction in both enemies and friends (incoherent).
2026-05-09 15:37:59 -07:00
"--gen-factions", "--gen-factions-alliance", "--gen-factions-wildlife",
"--info-wfac", "--validate-wfac",
feat(editor): add WFAC JSON round-trip authoring workflow Closes the WFAC open-format loop with --export-wfac-json / --import-wfac-json, mirroring the JSON pairs added for every other novel binary format. All 11 binary formats added since WOL now have full JSON round-trip authoring. Each faction round-trips: • 13 scalar fields (id, parent, name, description, flags, 7 ascending threshold values, baseReputation) • enemies[] and friends[] as JSON int arrays for trivial hand-edit • reputationFlags as dual int + string-array form (e.g. ["visible", "header"]) The 7 reputation thresholds round-trip exactly even though they have non-default values in some presets — the importer uses the canonical Hostile/Friendly/etc enum values as defaults so a hand-author can omit the standard thresholds and only specify custom ones. Verified byte-identical round-trip on the alliance preset (5 factions: Alliance header + 3 cities with reciprocal friend lists + Defias enemy). Adds 2 flags (523 documented total now).
2026-05-09 15:45:58 -07:00
"--export-wfac-json", "--import-wfac-json",
feat(pipeline): add WLCK (Wowee Lock Template) format Novel open replacement for Blizzard's Lock.dbc. The 18th open format added to the editor. Closes the cross-reference gap from WGOT.entry.lockId — until now that field pointed to a format that didn't exist yet. A lock is a multi-channel security check. Each lock has up to 5 independent channels; a player can open the lock by satisfying ANY ONE channel: • Item — requires a specific key item (WIT cross-ref) • Lockpick — requires the lockpicking skill at minimum rank (rogue / engineering profession) • Spell — requires casting a specific spell • Damage — can be forced open with attack damage Cross-references with previously-added formats: WGOT.entry.lockId -> WLCK.entry.lockId WLCK.channel.targetId (Item) -> WIT.entry.itemId WLCK.channel.targetId (Lockpick) -> future WSKL skillId WLCK.channel.targetId (Spell) -> future WSPL spellId The starter and dungeon presets' lockIds (1 and 2) deliberately match WGOT.makeDungeon's iron-door lockId=1 and bandit-strongbox lockId=2, so the demo content stack already wires together: WSPN spawn -> WGOT object template -> WLCK lock template -> WIT key items. Format: • magic "WLCK", version 1, little-endian • per lock: lockId / name / flags / 5 fixed channel slots • per channel: kind / skillRequired / targetId • all 5 slots written even when unused (kind=None + zeroed fields), keeping the per-entry size constant for fast random access Enums: • ChannelKind: None / Item / Lockpick / Spell / Damage • Flags: DestructOnOpen / RespawnOnKey / TrapOnFail API: WoweeLockLoader::save / load / exists / findById; presets makeStarter (Iron Door + Wooden Chest), makeDungeon (matches WGOT cross-references; light/heavy lockpicks + boss-key-only seal), makeProfessions (4-tier rogue lockpick progression at ranks 1/100/175/250). CLI added (5 flags, 521 documented total now): --gen-locks / --gen-locks-dungeon / --gen-locks-professions --info-wlck / --validate-wlck Validator catches: lockId=0 + duplicates, all-None channels (lock can never open), Item/Spell/Lockpick channels with targetId=0 (no resource referenced), unknown channel kind, skillRequired set on non-Lockpick channel (silently ignored at runtime — flag as warning).
2026-05-09 15:44:26 -07:00
"--gen-locks", "--gen-locks-dungeon", "--gen-locks-professions",
"--info-wlck", "--validate-wlck",
feat(editor): add WLCK JSON round-trip authoring workflow Closes the WLCK open-format loop with --export-wlck-json / --import-wlck-json, mirroring the JSON pairs added for every other novel binary format. All 12 binary formats added since WOL now have full JSON round-trip authoring. Each lock round-trips: • lockId, name, flags • all 5 channel slots (even unused ones, kind=None) • each channel: kind (dual int + name) + skillRequired + targetId The flag bitset emits string-array form so a hand-author can write ["destruct"] instead of having to remember that DestructOnOpen = 0x01. Channel kindName makes the difference between item / lockpick / spell / damage obvious without needing to know the int values. Verified byte-identical round-trip on the dungeon preset (3 locks: light lockpick + steel chest with dual key/pick channels + boss-key seal with destruct flag). Adds 2 flags (530 documented total now).
2026-05-09 15:52:20 -07:00
"--export-wlck-json", "--import-wlck-json",
feat(pipeline): add WSKL (Wowee Skill Catalog) format 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).
2026-05-09 15:50:25 -07:00
"--gen-skills", "--gen-skills-professions", "--gen-skills-weapons",
"--info-wskl", "--validate-wskl",
feat(editor): add WSKL JSON round-trip authoring workflow Closes the WSKL open-format loop with --export-wskl-json / --import-wskl-json, mirroring the JSON pairs added for every other novel binary format. All 13 binary formats added since WOL now have full JSON round-trip authoring. Each skill round-trips all 8 scalar fields (skillId, name, description, categoryId, canTrain, maxRank, rankPerLevel, iconPath). The categoryId emits dual int + name forms so a hand-author can write "profession" / "weapon" / "language" instead of the int values. Verified byte-identical round-trip on the professions preset (12 entries: 9 primary + 3 secondary professions with full canonical SkillLine IDs preserved). Adds 2 flags (537 documented total now).
2026-05-09 15:59:20 -07:00
"--export-wskl-json", "--import-wskl-json",
feat(pipeline): add WSPL (Wowee Spell Catalog) format Novel open replacement for Blizzard's Spell.dbc + SpellEffect.dbc + the AzerothCore-style spell_dbc / spell_proc tables. The 20th open format added to the editor — completes the canonical-data side of the gameplay graph. Each entry holds the metadata side of a spell: name, description, school, range, mana / cast / cooldown times, plus a single primary effect. The simplified effect model (one effectKind + min/max value + misc field) covers the common cases (damage / heal / buff / debuff / teleport / summon / dispel) without needing to reproduce the full multi-effect graph that classic Spell.dbc carries. Cross-references with previously-added formats: WLCK.channel.targetId (kind=Spell) -> WSPL.entry.spellId WQT.objective.targetId (kind=SpellCast) -> WSPL.entry.spellId WCRT.equippedMain (item with on-use) -> WIT -> WSPL Format: • magic "WSPL", version 1, little-endian • per spell: spellId / name / description / iconPath / school / targetType / effectKind / cast & cooldown & GCD ms / manaCost / range min..max / minLevel / maxStacks / durationMs / effectValueMin..Max / effectMisc / flags Enums: • School (7): Physical / Holy / Fire / Nature / Frost / Shadow / Arcane • TargetType (6): Self / Single / Cone / AoeFromSelf / Line / Ground • EffectKind (7): Damage / Heal / Buff / Debuff / Teleport / Summon / Dispel • Flags: Passive / Hidden / Channeled / Ranged / AreaOfEffect / Triggered / UnitTargetOnly / FriendlyOnly / HostileOnly API: WoweeSpellLoader::save / load / exists / findById; presets makeStarter (Strike + Lesser Heal + Power Word: Fortitude + Hearthstone, one per major effect kind), makeMage (Frostbolt 116 + Fireball 133 + Arcane Intellect 1459 + Blink 1953, canonical Classic spellIds), makeWarrior (Heroic Strike 78 + Thunder Clap 6343 + Battle Shout 6673 + Mortal Strike 12294). CLI added (5 flags, 535 documented total now): --gen-spells / --gen-spells-mage / --gen-spells-warrior --info-wspl / --validate-wspl Validator catches: spellId=0 + duplicates, empty name, school out of range, effectKind out of range, NaN range, range/value min>max, FriendlyOnly+HostileOnly conflict (incoherent), friendly-only with damage/debuff effect (incoherent), hostile-only with heal/buff effect, buff/debuff effect with durationMs=0 (instant fade — almost certainly authoring oversight). The validator caught a real preset-emitter authoring error during initial smoke testing — buff spells were setting effectValueMin without effectValueMax (validator's range check immediately flagged it), prompting an in-batch fix to set both fields. This is exactly the catch-the-typo purpose validators serve.
2026-05-09 15:58:09 -07:00
"--gen-spells", "--gen-spells-mage", "--gen-spells-warrior",
"--info-wspl", "--validate-wspl",
feat(editor): add WSPL JSON round-trip authoring workflow Closes the WSPL open-format loop with --export-wspl-json / --import-wspl-json, mirroring the JSON pairs added for every other novel binary format. All 14 binary formats added since WOL now have full JSON round-trip authoring. Each spell round-trips all 18 scalar fields. Four enum-typed fields emit dual int + name forms so a hand-author can use either: • school (physical / holy / fire / nature / frost / shadow / arcane) • targetType (self / single / cone / aoe-self / line / ground) • effectKind (damage / heal / buff / debuff / teleport / summon / dispel) • flags (passive / channeled / ranged / aoe / friendly / hostile / ...) The flags bitset emits string-array form so a hand-author can write ["hostile", "aoe"] instead of having to remember that HostileOnly|AreaOfEffect = 0x110. Verified byte-identical round-trip on the mage preset (4 spells covering frost / fire / arcane schools and damage / buff / teleport effects, full flag and effect-value coverage). Adds 2 flags (544 documented total now).
2026-05-09 16:06:29 -07:00
"--export-wspl-json", "--import-wspl-json",
feat(pipeline): add WACH (Wowee Achievement Catalog) format Novel open replacement for Blizzard's Achievement.dbc + AchievementCriteria.dbc + AchievementCategory.dbc + the AzerothCore-style character_achievement / character_achievement_progress SQL tables. The 21st open format added to the editor. Each achievement carries display metadata (name, description, icon, points, faction restriction) plus a list of criteria the player must satisfy. Criteria mirror the WQT objective model (kind + targetId + quantity), so the runtime can reuse the same progress-tracking machinery for both quests and achievements. Cross-references with previously-added formats — every criterion kind has a real format target: WACH.criteria.targetId (kind=KillCreature) -> WCRT.creatureId WACH.criteria.targetId (kind=CompleteQuest) -> WQT.questId WACH.criteria.targetId (kind=LootItem) -> WIT.itemId WACH.criteria.targetId (kind=CastSpell) -> WSPL.spellId WACH.criteria.targetId (kind=ReachSkillLevel) -> WSKL.skillId WACH.criteria.targetId (kind=EarnReputation) -> WFAC.factionId WACH.criteria.targetId (kind=CompleteAchievement) -> WACH.achievementId (meta-achievements) Format: • magic "WACH", version 1, little-endian • per achievement: id / categoryId / name / description / iconPath / titleReward / points / minLevel / faction / flags / criteria[] • per criterion: criteriaId / kind / targetId / quantity / description Enums: • CriteriaKind (9): KillCreature / CompleteQuest / LootItem / ReachLevel / EarnReputation / CastSpell / ReachSkillLevel / VisitArea / CompleteAchievement • Faction: Both / Alliance / Horde • Flags: HiddenUntilEarned / ServerFirst / RealmFirst / Tracking / Counter / Account API: WoweeAchievementLoader::save / load / exists / findById; presets makeStarter (3 simple kill/quest/level demos), makeBandit (3 with WCRT/WGOT/WQT cross-refs), makeMeta (3 base + 1 meta-achievement granting "the Versatile" title, exercising CompleteAchievement criterion kind that lets achievements depend on other achievements). CLI added (5 flags, 542 documented total now): --gen-achievements / --gen-achievements-bandit / --gen-achievements-meta --info-wach / --validate-wach Validator catches: achievementId=0 + duplicates, empty name, faction out of range, no criteria (achievement can never be earned), criterion quantity=0, unknown criterion kind, targetId=0 on criterion kinds that need a real resource reference (everything except ReachLevel which uses the quantity field for the level number). The bandit preset's cross-references close the gameplay graph end-to-end: kill 50 creatureId=1000 (matches WCRT/ WSPN/WLOT bandit), loot objectId=2000 (matches WGOT bandit strongbox), complete questId=1 (matches WQT Bandit Trouble). The meta preset closes a separate loop: 3 sub-achievements covering Mining (skillId=186), Lockpicking (skillId=633), and Frostbolt cast count (spellId=116) — each pointing at a real WSKL/WSPL entry that already exists in the demo content stack.
2026-05-09 16:04:30 -07:00
"--gen-achievements", "--gen-achievements-bandit", "--gen-achievements-meta",
"--info-wach", "--validate-wach",
feat(editor): add WACH JSON round-trip authoring workflow Closes the WACH open-format loop with --export-wach-json / --import-wach-json, mirroring the JSON pairs added for every other novel binary format. All 15 binary formats added since WOL now have full JSON round-trip authoring. Each achievement round-trips: • 11 scalar fields (id, categoryId, name, description, icon, titleReward, points, minLevel, faction, flags) • criteria array with full per-criterion fields Three enum-typed fields emit dual int + name forms so a hand-author can use either: • criterion.kind (kill/quest/loot/level/rep/cast/skill/visit/meta) • faction (both/alliance/horde) • flags (hidden/server-first/realm-first/tracking/...) Verified byte-identical round-trip on the meta preset (4 achievements, 6 criteria including the 3 CompleteAchievement criteria that wire the meta-achievement to its prerequisites). Adds 2 flags (546 documented total now).
2026-05-09 16:07:53 -07:00
"--export-wach-json", "--import-wach-json",
feat(pipeline): add WTRN (Wowee Trainer / Vendor catalog) format Novel open replacement for AzerothCore-style npc_trainer + npc_vendor SQL tables PLUS the Blizzard TrainerSpells.dbc family. The 22nd open format added to the editor. Unifies trainer spell lists and vendor item inventories into one per-NPC entry. A creature flagged Trainer or Vendor in WCRT references a WTRN entry that lists what they teach / sell. The same NPC can be both — kindMask is a bitmask covering the Trainer (0x01) and Vendor (0x02) kinds. This format closes a major cross-format gap: WCRT.npcFlags already had Vendor / Trainer bits, but until now there was no format defining what a vendor sells or what a trainer teaches. Now an NPC marked Vendor in WCRT has a real inventory, and an NPC marked Trainer has a real spell list. Cross-references — every WTRN field has a real format target: WTRN.entry.npcId -> WCRT.entry.creatureId WTRN.spell.spellId -> WSPL.entry.spellId WTRN.spell.requiredSkillId -> WSKL.entry.skillId WTRN.item.itemId -> WIT.entry.itemId Format: • magic "WTRN", version 1, little-endian • per NPC: npcId / kindMask / greeting + spells[] + items[] • per spell offer: spellId / moneyCostCopper / requiredSkillId / requiredSkillRank / requiredLevel • per item offer: itemId / stockCount (0xFFFFFFFF = unlimited) / restockSec / extendedCost / moneyCostCopper (0 = inherit from WIT.buyPrice) API: WoweeTrainerLoader::save / load / exists / findByNpc; presets makeStarter (innkeeper 4001 as both trainer + vendor: teaches First Aid + sells starter items), makeMageTrainer (NPC 4003 teaches the WSPL mage spells at scaling cost), makeWeaponVendor (NPC 4002 sells WIT weapons with mixed unlimited/finite stock + restock timers). CLI added (5 flags, 551 documented total now): --gen-trainers / --gen-trainers-mage / --gen-trainers-weapons --info-wtrn / --validate-wtrn Validator catches: npcId=0 + duplicates, kindMask=0 (NPC offers nothing), Trainer flag without spells, Vendor flag without items, spells/items present without the matching kind bit (silently ignored at runtime), spellId=0 / itemId=0 in offers, finite stock with restockSec=0 (single-fill — usually intentional but worth surfacing). The 3 presets deliberately use npcIds matching WCRT village merchants (4001/4002/4003) so the demo content stack is self-consistent: WCRT 4001 has the Vendor + Trainer flag, and WTRN 4001 actually defines what they sell and teach.
2026-05-09 16:12:58 -07:00
"--gen-trainers", "--gen-trainers-mage", "--gen-trainers-weapons",
"--info-wtrn", "--validate-wtrn",
feat(editor): add WTRN JSON round-trip authoring workflow Closes the WTRN open-format loop with --export-wtrn-json / --import-wtrn-json, mirroring the JSON pairs added for every other novel binary format. All 16 binary formats added since WOL now have full JSON round-trip authoring. Each NPC round-trips: • npcId, kindMask (dual int + kindList string array), greeting • spells[]: spellId / cost / requiredSkill+rank / minLevel • items[]: itemId / stockCount / restockSec / extendedCost / moneyCostCopper The stockCount field has special handling — the sentinel 0xFFFFFFFF value emits as the string "unlimited" instead of the raw integer, since 4294967295 reads as a magic-number typo in hand-edit JSON. The importer accepts either form. Verified byte-identical round-trip on the starter preset (innkeeper 4001 with 1 spell + 3 items, exercising both unlimited-stock and finite-stock-with-restock cases). Adds 2 flags (553 documented total now).
2026-05-09 16:14:50 -07:00
"--export-wtrn-json", "--import-wtrn-json",
feat(pipeline): add WGSP (Wowee Gossip Menu) format Novel open replacement for AzerothCore-style gossip_menu + gossip_menu_option + npc_text SQL tables PLUS the Blizzard NpcText.dbc family. The 23rd open format added to the editor. An NPC's dialogue tree: a menu of options the player can pick from when right-clicking the NPC. Each option may bridge to another menu, trigger a vendor / trainer interaction, offer a quest, etc. The simplified per-option model (kind + actionTarget + flags + moneyCost) covers the common cases without needing separate npc_text condition tables. Closes a major cross-format gap: WCRT.entry.gossipId has existed since batch 116 (when WCRT was added) but pointed to a format that didn't exist yet. The innkeeper preset's menuId=4001 deliberately matches WCRT's Bartleby NPC so the demo content stack can wire WCRT.gossipId = 4001 once that field is plumbed through the runtime. Cross-references: WCRT.entry.gossipId -> WGSP.entry.menuId WGSP.option.actionTarget (Submenu) -> WGSP.entry.menuId WGSP.option.actionTarget (Vendor / Trainer) -> WTRN.entry.npcId WGSP.option.actionTarget (Quest) -> WQT.entry.questId Format: • magic "WGSP", version 1, little-endian • per menu: menuId / titleText + options[] • per option: optionId / text / kind / actionTarget / requiredFlags / moneyCostCopper Enums: • OptionKind (13): Close / Submenu / Vendor / Trainer / Quest / Tabard / Banker / Innkeeper / FlightMaster / TextOnly / Script / Battlemaster / Auctioneer • OptionFlags: AllianceOnly / HordeOnly / Coinpouch / QuestGated / Closes API: WoweeGossipLoader::save / load / exists / findById; presets makeStarter (1 menu with vendor + trainer + close), makeInnkeeper (2-menu tree: main menu 4001 with hearth / vendor / flight / submenu options + lore submenu 4002 that links back), makeQuestGiver (1 menu with 2 quest options referencing WQT 1 and 100, plus a paid respec script exercising the Coinpouch flag with a 10g cost). CLI added (5 flags, 558 documented total now): --gen-gossip / --gen-gossip-innkeeper / --gen-gossip-questgiver --info-wgsp / --validate-wgsp Validator catches: menuId=0 + duplicates, empty title / options, unknown option kind, empty option text, Submenu options pointing at non-existent menuIds (intra-format cross-reference resolution), Coinpouch flag without moneyCost (misleading UI), AllianceOnly+HordeOnly conflict.
2026-05-09 16:20:07 -07:00
"--gen-gossip", "--gen-gossip-innkeeper", "--gen-gossip-questgiver",
"--info-wgsp", "--validate-wgsp",
feat(editor): add WGSP JSON round-trip authoring workflow Closes the WGSP open-format loop with --export-wgsp-json / --import-wgsp-json, mirroring the JSON pairs added for every other novel binary format. All 17 binary formats added since WOL now have full JSON round-trip authoring. Each menu round-trips: • menuId, titleText • options[] with optionId / text / kind (dual int + name) / actionTarget / requiredFlags (dual int + flag-string array) / moneyCostCopper The kindName field makes it obvious that a hand-edited "vendor" / "trainer" / "submenu" string maps to the right internal value without needing to know that vendor=2 and submenu=1. Verified byte-identical round-trip on the innkeeper preset (2 menus, 7 options including Submenu cross-references that must stay byte-stable to preserve the inter-menu graph). Adds 2 flags (566 documented total now).
2026-05-09 16:28:12 -07:00
"--export-wgsp-json", "--import-wgsp-json",
feat(pipeline): add WTAX (Wowee Taxi catalog) format Novel open replacement for Blizzard's TaxiNodes.dbc + TaxiPath.dbc + TaxiPathNode.dbc. The 24th open format added to the editor. Defines the flight-master network: a set of named nodes (positions on the world map) plus the paths between them (sequences of waypoints with per-segment delay and a per-path gold cost). The same file holds both node and path lists — flat arrays keyed by id, with intra-format references from path.fromNodeId / toNodeId to node.nodeId. Cross-references: WCRT.entry (with FlightMaster npcFlag) ~= WTAX.nodeId (matched by world position; flight master NPCs stand at their nodes) WTAX.path.fromNodeId / toNodeId -> WTAX.entry.nodeId (intra-format graph) Format: • magic "WTAX", version 1, little-endian • nodes (each): nodeId / mapId / name / iconPath / position / faction restrictions • paths (each): pathId / from+toNodeId / moneyCostCopper / waypoints[] each with position + per-waypoint delaySec API: WoweeTaxiLoader::save / load / exists + WoweeTaxi::findNode / findPath / findPathBetween. Three preset emitters showcase different graph shapes: • makeStarter — 2 nodes + 2 paths (round-trip) • makeRegion — 4 nodes at a 500m square + 4-path directed ring (NW->NE->SE->SW->NW) • makeContinent — 6 nodes hub-spoke + 3 perimeter shortcuts; intermediate waypoints climb to altitude 120m for visual arc effect CLI added (5 flags, 564 documented total now): --gen-taxi / --gen-taxi-region / --gen-taxi-continent --info-wtax / --validate-wtax Validator catches: nodeId/pathId=0 + duplicates, empty node name, non-finite positions, fromNodeId == toNodeId (self-loop path), path references to non-existent nodes (intra-format cross-reference resolution), negative waypoint delays.
2026-05-09 16:26:27 -07:00
"--gen-taxi", "--gen-taxi-region", "--gen-taxi-continent",
"--info-wtax", "--validate-wtax",
feat(editor): add WTAX JSON round-trip authoring workflow Closes the WTAX open-format loop with --export-wtax-json / --import-wtax-json, mirroring the JSON pairs added for every other novel binary format. All 18 binary formats added since WOL now have full JSON round-trip authoring. Two top-level arrays mirror the binary layout: • nodes[] — nodeId / mapId / name / iconPath / position[3] / factionAlliance + factionHorde restrictions • paths[] — pathId / fromNodeId / toNodeId / moneyCostCopper / waypoints[] each with position[3] + delaySec Vec3 fields become 3-element JSON arrays for natural hand-edit. The intra-format graph (paths reference nodeIds) round-trips exactly so the catalog's connectivity is preserved. Verified byte-identical round-trip on the continent preset (6 nodes + 8 paths covering hub-and-spoke + 3 perimeter shortcuts, 16 total waypoints). Adds 2 flags (573 documented total now).
2026-05-09 16:35:01 -07:00
"--export-wtax-json", "--import-wtax-json",
feat(pipeline): add WTAL (Wowee Talent catalog) format Novel open replacement for Blizzard's TalentTab.dbc + Talent.dbc + the AzerothCore-style talent_progression SQL tables. The 25th open format added to the editor. Defines class talent specialization trees: per-class set of named tabs (Arms / Fury / Protection for warrior, Fire / Frost / Arcane for mage), each with talents arranged in a row/column grid, each talent having up to 5 ranks and an optional prerequisite chain. Cross-references with previously-added formats: WTAL.talent.prereqTalentId -> WTAL.talent.talentId (intra-format chain) WTAL.talent.rankSpellIds[] -> WSPL.entry.spellId (spell granted at each rank) Format: • magic "WTAL", version 1, little-endian • per tree: treeId / name / iconPath / requiredClassMask / talents[] (row, col, maxRank, prereqTalentId+rank, rankSpellIds[5] zero-padded for unused ranks) Enums: • ClassMask: bit positions match canonical CharClasses.dbc classIds — Warrior / Paladin / Hunter / Rogue / Priest / DK / Shaman / Mage / Warlock / Druid API: WoweeTalentLoader::save / load / exists + WoweeTalent::findTree / findTalent (global lookup across all trees in the catalog). Three preset emitters showcase tree shapes: • makeStarter — 1 small tree (3-talent vertical chain) • makeWarrior — 3 trees (Arms 4 / Fury 4 / Protection 3) with WSPL cross-refs at capstones (Mortal Strike -> WSPL 12294, Battle Shout -> WSPL 6673, Thunder Clap -> WSPL 6343) • makeMage — 3 trees (Arcane / Fire / Frost) with capstones referencing Frostbolt 116 / Fireball 133 / Blink 1953 from WSPL CLI added (5 flags, 571 documented total now): --gen-talents / --gen-talents-warrior / --gen-talents-mage --info-wtal / --validate-wtal Validator catches: tree+talent ids=0 or duplicates, empty tree name, requiredClassMask=0 (every class would see this tree — usually a typo), maxRank not in 1..5, talent listing itself as prerequisite, prereqTalentId pointing at a talent that doesn't exist in this catalog (intra-format cross-reference resolution), prereqRank=0 or > the prereq talent's maxRank (catches off-by-one references), gaps in rankSpellIds progression (rank N has spell but rank N-1 doesn't — usually a typo). The validator caught a real authoring bug in the makeMage / makeWarrior presets during smoke testing — initial check was comparing prereqRank against the WRONG talent's maxRank (this talent's rather than the prereq's). Fixed in the same commit by hoisting the check into the cross-reference resolution pass where the prereq talent is in hand.
2026-05-09 16:33:45 -07:00
"--gen-talents", "--gen-talents-warrior", "--gen-talents-mage",
"--info-wtal", "--validate-wtal",
feat(editor): add WTAL JSON round-trip authoring workflow Closes the WTAL open-format loop with --export-wtal-json / --import-wtal-json, mirroring the JSON pairs added for every other novel binary format. All 19 binary formats added since WOL now have full JSON round-trip authoring. Each tree round-trips: • treeId, name, iconPath, requiredClassMask • talents[] with talentId / row / col / maxRank / prereqTalentId+Rank / rankSpellIds[5] (always emitted as a 5-element array, zero-padded for unused ranks) The fixed-size rankSpellIds array round-trips exactly even when most slots are zero — preserves binary layout parity for downstream consumers expecting fixed-stride talent records. Verified byte-identical round-trip on the warrior preset (3 trees, 11 talents with prereq chains and capstone WSPL spell references intact). Adds 2 flags (580 documented total now).
2026-05-09 16:41:37 -07:00
"--export-wtal-json", "--import-wtal-json",
feat(pipeline): add WMS (Wowee Map / Area) catalog format Novel open replacement for Blizzard's Map.dbc + AreaTable.dbc + the AzerothCore-style world_zone SQL tables. The 26th open format added to the editor. Defines two related kinds of locator in one catalog: • Maps — top-level worlds (continents / instances / raids / battlegrounds / arenas) with a friendly name, type, expansion tag, and player-count cap. • Areas — sub-zones within maps with friendly names, parent- area chain, recommended level range, faction- territory marker (alliance / horde / contested / both), exploration XP, and an ambient-sound cross-reference into WSND. The runtime uses Areas for minimap labels, location strings under the player frame, "Discover Sub-zone" XP gains, and ambient-music selection on zone entry. Cross-references with previously-added formats: WMS.area.ambienceSoundId -> WSND.entry.soundId WMS.area.parentAreaId -> WMS.area.areaId (intra-format sub-zone hierarchy) WSPN entries are tied to WMS.area boundaries by world position (no direct ID — the runtime resolves position -> area at lookup time) Format: • magic "WMSX", version 1, little-endian • maps[] (each): mapId / name / shortName / mapType / expansionId / maxPlayers • areas[] (each): areaId / mapId / parentAreaId / name / minLevel..maxLevel / factionGroup / explorationXP / ambienceSoundId Enums: • MapType (5): Continent / Instance / Raid / Battleground / Arena • ExpansionId (5): Classic / Tbc / Wotlk / Cata / Mop • FactionGroup: Both / Alliance / Horde / Contested (PvP-flagging zone) API: WoweeMapsLoader::save / load / exists + WoweeMaps::findMap / findArea. Three preset emitters showcase the catalog shape: • makeStarter — 1 continent + 3 areas with parent chain (Goldshire is a sub-zone of Elwynn Forest) • makeClassic — 2 continents + Deadmines instance + 6 areas (Stormwind/Elwynn/Goldshire/Westfall/ Duskwood/Teldrassil/Deadmines) with WSND ambient-sound refs • makeBgArena — Alterac Valley (40-player BG) + Nagrand Arena (5v5 with maxPlayers=10) CLI added (5 flags, 578 documented total now): --gen-maps / --gen-maps-classic / --gen-maps-bgarena --info-wms / --validate-wms Validator catches: empty map name, unknown mapType / expansion, BG/Arena with maxPlayers=0 (no participant cap), area ids=0 + duplicates, empty area name, maxLevel < minLevel, areas referencing non-existent maps, parentAreaId chains crossing maps (sub-zones must be on the same world), self-parent.
2026-05-09 16:40:00 -07:00
"--gen-maps", "--gen-maps-classic", "--gen-maps-bgarena",
"--info-wms", "--validate-wms",
feat(editor): add WMS JSON round-trip authoring workflow Closes the WMS open-format loop with --export-wms-json / --import-wms-json, mirroring the JSON pairs added for every other novel binary format. All 20 binary formats added since WOL now have full JSON round-trip authoring. Two top-level arrays mirror the binary layout: • maps[] — mapId / name / shortName / mapType (dual int + name) / expansionId (dual int + name) / maxPlayers • areas[] — areaId / mapId / parentAreaId / name / minLevel..maxLevel / factionGroup (dual int + name) / explorationXP / ambienceSoundId Three enum-typed fields (mapType, expansionId, factionGroup) emit dual int + name forms — a hand-author can write "continent" / "wotlk" / "alliance" instead of remembering the integer values. Verified byte-identical round-trip on the classic preset (3 maps including Deadmines instance, 6 areas with full parent-chain hierarchy + WSND ambient cross-refs preserved). Adds 2 flags (587 documented total now).
2026-05-09 16:48:34 -07:00
"--export-wms-json", "--import-wms-json",
feat(pipeline): add WCHC (Wowee Character Classes/Races) format Novel open replacement for Blizzard's CharClasses.dbc + CharRaces.dbc + CharStartOutfit.dbc trio. The 27th open format added to the editor — completes the foundational character-creation surface. One file holds three flat arrays: • classes — playable classes (Warrior / Mage / etc.) with power type (mana/rage/focus/energy/runic), base HP+power scaling, faction availability • races — playable races with faction (Alliance/Horde/ Neutral), starting map+zone, default language spell, base stats, racial mount spell • outfits — starting gear loadout per (class, race, gender) triple, listing item IDs and display slots Cross-references with previously-added formats: WCHC.race.startingMapId -> WMS.map.mapId WCHC.race.startingZoneAreaId -> WMS.area.areaId WCHC.race.defaultLanguageSpellId -> WSPL.entry.spellId WCHC.race.mountSpellId -> WSPL.entry.spellId WCHC.outfit.items.itemId -> WIT.entry.itemId The starter preset's outfits use real WIT itemIds (1=Worn Shortsword, 2=Linen Vest, 3=Healing Potion) so the demo content stack is consistent: a freshly created Human Warrior in WCHC starts with WIT items 1/2/3, drops them on death into a WLOT-tracked corpse loot, and can be respawned via WSPN, etc. Format: • magic "WCHC", version 1, little-endian • classes[]: classId / name / icon / powerType / display / baseHP+perLevel / basePower+perLevel / factionAvailability • races[]: raceId / name / icon / factionId / male+female displayId / 5 base stats / startingMap+zone / defaultLanguage+mount spell IDs • outfits[]: classId+raceId+gender + items[] (each: itemId + displaySlot) Enums: • PowerType (6): Mana / Rage / Focus / Energy / RunicPower / Runes • RaceFaction (3): Alliance / Horde / Neutral • Gender: Male / Female • FactionAvailability bitmask: AvailableAlliance, AvailableHorde API: WoweeCharsLoader::save / load / exists + WoweeChars::findClass / findRace / findOutfit (by class+race+gender). CLI added (5 flags, 585 documented total now): --gen-chars / --gen-chars-alliance / --gen-chars-allraces --info-wchc / --validate-wchc Validator catches: ids unique, baseHealth=0 (instant-death character), factionAvailability=0 (no faction can pick), empty names, factionId out of range, outfit references to non-existent class/race ids (cross-format resolution), gender > 1, outfit items with itemId=0, outfit with no items (warning — naked character).
2026-05-09 16:47:04 -07:00
"--gen-chars", "--gen-chars-alliance", "--gen-chars-allraces",
"--info-wchc", "--validate-wchc",
feat(editor): add WCHC JSON round-trip authoring workflow Closes the WCHC open-format loop with --export-wchc-json / --import-wchc-json, mirroring the JSON pairs added for every other novel binary format. All 21 binary formats added since WOL now have full JSON round-trip authoring. Three top-level arrays mirror the binary layout: • classes[] — id / name / icon / powerType (dual int + name) / displayPower / baseHP+power scaling / factionAvailability bitmask • races[] — id / name / icon / factionId (dual int + name) / male+female displayId / 5 base stats / starting map+zone / language+mount spell IDs • outfits[] — classId+raceId+gender (dual int + name) + items array (each: itemId + displaySlot) Verified byte-identical round-trip on the starter preset (2 classes / 2 races / 4 outfits with full WIT itemId cross-references preserved through the JSON layer). Adds 2 flags (594 documented total now).
2026-05-09 16:55:31 -07:00
"--export-wchc-json", "--import-wchc-json",
feat(pipeline): add WTKN (Wowee Token catalog) format Novel open replacement for Blizzard's Currency.dbc + CurrencyCategory.dbc + CurrencyTypes.dbc + the AzerothCore- style player_currency SQL tables. The 28th open format added to the editor. Defines secondary currency tokens beyond gold: Honor Points (PvP), Arena Points (rated PvP), Marks of Honor (per battleground), faction reputation tokens, holiday-event currencies. Each token has a balance cap, optional weekly cap (regenerating earnings limit), and a category for grouping in the player's currency tab. Cross-references: WTRN.item.extendedCost -> WTKN.entry.tokenId (vendors can charge in tokens instead of copper — when extendedCost > 0 the runtime looks up the matching token) Format: • magic "WTKN", version 1, little-endian • per token: tokenId / name / description / iconPath / category / maxBalance / weeklyCap / flags Enums: • Category (6): Misc / Pvp / Reputation / Crafting / Seasonal / Holiday • Flags: AccountWide / Tradeable / HiddenUntilEarned / ResetsOnLogout / ConvertsToGold API: WoweeTokenLoader::save / load / exists / findById. Three preset emitters showcase typical token shapes: • makeStarter — 3 tokens (Honor / Marks / Stormwind Guard rep) covering Pvp + Reputation categories • makePvp — full PvP set: Honor (75k) + Arena (5k + weekly 1500) + 6 BG marks of honor for classic + TBC + WotLK battlegrounds • makeSeasonal — 4 holiday tokens (Tricky Treats / Brewfest / Coin of Ancestry / Stranger's Gift) all flagged ResetsOnLogout to make them event-bound CLI added (5 flags, 592 documented total now): --gen-tokens / --gen-tokens-pvp / --gen-tokens-seasonal --info-wtkn / --validate-wtkn Validator catches: tokenId=0 + duplicates, empty name, unknown category, weeklyCap > maxBalance (cap unreachable), ResetsOnLogout + AccountWide combo (incoherent — account state survives logout by definition).
2026-05-09 16:53:11 -07:00
"--gen-tokens", "--gen-tokens-pvp", "--gen-tokens-seasonal",
"--info-wtkn", "--validate-wtkn",
feat(editor): add WTKN JSON round-trip authoring workflow Closes the WTKN open-format loop with --export-wtkn-json / --import-wtkn-json, mirroring the JSON pairs added for every other novel binary format. All 22 binary formats added since WOL now have full JSON round-trip authoring. Each token round-trips all 8 scalar fields (tokenId, name, description, iconPath, category, maxBalance, weeklyCap, flags). Two enum-typed fields (category and flags) emit dual int + name forms. The flag bitset emits string-array form so a hand-author can write ["hidden", "resets"] instead of having to remember that HiddenUntilEarned|ResetsOnLogout = 0xC. Verified byte-identical round-trip on the PvP preset (8 tokens: Honor + Arena + 6 BG marks of honor with maxBalance + weeklyCap + flags all preserved). Adds 2 flags (596 documented total now).
2026-05-09 16:56:55 -07:00
"--export-wtkn-json", "--import-wtkn-json",
feat(pipeline): add WTRG (Wowee Area Trigger) format Novel open replacement for Blizzard's AreaTrigger.dbc + AreaTriggerTeleport.dbc + the AzerothCore-style areatrigger_template / areatrigger_teleport SQL tables. The 29th open format added to the editor. Defines proximity-based event zones — when a player enters a defined region (box or sphere), the runtime fires the trigger's action: teleport to another map, award exploration XP for a quest, run a server script, gate an instance entrance behind a key item, mark a PvP boundary, or simply display a "Discovered: {area name}" banner. Cross-references with previously-added formats — every trigger field has a real format target: WTRG.entry.mapId / areaId -> WMS.map.mapId / WMS.area.areaId WTRG.actionTarget (Teleport) -> WMS.mapId WTRG.actionTarget (QuestExploration) -> WQT.questId WTRG.requiredQuestId -> WQT.entry.questId WTRG.requiredItemId -> WIT.entry.itemId (key) Format: • magic "WTRG", version 1, little-endian • per trigger: triggerId / mapId / areaId / name / center vec3 / shape / kind / boxDims vec3 / radius / actionTarget / dest vec3 / destOrientation / requiredQuestId / requiredItemId / minLevel Enums: • Shape (2): Box / Sphere • Kind (7): Teleport / QuestExploration / Script / InstanceEntrance / AreaName / CombatStartZone / Waypoint API: WoweeTriggerLoader::save / load / exists / findById. Three preset emitters showcase common trigger shapes: • makeStarter — area-name + quest-exploration with cross-ref to WQT 100 ("Investigate the Camp") • makeDungeon — outdoor area-name + portal-style InstanceEntrance with Deadmines key gate (WIT itemId 5200, matches WLCK.makeDungeon's Boss Vault Seal) + interior exit teleport back outdoors • makeFlightPath — 2 sphere waypoints near flight masters so the runtime can auto-open the flight UI on proximity (matches WTAX starter node positions) CLI added (5 flags, 601 documented total now): --gen-triggers / --gen-triggers-dungeon / --gen-triggers-flightpath --info-wtrg / --validate-wtrg Validator catches: triggerId=0 + duplicates, unknown shape / kind, non-finite center, sphere with radius<=0, box with all-zero half-extents, teleport / instance with dest=(0,0,0) (silently does nothing — usually a typo), QuestExploration without an actionTarget questId.
2026-05-09 17:01:43 -07:00
"--gen-triggers", "--gen-triggers-dungeon", "--gen-triggers-flightpath",
"--info-wtrg", "--validate-wtrg",
feat(editor): add WTRG JSON round-trip authoring workflow Closes the WTRG open-format loop with --export-wtrg-json / --import-wtrg-json, mirroring the JSON pairs added for every other novel binary format. All 23 binary formats added since WOL now have full JSON round-trip authoring. Each trigger round-trips: • triggerId / mapId / areaId / name / minLevel • center / boxDims / dest as 3-element JSON arrays • shape (dual int + name) / kind (dual int + name) • radius / actionTarget / destOrientation • requiredQuestId / requiredItemId Verified byte-identical round-trip on the dungeon preset (3 triggers including the box-shaped Deadmines portal with WIT key gate (itemId=5200) and full destination + facing preserved through the JSON layer). Adds 2 flags (603 documented total now).
2026-05-09 17:03:27 -07:00
"--export-wtrg-json", "--import-wtrg-json",
feat(pipeline): add WTIT (Wowee Title catalog) format Novel open replacement for Blizzard's CharTitles.dbc + the AzerothCore-style character_title SQL table. The 30th open format added to the editor. Defines the player-display titles awarded for completing achievements ("the Versatile"), reaching PvP ranks ("Sergeant Major" / "Stone Guard"), participating in raids ("Champion of the Naaru"), levelling a profession ("Master Locksmith"), or seasonal events ("Brewmaster", "the Hallowed"). Closes a long-standing gap: WACH.entry.titleReward has been a free-form string since batch 116 with no formal catalog to resolve against. WTIT systematizes those strings into a real catalog — the runtime resolves WACH.titleReward to a WTIT entry by name, then displays the titleId in the player title selector. Cross-references: WACH.entry.titleReward (string) ~= WTIT.entry.name (string match — runtime resolves achievement- granted titles by looking up matching WTIT entry by name) Format: • magic "WTIT", version 1, little-endian • per title: titleId / name / nameMale / nameFemale / iconPath / prefix (suffix vs prefix display) / category / sortOrder Enums: • Category (8): Achievement / Pvp / Raid / ClassTitle / Event / Profession / Lore / Custom API: WoweeTitleLoader::save / load / exists + WoweeTitle::findById / findByName. Three preset emitters showcase typical title catalogs: • makeStarter — 4 titles (Versatile / Sergeant / Champion / Hallowed) covering 4 categories • makePvp — 28-title classic Honor System ladder (14 Alliance ranks Private->Grand Marshal + 14 Horde ranks Scout->High Warlord) • makeAchievement — 8 achievement titles including "the Versatile" matching WACH.makeMeta's achievement 250 titleReward + capstone profession titles CLI added (5 flags, 608 documented total now): --gen-titles / --gen-titles-pvp / --gen-titles-achievement --info-wtit / --validate-wtit Validator catches: titleId=0 + duplicates, empty name, unknown category, gender variants set on only one side (causes mixed-gender display when the runtime falls back to canonical for the unset side).
2026-05-09 17:07:56 -07:00
"--gen-titles", "--gen-titles-pvp", "--gen-titles-achievement",
"--info-wtit", "--validate-wtit",
feat(editor): add WTIT JSON round-trip authoring workflow Closes the WTIT open-format loop with --export-wtit-json / --import-wtit-json, mirroring the JSON pairs added for every other novel binary format. All 24 binary formats added since WOL now have full JSON round-trip authoring. Each title round-trips all 8 scalar fields (titleId, name, nameMale, nameFemale, iconPath, prefix, category, sortOrder). Two enum-typed fields emit dual int + name forms: • category (achievement/pvp/raid/class/event/profession/...) • prefix (1=prefix vs 0=suffix display position) Verified byte-identical round-trip on the PvP preset (28-title Honor System ladder with full Alliance + Horde rank coverage preserved through the JSON layer). Adds 2 flags (616 documented total now).
2026-05-09 17:16:41 -07:00
"--export-wtit-json", "--import-wtit-json",
feat(pipeline): add WSEA (Wowee Seasonal Event) format Novel open replacement for Blizzard's GameEvents.dbc + the AzerothCore-style game_event / game_event_creature / game_event_gameobject SQL tables. The 31st open format added to the editor. Calendar-based content: holidays (Hallow's End, Winter's Veil), recurring promotional events (Children's Week, Lunar Festival, Brewfest), one-time anniversaries, and XP-bonus weekends. Each event has a start date, duration, optional recurrence (yearly / monthly / weekly), faction restriction, optional XP bonus, and a reward currency cross-reference into WTKN. Cross-references with previously-added formats: WSEA.entry.tokenIdReward -> WTKN.entry.tokenId (the seasonal currency the event hands out — Tricky Treats during Hallow's End, Brewfest Tokens during Brewfest, etc.) The yearly preset's tokenIdReward values (200/201/202/203) deliberately match WTKN.makeSeasonal's seasonal token ids so the demo content stack already wires together: WSEA yearly events grant WTKN tokens that vendors can charge in via WTRN.item.extendedCost. Format: • magic "WSEA", version 1, little-endian • per event: eventId / name / description / iconPath / announceMessage / startDate (Unix epoch seconds) / duration_seconds / recurrenceDays (0=one-shot, 365=yearly) / holidayKind / factionGroup / bonusXpPercent / tokenIdReward Enums: • HolidayKind (7): Combat / Collection / Racial / Anniversary / Fishing / Cosmetic / WorldEvent • FactionGroup (3): Both / Alliance / Horde API: WoweeEventLoader::save / load / exists / findById. Three preset emitters showcase typical event shapes: • makeStarter — 3 events covering Combat / Fishing / Anniversary kinds • makeYearly — 4 yearly holidays with full WTKN cross-refs (Hallow's End / Brewfest / Lunar Festival / Winter's Veil) • makeBonusWeekends — 3 monthly Fri-Sun bonus tiers (50% / 100% / 200% RAF-style) CLI added (5 flags, 614 documented total now): --gen-events / --gen-events-yearly / --gen-events-weekends --info-wsea / --validate-wsea Validator catches: eventId=0 + duplicates, empty name, unknown holidayKind / factionGroup, duration_seconds=0 (event never runs), duration > recurrence period (events would overlap themselves on next iteration), bonusXpPercent > 200 (very high — verify intentional).
2026-05-09 17:14:46 -07:00
"--gen-events", "--gen-events-yearly", "--gen-events-weekends",
"--info-wsea", "--validate-wsea",
feat(editor): add WSEA JSON round-trip authoring workflow Closes the WSEA open-format loop with --export-wsea-json / --import-wsea-json, mirroring the JSON pairs added for every other novel binary format. All 25 binary formats added since WOL now have full JSON round-trip authoring. Each event round-trips all 11 scalar fields. Two enum-typed fields emit dual int + name forms: • holidayKind (combat / collection / racial / anniversary / fishing / cosmetic / world-event) • factionGroup (both / alliance / horde) Verified byte-identical round-trip on the yearly preset (4 holidays — Hallow's End / Brewfest / Lunar Festival / Winter's Veil — with full WTKN tokenIdReward cross-refs preserved through the JSON layer). Adds 2 flags (623 documented total now).
2026-05-09 17:24:50 -07:00
"--export-wsea-json", "--import-wsea-json",
feat(pipeline): add WMOU (Wowee Mount catalog) format Novel open replacement for Blizzard's Mount.dbc + MountCapability.dbc + MountType.dbc + the mount-related subsets of Spell.dbc / Item.dbc. The 32nd open format added to the editor. Defines all summonable steeds: ground mounts, flying mounts, swimming mounts, racial mounts (Tauren Plainsrunner for druids), and class mounts (Warlock dreadsteed, Paladin charger). Each mount has a summon spell, optional teach item, riding skill prerequisite, speed bonus, and faction / race availability mask. Cross-references with previously-added formats: WMOU.entry.summonSpellId -> WSPL.entry.spellId WMOU.entry.itemIdToLearn -> WIT.entry.itemId WMOU.entry.requiredSkillId -> WSKL.entry.skillId (Riding skill ID 762) WCHC.race.mountSpellId ~= WMOU.entry.summonSpellId (loose match by spellId) Format: • magic "WMOU", version 1, little-endian • per mount: mountId / name / description / icon / displayId / summonSpellId / itemIdToLearn / requiredSkillId+Rank / speedPercent / mountKind / factionId / categoryId / raceMask Enums: • Kind (5): Ground / Flying / Swimming / Hybrid / Aquatic • Faction (3): Both / Alliance / Horde • Category (8): Common / Epic / Racial / Event / Achievement / Pvp / Quest / ClassMount API: WoweeMountLoader::save / load / exists / findById. Three preset emitters showcase typical mount catalogs: • makeStarter — 3 mounts (ground horse + epic flying gryphon + aquatic riding turtle) • makeRacial — 6 racial mounts (4 Alliance: Pinto / Ram / Frostsaber / Mechanostrider; 2 Horde: Dire Wolf / Skeletal Horse) with raceMask gating per WCHC race bit positions • makeFlying — 4 flying mounts spanning Common (60%) -> Epic (100%) -> Achievement (280%) -> Pvp (310%) speed tiers CLI added (5 flags, 621 documented total now): --gen-mounts / --gen-mounts-racial / --gen-mounts-flying --info-wmou / --validate-wmou Validator catches: mountId=0 + duplicates, empty name, summonSpellId=0 (mount cannot be cast), unknown enum values, speedPercent=0 (no speed bonus), flying mount with requiredSkillRank<150 (player can't fly), Racial category without raceMask (any race could use — usually a typo).
2026-05-09 17:23:00 -07:00
"--gen-mounts", "--gen-mounts-racial", "--gen-mounts-flying",
"--info-wmou", "--validate-wmou",
feat(editor): add WMOU JSON round-trip authoring workflow Closes the WMOU open-format loop with --export-wmou-json / --import-wmou-json, mirroring the JSON pairs added for every other novel binary format. All 26 binary formats added since WOL now have full JSON round-trip authoring. Each mount round-trips all 14 scalar fields. Three enum-typed fields emit dual int + name forms: • mountKind (ground / flying / swimming / hybrid / aquatic) • factionId (both / alliance / horde) • categoryId (common / epic / racial / event / achievement / pvp / quest / class) Verified byte-identical round-trip on the flying preset (4 mounts spanning common/epic/achievement/pvp tiers with full WSPL spell + WIT item + WSKL riding skill cross-refs preserved through the JSON layer). Adds 2 flags (630 documented total now).
2026-05-09 17:33:54 -07:00
"--export-wmou-json", "--import-wmou-json",
feat(pipeline): add WBGD (Wowee Battleground Definition) format Novel open replacement for Blizzard's BattlemasterList.dbc + PvpDifficulty.dbc + the AzerothCore-style battleground_template SQL tables. The 33rd open format added to the editor. Defines per-BG gameplay rules: player count brackets, score-to-win, time limit, objective type (annihilation / capture flag / control nodes / king of hill / resource race / carry object), per-team start positions, respawn timer, and the WTKN currency token awarded on win. Cross-references with previously-added formats: WBGD.entry.mapId -> WMS.map.mapId (where mapType=Battleground) WBGD.entry.markTokenId -> WTKN.entry.tokenId (Mark of Honor for that BG) The classic preset's markTokenId fields (102/103/104) deliberately match WTKN.makePvp's "Mark of Honor: Warsong Gulch / Arathi Basin / Alterac Valley" token ids — so the demo content stack already wires together: WBGD.scoreToWin reached → grant WTKN mark → which a vendor in WTRN can charge in via item.extendedCost. Format: • magic "WBGD", version 1, little-endian • per BG: battlegroundId / mapId / name / description / objectiveKind / min+maxPlayersPerSide / minLevel..maxLevel / scoreToWin / timeLimitSeconds / bracketSize / allianceStart vec3 + facing / hordeStart vec3 + facing / respawnTimeSeconds / markTokenId Enums: • ObjectiveKind (6): Annihilation / CaptureFlag / ControlNodes / KingOfHill / ResourceRace / CarryObject API: WoweeBattlegroundLoader::save / load / exists / findById. Three preset emitters showcase typical BG shapes: • makeStarter — 1 king-of-hill BG (10v10, 3-cap to win) • makeClassic — 3 classic BGs with authentic player counts, level brackets, scoring, and WTKN cross-refs (Warsong Gulch CTF / Arathi Basin nodes / Alterac Valley resource race) • makeArena — 3 arena formats (Nagrand 2v2 / Blade's Edge 3v3 / Lordaeron 5v5) — annihilation objective + no respawn + 25 min cap CLI added (5 flags, 628 documented total now): --gen-bg / --gen-bg-classic / --gen-bg-arena --info-wbgd / --validate-wbgd Validator catches: bgId=0 + duplicates, empty name, unknown objectiveKind, player count=0, min>max counts/levels, scoreToWin=0 (no win condition), non-annihilation BG with respawnTimeSeconds=0 (losing side cannot recover).
2026-05-09 17:30:59 -07:00
"--gen-bg", "--gen-bg-classic", "--gen-bg-arena",
"--info-wbgd", "--validate-wbgd",
feat(editor): add WBGD JSON round-trip authoring workflow Closes the WBGD open-format loop with --export-wbgd-json / --import-wbgd-json, mirroring the JSON pairs added for every other novel binary format. All 27 binary formats added since WOL now have full JSON round-trip authoring. Each battleground round-trips all scalar fields plus the allianceStart and hordeStart vec3 + facing pairs (positions become 3-element JSON arrays for natural hand-edit). The objectiveKind enum emits dual int + name forms. Verified byte-identical round-trip on the classic preset (3 BGs spanning CTF / control nodes / resource race objectives with full WMS map + WTKN markTokenId cross-refs preserved through the JSON layer). Adds 2 flags (637 documented total now).
2026-05-09 17:53:41 -07:00
"--export-wbgd-json", "--import-wbgd-json",
feat(pipeline): add WMAL (Wowee Mail Template) format Novel open replacement for AzerothCore-style mail_loot_template SQL + the in-game mail subset of the inventory + currency systems. The 34th open format added to the editor. Defines templated mail messages with currency + item attachments. Triggered by quest reward delivery (overflow when bag is full), auction house bid wins / sales, achievement reward attachments, GM correspondence, holiday event mailings (Brewfest samples, Hallow's End candy), and returned-mail-on-rejection. Cross-references with previously-added formats: WMAL.entry.senderNpcId -> WCRT.entry.creatureId WMAL.entry.attachments.itemId -> WIT.entry.itemId Format: • magic "WMAL", version 1, little-endian • per template: templateId / senderNpcId / subject / body / senderName / moneyCopperAttached / categoryId / cod / returnable / expiryDays / attachments[] (each: itemId + quantity) Enums: • Category (8): QuestReward / Auction / GmCorrespondence / AchievementReward / EventMailing / Raffle / ScriptDelivery / ReturnedMail API: WoweeMailLoader::save / load / exists / findById. Three preset emitters showcase typical mail templates: • makeStarter — 3 templates (quest overflow / auction won / GM gift) covering the 3 most common categories • makeHoliday — 4 holiday samples that cross-reference the WTKN seasonal token IDs (200=Tricky Treats, 201=Brewfest, 202=Coin of Ancestry, 203=Stranger's Gift) so the demo content stack ships a full holiday onboarding experience • makeAuction — 5-template auction-house family (outbid / won / sold / expired / cancelled) — runtime fills in actual bid amounts / sold items at send time CLI added (5 flags, 635 documented total now): --gen-mail / --gen-mail-holiday / --gen-mail-auction --info-wmal / --validate-wmal Validator catches: templateId=0 + duplicates, empty subject, neither senderNpcId nor senderName set (no displayable sender), unknown category, expiryDays=0 (mail expires immediately), cod=1 with no money attached (free COD), empty mail in categories where the runtime doesn't fill in content (skips Auction / GmCorrespondence / ReturnedMail where empty templates are intentional). Two bugs caught + fixed during smoke-test on the auction preset: • print formatting glued the `0` from senderNpcId after the senderName when no NPC was set (rendered as "Postmaster0" instead of "Postmaster") — fixed with an explicit if/else split • validator's "no money + no items" warning was too aggressive for the Auction category, where templates are intentionally informational and the runtime fills in the real values — added Auction + ReturnedMail to the skip list
2026-05-09 17:41:03 -07:00
"--gen-mail", "--gen-mail-holiday", "--gen-mail-auction",
"--info-wmal", "--validate-wmal",
feat(editor): add WMAL JSON round-trip authoring workflow Closes the WMAL open-format loop with --export-wmal-json / --import-wmal-json, mirroring the JSON pairs added for every other novel binary format. All 28 binary formats added since WOL now have full JSON round-trip authoring. Each template round-trips all 11 scalar fields plus the variable-length attachments array. categoryId emits dual int + name forms (quest / auction / gm / achievement / event / raffle / script / returned). Verified byte-identical round-trip on the holiday preset (4 templates with full WIT itemId attachments matching WTKN seasonal token IDs preserved through the JSON layer). Adds 2 flags (644 documented total now).
2026-05-09 18:04:03 -07:00
"--export-wmal-json", "--import-wmal-json",
feat(pipeline): add WGEM (Wowee Gem / Enchantment) format Novel open replacement for Blizzard's ItemEnchantment.dbc + GemProperties.dbc + SpellItemEnchantment.dbc. The 35th open format added to the editor. Defines two related kinds of item enhancement in one catalog: • Gems — socketable jewelry pieces with color (red / blue / yellow / meta) that fit into gear sockets, granting stats or triggering passive spells when socketed • Enchantments — persistent buffs applied to weapon / armor pieces, either by an enchanter spell or by an item proc (Mongoose, Crusader, Berserking) Cross-references with previously-added formats: WGEM.gem.itemIdToInsert -> WIT.entry.itemId WGEM.gem.spellId -> WSPL.entry.spellId WGEM.enchantment.spellId -> WSPL.entry.spellId Format: • magic "WGEM", version 1, little-endian • gems[]: gemId / itemIdToInsert / name / color / statType + statValue / requiredItemQuality / spellId • enchantments[]: enchantId / name / description / iconPath / enchantSlot / statType + statValue / spellId / durationSeconds / chargeCount Enums: • Color (8): Meta / Red / Yellow / Blue / Purple / Green / Orange / Prismatic • EnchantSlot (5): Permanent / Temporary / SocketColor / Ring / Cloak API: WoweeGemLoader::save / load / exists + WoweeGem::findGem / findEnchant. Three preset emitters showcase common shapes: • makeStarter — 3 gems (one per primary color) + 2 enchantments (proc + stat) • makeGemSet — 6-gem full color palette covering primary + secondary combinations • makeEnchants — 5 enchant variants spanning slots (Mongoose / Deadly Poison / stats ring / cloak / Berserking) CLI added (5 flags, 642 documented total now): --gen-gems / --gen-gems-set / --gen-gems-enchants --info-wgem / --validate-wgem Validator catches: ids=0 + duplicates, empty name, color / slot out of range, stat-only entries with statValue=0 (gem provides nothing), chargeCount > 0 on non-Temporary enchant slots (charges silently ignored at runtime). The validator caught a real preset issue on first run — the proc enchants (Mongoose / Deadly Poison / Berserking) had spellId=0 and statValue=0, providing nothing. Fixed by adding placeholder spellIds in the 28000-29000 range, with a comment noting they resolve to real WSPL proc spells when the spell catalog is extended.
2026-05-09 18:01:48 -07:00
"--gen-gems", "--gen-gems-set", "--gen-gems-enchants",
"--info-wgem", "--validate-wgem",
feat(editor): add WGEM JSON round-trip authoring workflow Closes the WGEM open-format loop with --export-wgem-json / --import-wgem-json, mirroring the JSON pairs added for every other novel binary format. All 29 binary formats added since WOL now have full JSON round-trip authoring. Two top-level arrays mirror the binary layout: • gems[] — gemId / itemIdToInsert / name / color (dual int + name) / statType+Value / requiredItemQuality / spellId • enchantments[] — enchantId / name / description / icon / enchantSlot (dual int + name) / statType+Value / spellId / duration / chargeCount Verified byte-identical round-trip on the enchants preset (5 enchantments including 3 proc-based with WSPL spellId cross-refs in the 28000-29000 placeholder range, plus ring/cloak slot variants with chargeCount preserved). Adds 2 flags (651 documented total now).
2026-05-09 18:12:33 -07:00
"--export-wgem-json", "--import-wgem-json",
feat(pipeline): add WGLD (Wowee Guild) catalog format Novel open replacement for AzerothCore-style guild + guild_member + guild_rank + guild_bank_tab + guild_perk SQL tables. The 36th open format added to the editor. Each guild entry holds the complete social-organization state: header (name, leader, faction, MOTD, info, creation date, level + experience, bank money, packed emblem), rank ladder with permissions bitmask + daily withdraw caps, member roster with rank + join date + public/officer notes, bank tabs with per-tab and per-rank deposit / withdraw / view permission masks, and purchased guild perks referencing WSPL spell IDs. Cross-references with previously-added formats: WGLD.entry.factionId ~ WCHC.race.factionId (guilds are faction-locked) WGLD.entry.perks.spellId -> WSPL.entry.spellId Format: • magic "WGLD", version 1, little-endian • per guild: header (12 scalar fields + 4 strings) + ranks[] + members[] + bankTabs[] + perks[] • per rank: rankIndex / name / permissionsMask / moneyPerDayCopper • per member: characterName / rankIndex / joinedDate / publicNote / officerNote • per bankTab: tabIndex / name / iconPath / deposit+withdraw+view permission masks • per perk: perkId / name / spellId / requiredGuildLevel Enums: • Faction (2): Alliance / Horde • RankPermissionFlags (14): GuildChat / OfficerChat / Invite / Remove / Promote / Demote / SetMotd / EditPublicNote / EditOfficerNote / ViewBank / Deposit / Withdraw / Disband / RepairFromBank API: WoweeGuildLoader::save / load / exists / findById + shared addDefaultRanks helper used by both starter and faction-pair presets. Three preset emitters: • makeStarter — 1 small guild, default 5-rank ladder (GM/Officer/Veteran/Member/Initiate), 3 members borrowing names from WCRT merchants for cross-format consistency • makeFull — 1 fleshed-out guild: 6 ranks (with Recruit added) + 8 members + 4 bank tabs (officer-only withdraw on tabs 3+4) + 3 perks referencing WSPL spell IDs (Heroic Strike / Battle Shout / Thunder Clap as placeholder perk procs) • makeFactionPair — 2 parallel guilds, one Alliance + one Horde, with identical rank structures CLI added (5 flags, 649 documented total now): --gen-guilds / --gen-guilds-full / --gen-guilds-pair --info-wgld / --validate-wgld Validator catches: guildId=0 + duplicates, empty name / leaderName, factionId out of range, no ranks (members can't exist without a rank ladder), member.rankIndex exceeding the highest defined rank (intra-format cross-reference resolution), duplicate bank tabIndices, perks with spellId=0 (perk does nothing).
2026-05-09 18:10:45 -07:00
"--gen-guilds", "--gen-guilds-full", "--gen-guilds-pair",
"--info-wgld", "--validate-wgld",
feat(editor): add WGLD JSON round-trip authoring workflow Closes the WGLD open-format loop with --export-wgld-json / --import-wgld-json, mirroring the JSON pairs added for every other novel binary format. All 30 binary formats added since WOL now have full JSON round-trip authoring. Each guild round-trips header scalars (12 fields) plus the 4 sub-arrays: • ranks[] — rank ladder with permissions + money cap • members[] — character roster with rank + notes • bankTabs[] — per-tab name + 3 permission masks • perks[] — purchased buffs with WSPL spell refs factionId emits dual int + name forms (alliance / horde). Verified byte-identical round-trip on the full preset (1 guild with 6 ranks + 8 members + 4 bank tabs + 3 perks; all permission masks and per-rank money caps preserved through the JSON layer). Adds 2 flags (658 documented total now).
2026-05-09 18:20:43 -07:00
"--export-wgld-json", "--import-wgld-json",
feat(pipeline): add WPCD (Wowee Player Condition) format Novel open replacement for Blizzard's PlayerCondition.dbc + the AzerothCore-style condition_template SQL tables. The 37th open format added to the editor. Defines reusable boolean conditions that other formats can reference for gating: "player has quest X completed", "player level >= N", "player class is mage", "player has item Y in inventory", "WSEA event Z is active". Conditions can be grouped and combined with AND/OR aggregators on a per-group basis: a quest-giver gossip option that says "show only to level 60 alliance mages who completed quest 1234" composes 4 conditions sharing the same groupId with AND aggregation. The runtime walks each group, applies the group's aggregator, and returns the boolean result to the caller. Cross-references with previously-added formats — the targetId field has a polymorphic interpretation by kind: WPCD.targetId (kind=QuestCompleted/Active) -> WQT.questId WPCD.targetId (kind=HasItem) -> WIT.itemId WPCD.targetId (kind=HasSpell) -> WSPL.spellId WPCD.targetId (kind=HasAchievement) -> WACH.achievementId WPCD.targetId (kind=AreaId) -> WMS.areaId WPCD.targetId (kind=EventActive) -> WSEA.eventId WPCD.targetId (kind=HasTitle) -> WTIT.titleId WPCD.targetId (kind=FactionRep) -> WFAC.factionId WPCD.targetId (kind=Class/Race) -> WCHC class/race id Future format extensions can reference WPCD.conditionId in their own gating fields — WTRG triggers gated by player state, WGSP options visible only when conditions are met, WMOU summon spells condition-gated by quest progress, etc. Format: • magic "WPCD", version 1, little-endian • per condition: conditionId / groupId (0 = standalone) / name / description / kind / aggregator / negated / targetId / minValue / maxValue Enums: • Kind (17): AlwaysTrue / AlwaysFalse / QuestCompleted / QuestActive / HasItem / HasSpell / MinLevel / MaxLevel / ClassMatch / RaceMatch / FactionRep / HasAchievement / TeamSize / GuildLevel / EventActive / AreaId / HasTitle • Aggregator (2): And / Or API: WoweeConditionLoader::save / load / exists / findById. Three preset emitters showcase typical usage: • makeStarter — 4 standalone conditions covering the most common kinds (quest-done / has-item / min-level / class) • makeGated — 5 conditions in 2 groups demonstrating AND-aggregation (alliance + mage + lvl 60) and OR-aggregation (did quest 1 OR quest 100) • makeEvent — 3 event-gated conditions cross-referencing WSEA event IDs (Hallow's End / Brewfest / Winter's Veil) CLI added (5 flags, 656 documented total now): --gen-conditions / --gen-conditions-gated / --gen-conditions-event --info-wpcd / --validate-wpcd Validator catches: conditionId=0 + duplicates, kind / aggregator out of range, kinds requiring targetId having target=0 (skips AlwaysTrue/False, MinLevel/MaxLevel, TeamSize, GuildLevel which use min/max instead), TeamSize with min > max.
2026-05-09 18:18:27 -07:00
"--gen-conditions", "--gen-conditions-gated", "--gen-conditions-event",
"--info-wpcd", "--validate-wpcd",
feat(editor): add WPCD JSON round-trip authoring workflow Closes the WPCD open-format loop with --export-wpcd-json / --import-wpcd-json, mirroring the JSON pairs added for every other novel binary format. All 31 binary formats added since WOL now have full JSON round-trip authoring. Each condition round-trips all 9 scalar fields. Two enum-typed fields emit dual int + name forms: • kind (true / false / quest-done / has-item / min-level / class / event / area / title / ...) • aggregator (and / or) Verified byte-identical round-trip on the gated preset (5 conditions in 2 groups demonstrating both AND and OR aggregation, with full polymorphic targetId / minValue / maxValue payload preserved through the JSON layer). Adds 2 flags (665 documented total now).
2026-05-09 18:28:47 -07:00
"--export-wpcd-json", "--import-wpcd-json",
feat(pipeline): add WPET (Wowee Pet System) catalog Novel open replacement for AzerothCore-style pet_template + pet_levelstats SQL + the pet-related subsets of CreatureFamily.dbc + SpellFamilyName.dbc. The 38th open format added to the editor. Defines two related kinds of player-controlled NPCs in one catalog: • Pet families — hunter pet families (Wolf / Cat / Bear / Boar / Raptor / Spider / etc.) with per-family ability sets, base stat multipliers, and diet preferences • Warlock minions — Imp / Voidwalker / Succubus / Felhunter / Felguard, each with their own summon spell, creature template, and ability list Cross-references with previously-added formats: WPET.family.familyId -> WCRT.entry.familyId (matches creature family) WPET.family.abilities.spellId -> WSPL.entry.spellId WPET.minion.summonSpellId -> WSPL.entry.spellId WPET.minion.creatureId -> WCRT.entry.creatureId (used for stat scaling) WPET.minion.abilities.spellId -> WSPL.entry.spellId The starter preset's familyIds (1=Wolf, 2=Cat) match WCRT::FamilyId enum values, so a hunter taming a wolf via WCRT links straight through to WPET ability sets. Format: • magic "WPET", version 1, little-endian • families[]: familyId / name / description / icon / petType / baseAttackSpeed / damageMultiplier / armorMultiplier / dietMask / abilities[] • minions[]: minionId / name / summonSpellId / creatureId / abilities[] (each: spellId / rank / autocastDefault) Enums: • PetType (3): Cunning / Ferocity / Tenacity (WotLK+ talent tree categorization) • DietFlags: Meat / Fish / Bread / Cheese / Fruit / Fungus API: WoweePetLoader::save / load / exists + WoweePet::findFamily / findMinion + dietMaskName helper that decodes a dietMask into a "meat+fish" string. Three preset emitters showcase typical pet catalogs: • makeStarter — 2 hunter families (Wolf + Cat) with full 3-ability sets + 1 warlock Imp • makeHunter — 8 classic hunter families covering all 3 petType categories with appropriate diet masks • makeWarlock — 5 warlock minions each with summon spell ID and creatureId pointing into WCRT CLI added (5 flags, 663 documented total now): --gen-pets / --gen-pets-hunter / --gen-pets-warlock --info-wpet / --validate-wpet Validator catches: ids=0 + duplicates, empty name, petType out of range, baseAttackSpeed<=0 (would divide by zero in DPS calc), dietMask=0 (pet cannot be fed for happiness), minion missing summonSpellId / creatureId.
2026-05-09 18:27:02 -07:00
"--gen-pets", "--gen-pets-hunter", "--gen-pets-warlock",
"--info-wpet", "--validate-wpet",
feat(editor): add WPET JSON round-trip authoring workflow Closes the WPET open-format loop with --export-wpet-json / --import-wpet-json, mirroring the JSON pairs added for every other novel binary format. All 32 binary formats added since WOL now have full JSON round-trip authoring. Two top-level arrays mirror the binary layout: • families[] — familyId / name / description / icon / petType (dual int + name) / baseAttackSpeed / damageMultiplier / armorMultiplier / dietMask + name / abilities[] • minions[] — minionId / name / summonSpellId / creatureId / abilities[] Verified byte-identical round-trip on the starter preset (2 hunter families with 3 abilities each + 1 warlock Imp with 2 abilities including autocast preferences preserved through the JSON layer). Adds 2 flags (672 documented total now).
2026-05-09 18:37:12 -07:00
"--export-wpet-json", "--import-wpet-json",
feat(pipeline): add WAUC (Wowee Auction House) catalog Novel open replacement for Blizzard's AuctionHouse.dbc + the AzerothCore-style auctionhouse / auctionhousebot SQL tables. The 39th open format added to the editor. Defines per-house rules for the auction system: faction access, deposit rate (basis points of buyout price), house cut on successful sale, three listing duration tiers with per-tier deposit multipliers, disallowed item-class bitmask, and the auctioneer NPC. Cross-references with previously-added formats: WAUC.entry.auctioneerNpcId -> WCRT.entry.creatureId (Auctioneer-flagged NPC) WAUC.entry.disallowedClassMask bitmask of WIT.Class values that may not be auctioned at this house The faction-pair preset captures the canonical asymmetry: faction houses charge 5% on a successful sale while neutral houses charge 15% — the cross-faction tax that makes neutral AHs profitable for goblins. Format: • magic "WAUC", version 1, little-endian • per house: houseId / auctioneerNpcId / name / factionAccess / baseDepositRateBp / houseCutRateBp / maxBidCopper / 3 duration hours + 3 deposit multipliers / disallowedClassMask Enums: • FactionAccess (4): Alliance / Horde / Neutral / Both • Rates use basis points: 10000 = 100% API: WoweeAuctionLoader::save / load / exists / findById. Three preset emitters showcase typical auction setups: • makeStarter — 1 neutral house with default 12h / 24h / 48h tiers • makeFactionPair — 3 houses (Stormwind / Orgrimmar / Booty Bay) with auctioneer NPC IDs + canonical faction-vs-neutral cut rates • makeRestricted — 1 house disallowing Containers (1) + Quest items (12) + Keys (13) with tighter durations + 1000g bid cap CLI added (5 flags, 670 documented total now): --gen-auction / --gen-auction-pair / --gen-auction-restricted --info-wauc / --validate-wauc Validator catches: houseId=0 + duplicates, empty name, factionAccess out of range, duration tier=0, durations not in short<=medium<=long order, houseCutRateBp >= 100% (seller loses money on a sale), warns on >50% cut.
2026-05-09 18:34:54 -07:00
"--gen-auction", "--gen-auction-pair", "--gen-auction-restricted",
"--info-wauc", "--validate-wauc",
feat(editor): add WAUC JSON round-trip authoring workflow Closes the WAUC open-format loop with --export-wauc-json / --import-wauc-json, mirroring the JSON pairs added for every other novel binary format. All 33 binary formats added since WOL now have full JSON round-trip authoring. Each house round-trips all 14 scalar fields plus the factionAccess enum dual int + name forms (alliance / horde / neutral / both). Verified byte-identical round-trip on the faction-pair preset (3 houses including Stormwind/Orgrimmar/Booty Bay with different cut rates and auctioneer NPC IDs preserved through the JSON layer). Adds 2 flags (679 documented total now).
2026-05-09 18:45:01 -07:00
"--export-wauc-json", "--import-wauc-json",
feat(pipeline): add WCHN (Wowee Chat Channel) catalog Novel open replacement for Blizzard's ChatChannels.dbc + the AzerothCore-style chat_channel SQL tables. The 40th open format added to the editor. Defines the world chat channel system: General, Trade, LookingForGroup, GuildRecruitment, LocalDefense, plus per-zone area channels and custom user-created channels. Each channel has access rules (faction / level), join behavior (auto vs opt-in), broadcast policy (announce / moderated), and optional area / map gating that auto-joins or auto-leaves the channel as the player moves. Cross-references with previously-added formats: WCHN.entry.areaIdGate -> WMS.area.areaId (channel auto-attaches in this area) WCHN.entry.mapIdGate -> WMS.map.mapId (channel auto-attaches on this map) Format: • magic "WCHN", version 1, little-endian • per channel: channelId / name / description / channelType / factionAccess / autoJoin / announce / moderated / minLevel / areaIdGate / mapIdGate Enums: • ChannelType (10): AreaLocal / Zone / Continent / World / Trade / LookingForGroup / GuildRecruit / LocalDefense / Custom / Pvp • FactionAccess (3): Alliance / Horde / Both API: WoweeChannelLoader::save / load / exists / findById. Three preset emitters: • makeStarter — 4 stock channels (General Zone + Trade + LFG + GuildRecruit) with default autoJoin policies • makeCity — 5 city-specific channels (3 Stormwind + 2 Orgrimmar) with mapId / areaId gates so they auto-attach on entry • makeModerated — 3 moderated / restricted channels (LocalDefense level 10+, WorldDefense moderated, RaidCoordination level 60+) CLI added (5 flags, 677 documented total now): --gen-channels / --gen-channels-city / --gen-channels-moderated --info-wchn / --validate-wchn Validator catches: channelId=0 + duplicates, empty name, unknown channelType / factionAccess, world / continent channel with area or map gate (gate is silently ignored at runtime — usually a typo), minLevel=0 (no level gate at all).
2026-05-09 18:43:26 -07:00
"--gen-channels", "--gen-channels-city", "--gen-channels-moderated",
"--info-wchn", "--validate-wchn",
feat(editor): add WCHN JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the channels catalog format shipped last batch. --export-wchn-json emits all 10 scalar fields plus dual int + name forms for channelType and factionAccess so hand-edits can use either representation. --import-wchn-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / city / moderated).
2026-05-09 18:52:32 -07:00
"--export-wchn-json", "--import-wchn-json",
feat(pipeline): add WCMS (Wowee Cinematic) catalog 41st open format — replaces Movie.dbc / CinematicCamera.dbc / CinematicSequences.dbc plus the AzerothCore cinematic_camera SQL table. Defines pre-rendered videos, in-engine camera flythroughs, text crawls, and still images, each with a media path, duration, skippable flag, and a polymorphic trigger that fires on quest events / class first-login / zone entry / dungeon clear / achievements / level milestones. Cross-references with prior formats — triggerTargetId resolves by triggerKind to WQT.questId / WMS.areaId / WMS.mapId / WCHC.classId / WACH.achievementId, and soundtrackId points at WSND.soundId. CLI: --gen-cinematics (3-entry starter), --gen-cinematics-intros (4 class intros), --gen-cinematics-quests (3 quest-bound cinematics referencing demo questIds 1/100/102), --info-wcms, --validate-wcms with --json variants. Validator catches id=0/duplicates, empty name/mediaPath, kind/trigger out of range, missing target id for non-Manual/Login/LevelUp triggers, zero-duration entries, and non-skippable pre-rendered videos.
2026-05-09 18:50:43 -07:00
"--gen-cinematics", "--gen-cinematics-intros", "--gen-cinematics-quests",
"--info-wcms", "--validate-wcms",
feat(editor): add WCMS JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the cinematic catalog format shipped two batches ago. --export-wcms-json emits all 9 scalar fields plus dual int + name forms for kind and triggerKind so hand-edits can use either representation. --import-wcms-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / intros / quests).
2026-05-09 18:56:29 -07:00
"--export-wcms-json", "--import-wcms-json",
feat(pipeline): add WGLY (Wowee Glyph) catalog 42nd open format — replaces GlyphProperties.dbc + GlyphSlot.dbc plus the AzerothCore-style glyph_properties SQL table. Defines the WotLK glyph system: per-class inscribable glyphs that modify spell behavior. Each entry pairs a glyph item (the inscriber's craft output) with the spell aura that applies the modification, tagged with a Major / Minor / Prime slot type and a classMask of allowed classes. Cross-references with prior formats — spellId points at WSPL.spellId (the aura), itemId points at WIT.itemId (the inscribed item), and classMask bit positions match the WCHC classId enum (1=Warrior, 2=Paladin, 3=Hunter, etc). CLI: --gen-glyphs (3-entry per-role starter), --gen-glyphs-warrior (6-entry full warrior allotment), --gen-glyphs-universal (4 classMask=All utility glyphs), --info-wgly, --validate-wgly with --json variants. Validator catches id=0/duplicates, empty name, spellId=0 (glyph applies no aura), classMask=0 (no class can inscribe), itemId=0 warning, requiredLevel<25 warning (below WotLK glyph threshold), and glyphType out-of-range.
2026-05-09 18:55:22 -07:00
"--gen-glyphs", "--gen-glyphs-warrior", "--gen-glyphs-universal",
"--info-wgly", "--validate-wgly",
feat(editor): add WGLY JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the glyph catalog format shipped last batch. --export-wgly-json emits all 8 scalar fields plus a dual int + name form for glyphType so hand-edits can use either representation. --import-wgly-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / warrior / universal). 700 documented CLI flags.
2026-05-09 19:01:03 -07:00
"--export-wgly-json", "--import-wgly-json",
feat(pipeline): add WVHC (Wowee Vehicle) catalog 43rd open format — replaces Vehicle.dbc + VehicleSeat.dbc plus the AzerothCore-style vehicle_template SQL tables. Defines drivable vehicles: tanks, demolishers, motorcycles, gryphons, choppers, siege weapons, multi-passenger transports. Each entry pairs a creature template (the rendered model) with a fixed seat layout — driver / passenger / gunner seats with their own attachment points, control flags (kSeatDriver / kSeatGunner / kSeatPassenger / kSeatHidesPlayer / kSeatNoEjectByCC), and per-seat abilities mounted to the action bar. Cross-references with prior formats — creatureId points at WCRT.creatureId (the rendered model), flightCapabilityId points at WMNT.mountId for shared fly-speed tables, and per-seat controlSpellId / exitSpellId point at WSPL.spellId. CLI: --gen-vehicles (3-vehicle starter chopper/wind-rider/tank), --gen-vehicles-siege (3 siege weapons with control spellIds), --gen-vehicles-flying (3 flying mounts cross-ref WMNT flightCapabilityIds), --info-wvhc, --validate-wvhc with --json variants. Validator catches id=0/duplicates, missing creature, enum out-of-range, empty seat list, flying-vehicle on wrong movement (would fall through world), driver-flag exclusivity (0 or >1 drivers), and duplicate seatIndex within a vehicle.
2026-05-09 18:59:49 -07:00
"--gen-vehicles", "--gen-vehicles-siege", "--gen-vehicles-flying",
"--info-wvhc", "--validate-wvhc",
feat(editor): add WVHC JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the vehicle catalog format shipped last batch. --export-wvhc-json emits all 10 scalar fields plus a nested array of seats per entry, and dual int + name forms for vehicleKind / movementKind / powerType so hand-edits can use either representation. --import-wvhc-json accepts either form, falling back to the int when both are present, and reconstructs the seat array preserving seat flags / attachments / control-spell cross-refs. Verified byte-identical round-trip on all three preset emitters (starter / siege / flying), including nested seat data. 702 documented CLI flags.
2026-05-09 19:02:17 -07:00
"--export-wvhc-json", "--import-wvhc-json",
feat(pipeline): add WHOL (Wowee Holiday) catalog 44th open format — replaces Holidays.dbc + HolidayDescriptions.dbc + HolidayNames.dbc plus the AzerothCore-style game_event SQL tables. Defines time-gated world events: seasonal holidays (Hallow's End / Brewfest / Winter Veil), weekly call-to-arms BG bonuses, world-PvP windows (Wintergrasp), one-shot specials, and recurring daily / weekly resets. Each holiday has a recurrence rule (Annual / Monthly / WeeklyRecur / OneTime), a calendar window (startMonth + startDay + durationHours), and optional cross-refs to a feature creature, an intro quest, and a token / item reward issued during the window. Cross-references with prior formats — holidayQuestId points at WQT.questId, bossCreatureId points at WCRT.creatureId, itemRewardId points at WIT.itemId, and areaIdGate / mapIdGate point at WMS.areaId / WMS.mapId. CLI: --gen-holidays (3 seasonal starter), --gen-holidays-weekly (3 weekly BG call-to-arms windows), --gen-holidays-special (3 world-PvP / lunar / children events), --info-whol, --validate-whol with --json variants. Validator catches id=0/duplicates, kind / recurrence out of range, durationHours=0, invalid month/day for non-weekly recurrence, and calendar-only events (no quest + boss + reward) as a warning.
2026-05-09 19:05:33 -07:00
"--gen-holidays", "--gen-holidays-weekly", "--gen-holidays-special",
"--info-whol", "--validate-whol",
feat(editor): add WHOL JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the holiday catalog format shipped last batch. --export-whol-json emits all 13 scalar fields plus dual int + name forms for holidayKind and recurrence so hand-edits can use either representation. --import-whol-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / weekly / special). 709 documented CLI flags.
2026-05-09 19:07:08 -07:00
"--export-whol-json", "--import-whol-json",
feat(pipeline): add WLIQ (Wowee Liquid Type) catalog 45th open format — replaces LiquidType.dbc plus the AzerothCore-style terrain liquid descriptor data. Defines liquid materials used by terrain MCNK liquid layers, WMO interior pools, and procedurally generated fluid bodies in custom zones. Each liquid pairs a render material (shader + texture array + flow vectors + fog color) with gameplay data (damage spell, raw DPS, ambient + splash audio cross-refs). Cross-references with prior formats — ambientSoundId and splashSoundId point at WSND.soundId, damageSpellId points at WSPL.spellId. 10 liquid kinds (Water / Magma / Slime / OceanSalt / FelFire / HolyLight / TarOil / AcidBog / FrozenWater / UnderworldGoo) covering both natural and magical fluids. Per-liquid: viscosity (0=water, 1=slime), flow direction+speed (radians+units/sec), fog density+RGB, packed minimap RGBA color. CLI: --gen-liquids (3-entry classic Water/Lava/Slime starter), --gen-liquids-magical (4 magical pools incl. fel/holy/cosmic), --gen-liquids-hazardous (3 high-damage liquids with WSPL DoT cross-refs), --info-wliq, --validate-wliq with --json variants. Validator catches id=0/duplicates, missing shader/material, kind out of range, fog/viscosity outside 0..1, hazardous-kind- without-damage warning, and Water/OceanSalt-with-damage warning to flag accidental misconfiguration.
2026-05-09 19:10:03 -07:00
"--gen-liquids", "--gen-liquids-magical", "--gen-liquids-hazardous",
"--info-wliq", "--validate-wliq",
feat(editor): add WLIQ JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the liquid catalog format shipped this batch. --export-wliq-json emits all 14 scalar fields (incl. 3-byte fog RGB) plus a dual int + name form for liquidKind so hand-edits can use either representation. --import-wliq-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / magical / hazardous). 716 documented CLI flags.
2026-05-09 19:11:14 -07:00
"--export-wliq-json", "--import-wliq-json",
feat(editor): add --rename-by-magic extension recovery flag Reads the 4-byte magic of a file, looks it up in the shared format table, and renames the file to use the correct .w* extension. Useful when files have lost their extensions (downloaded as 'data.bin', extracted from a tarball with mangled metadata, or copied via a tool that strips suffixes). Safe by default — refuses to overwrite an existing target; pass --force to allow overwrite. --dry-run prints the planned move without touching the filesystem. Files that already have the correct extension are a no-op. Unrecognized magic exits 1 with the bytes printed for diagnostic context. Reuses cli_format_table.cpp so any future format addition is picked up automatically.
2026-05-09 19:29:18 -07:00
"--info-magic", "--summary-dir", "--rename-by-magic",
feat(editor): add --tree-summary-md content inventory generator Walks a directory recursively, identifies every Wowee open-format file by 4-byte magic, parses the standard catalog header, and emits a Markdown report. Useful for content-bundle distributions to ship with a README of what's inside, and for change-log generation when diffing two content snapshots manually. The report has three sections: a summary table (total files / recognized / bytes), a per-format breakdown (magic / ext / file count / total entries / description), and a per-file detail table (path / magic / version / catalog name / entries / bytes). Output to stdout if no out path is given, otherwise written to a file. Reuses cli_format_table.cpp so any new format added in the future appears automatically without touching this tool.
2026-05-09 20:16:27 -07:00
"--bulk-rename-by-magic", "--touch-tree", "--tree-summary-md",
feat(editor): add --audit-tree to flag corrupted/misnamed Wowee files Walks a directory recursively and groups problems by category: too-small (file under 16 bytes — can't hold a header), unknown-magic (.w* file whose magic is not in the format table), ext-mismatch (extension says one format but the magic says another — usually from a renamed file), magic-no-ext (file with recognized Wowee magic but no .w* extension), and header-trunc (magic matches but the rest of the header is truncated). Returns exit 1 if any issue is found, so it composes into shell pipelines and CI checks. JSON sidecar via --json. Catches the kinds of breakage that --summary-dir silently rolls into the "unrecognized" bucket — a renamed .wsrg file masquerading as .wsct shows up cleanly here but would otherwise be invisible. Like every cross-format utility this reuses cli_format_table.cpp, so new formats are audited automatically. CLI flag count 906 -> 907.
2026-05-09 21:45:54 -07:00
"--catalog-grep", "--diff-headers", "--audit-tree",
feat(editor): add --bulk-validate to run every format's validator across a tree Recursively walks a directory, peeks each file's 4-byte magic to identify the format, derives the per-format --validate-X flag from the format table's --info-X entry, and invokes that validator as a subprocess for each file. Reports total / passed / failed / skipped counts and lists the failure paths with their exit codes; returns exit 1 if any failure is found. For each failure it prints the exact follow-up command needed to reproduce the detailed error message, so the user doesn't have to remember which validator goes with which extension. Asset- style formats with no validator (.wom / .wob / .whm world geometry) are counted in the "skipped" bucket but don't fail the run. Composes with the existing audit/fix tooling: --audit-tree dir # find header-level breakage --magic-fix dir --apply # auto-fix ext/magic mismatches --bulk-validate dir # run every per-format validator # then re-run --validate-X on individual failures for detail This is the 12th cross-format utility — depth-checking that catches per-format semantic errors (duplicate ids, invalid enums, contradictory flag combos, dangling cross-refs) that --audit-tree's header-only scan can't see. CLI flag count 950 -> 951.
2026-05-09 22:19:09 -07:00
"--magic-fix", "--bulk-validate",
feat(editor): add --bulk-export-json + --bulk-import-json paired utilities Two new cross-format utilities for git-friendly catalog editing: --bulk-export-json <dir> recursively walks the tree, peeks each file's magic, and dispatches the per-format --export-X-json flag for every .w* it finds. Writes one .json sidecar per binary. --bulk-import-json <dir> inverse direction — recursively walks *.wXXX.json sidecars and dispatches the per-format --import-X-json flag to write back the byte-identical binary. Both report total / processed / failed / skipped counts and exit 1 on any failure. Asset-style formats with no per-format JSON exporter are counted in the "skipped" bucket. Use case — git-friendly diffs of binary catalogs: --bulk-export-json mydir # convert binaries to JSON git add mydir/*.json && git commit # version control as text git diff # see exact catalog changes --bulk-import-json mydir # restore binaries Verified end-to-end: 5 different format presets (WSRG, WCDF, WMAT, WTLE, WCTR) round-trip byte-identical through export -> JSON -> import. Reuses the same shellQuote / WEXITSTATUS scaffolding as --bulk-validate. CLI flag count 972 -> 974. This brings the cross-format utility count to 14: --list-formats / --info-magic / --summary-dir / --rename-by-magic --bulk-rename-by-magic / --touch-tree / --tree-summary-md --catalog-grep / --diff-headers / --audit-tree / --magic-fix --bulk-validate / --bulk-export-json / --bulk-import-json
2026-05-09 22:35:12 -07:00
"--bulk-export-json", "--bulk-import-json",
feat(editor): add --list-by-magic to filter a tree to one specific format Walks a directory recursively and lists every file matching a 4-character magic. Reports per-file size, entry count, catalog name, and relative path; aggregates total bytes + total entries across the matches. Useful for narrow per-format inventory: "show me all the WSPL spell catalogs in my project" or "find every WCDF that defines raid difficulty variants under my custom-content tree". The existing --summary-dir gives a multi-format rollup; this is the single-format zoom-in. Magic argument is case-insensitive — "WSPL" and "wspl" both match. If the magic is recognized in the format table the report header includes the format description and category; if not (e.g. a server-custom magic), the listing still works and just notes "unknown magic — no metadata". JSON sidecar via --json. Exit 1 if no matches (so it composes into shell "if any matches, do X" pipelines). This is the 17th cross-format utility: --list-formats / --info-magic / --summary-dir / --rename-by-magic --bulk-rename-by-magic / --touch-tree / --tree-summary-md --catalog-grep / --diff-headers / --audit-tree / --magic-fix --bulk-validate / --bulk-export-json / --bulk-import-json --diff-tree / --orphan-jsons / --list-by-magic CLI flag count 1032 -> 1033.
2026-05-09 23:18:46 -07:00
"--diff-tree", "--orphan-jsons", "--list-by-magic",
feat(editor): add --catalog-stats for single-file deep size analysis Reports header bytes (magic + version + nameLen + name + entryCount) vs entry-section bytes, average entry size, total file size, the catalog's name string length, and the first entry's id field. Useful for sizing analysis: "which catalogs are biggest, where do the bytes go, what's the per-entry overhead". Goes deeper than --info-magic which just reports the magic + version + name + count. The byte breakdown distinguishes: - headerBytes — fixed-cost header - catalogNameBytes — variable-length catalog label - entrySectionBytes — total size of all entries combined - averageEntryBytes — entrySectionBytes / entryCount Only the first entry's id is sampled because entries have variable-length name+description strings — multi-sampling produces garbage for most formats. The single sampled id is reliable because it sits at exactly headerBytes offset. JSON sidecar via --json. Format metadata (description / category) is included from the format table when the magic is recognized; unknown magics still get the size breakdown but no metadata. This is the 18th cross-format utility; the second per-file single-target one (alongside --info-magic). CLI flag count 1033 -> 1034.
2026-05-09 23:21:32 -07:00
"--catalog-stats",
feat(pipeline): add WANI (Wowee Animation) catalog 46th open format — replaces AnimationData.dbc plus the hard-coded animation-id tables in M2 model loaders. Defines named animations (Stand, Walk, Run, Cast, Death, MountIdle, Fly, ...) with fallback chains, behavior tier (default / mounted / sitting / aerial / swimming), and weapon-flag bitmasks that select the correct animation variant when the model wields 1H / 2H / dual / bow / rifle / wand / etc. Cross-references with prior formats — fallbackId resolves within the same WANI catalog (graceful degradation when the requested animation is absent: Run falls back to Walk, Attack2H falls back to Attack1H). 10 weapon-flag constants + 6 behavior flags (Looped, BlendableCycle, Interruptable, MovementSync, OneShot, PreserveAtEnd). 5 behavior tiers. CLI: --gen-animations (5 essentials), --gen-animations-combat (8 weapon-typed attacks + parry + channel), --gen-animations-movement (6 locomotion anims with tier transitions). Validator catches id-uniqueness, fallback-self-loop, looped-without-duration, mutually-exclusive Looped+OneShot flags, weaponFlags=0 warning, and unresolved fallback warnings. Also extends --list-formats and --info-magic with WANI.
2026-05-09 19:19:13 -07:00
"--gen-animations", "--gen-animations-combat", "--gen-animations-movement",
"--info-wani", "--validate-wani",
feat(editor): add WANI JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the animation catalog format shipped last batch. --export-wani-json emits all 8 scalar fields plus a dual int + name form for behaviorTier so hand-edits can use either representation. --import-wani-json accepts either form, falling back to the int when both are present, and defaults weaponFlags to kWeaponAny when omitted to preserve compatibility with hand-authored sidecars that forget to specify it. Verified byte-identical round-trip on all three preset emitters (starter / combat / movement). 724 documented CLI flags.
2026-05-09 19:20:22 -07:00
"--export-wani-json", "--import-wani-json",
feat(pipeline): add WSVK (Wowee Spell Visual Kit) catalog 47th open format — replaces SpellVisualKit.dbc + SpellVisualEffectName.dbc plus the AzerothCore-style spell visual SQL data. Defines per-spell visual presentations: cast-bar effect model, projectile model + travel speed + arc gravity, impact effect model, hand effect on the caster, and the animations + sounds that fire at cast / channel / impact time. Cross-references with prior formats — castAnimId / impactAnimId / precastAnimId point at WANI.animationId, castSoundId / impactSoundId point at WSND.soundId. Spell catalogs (WSPL) will reference visualKitId here to bind "what mechanically happens" to "what plays visually." CLI: --gen-svk (3-kit Frostbolt/Fireball/HealingTouch starter showing projectile + AoE + heal patterns), --gen-svk-combat (5 melee/ranged with WANI animation refs), --gen-svk-utility (4 portal/hearth/mount/resurrect with no projectile), --info-wsvk, --validate-wsvk with --json variants. Validator catches id=0/duplicates, missing name, negative speeds/radii, projectile-model + speed coherence (model without speed = never travels; speed without model = invisible), and a no-effect catch-all (no models + no anims + no sounds).
2026-05-09 19:23:36 -07:00
"--gen-svk", "--gen-svk-combat", "--gen-svk-utility",
"--info-wsvk", "--validate-wsvk",
feat(editor): add WSVK JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the spell visual kit catalog format shipped this batch. --export-wsvk-json emits all 12 scalar fields and 4 model-path strings. WSVK has no enum fields, so the JSON mapping is a straight-through dump with no name-form widening. --import-wsvk-json parses it back, defaulting unset fields to 0/empty. Verified byte-identical round-trip on all three preset emitters (starter / combat / utility). 731 documented CLI flags.
2026-05-09 19:24:37 -07:00
"--export-wsvk-json", "--import-wsvk-json",
feat(pipeline): add WWUI (Wowee World-State UI) catalog 48th open format — replaces WorldStateUI.dbc plus the AzerothCore-style world_state SQL data. Defines on-screen UI elements that surface server-side world-state variables: BG scoreboards (flag captures, base controls), Wintergrasp tank counters, Eye of the Storm flag-carrier indicator, dungeon boss progress, world-event collection trackers. Each entry binds a server-side variableIndex to a UI panel kind (counter / timer / flag-icon / progress-bar / two-sided score / custom) gated by mapId+areaId, with optional alwaysVisible and hideWhenZero flags and a chosen panel position (top / bottom / top-left / top-right / center). Cross-references with prior formats — mapId points at WMS.mapId and areaId points at WMS.areaId. CLI: --gen-wsui (3-entry BG scoreboard starter for WSG/AB/ EotS), --gen-wsui-wintergrasp (4-entry full Wintergrasp UI), --gen-wsui-dungeon (3-entry boss/keys/treasure hunt UI), --info-wwui, --validate-wwui with --json variants. Validator catches id=0/duplicates, kind/position out of range, variableIndex=0 warning, alwaysVisible+hideWhenZero conflict warning, and (mapId, variableIndex) collision warning when two entries would read the same server slot on the same map. Also extends --list-formats and --info-magic with WWUI.
2026-05-09 19:32:15 -07:00
"--gen-wsui", "--gen-wsui-wintergrasp", "--gen-wsui-dungeon",
"--info-wwui", "--validate-wwui",
feat(editor): add WWUI JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the world-state UI catalog format shipped last batch. --export-wwui-json emits all 11 scalar fields plus dual int + name forms for displayKind and panelPosition so hand-edits can use either representation. --import-wwui-json accepts either form, falling back to the int when both are present, and defaults iconColorRGBA to 0xFFFFFFFF (opaque white) when omitted. Verified byte-identical round-trip on all three preset emitters (starter / wintergrasp / dungeon). 740 documented CLI flags.
2026-05-09 19:33:37 -07:00
"--export-wwui-json", "--import-wwui-json",
feat(pipeline): add WPCN (Wowee Player Condition) catalog 49th open format — replaces PlayerCondition.dbc plus the AzerothCore-style condition resolver. Defines reusable boolean checks that other catalogs reference by conditionId to gate gossip options, vendor items, quest availability, achievement criteria, spell trainer offerings. 16 condition kinds (Always, Race, Class, Level, Zone, Map, Reputation, AchievementWon, QuestComplete, QuestActive, SpellKnown, ItemEquipped, Faction, InCombat, Mounted, Resting), 8 comparison ops (==, !=, >, >=, <, <=, in-set, not-in-set), and 4 chain ops (none, and, or, not) — chain multiple conditions via chainNextId to express arbitrary boolean trees. Cross-references with prior formats — targetIdA is polymorphic by conditionKind: resolves to WCHC raceId/classId, WMS areaId/mapId, WFAC factionId, WACH achievementId, WQT questId, WSPL spellId, or WIT itemId. chainNextId resolves within the same WPCN catalog. CLI: --gen-pcn (3 single-check starters), --gen-pcn-quest-gates (4 cross-format quest gates with real WQT/WFAC/WACH/WMS IDs), --gen-pcn-composite (3 leaves + 3 chained roots showing AND/ OR/NOT). Validator catches id=0/duplicates, kind/op out of range, chain self-loop (infinite recursion), chainOp set without chainNextId (dangling chain), chainNextId set without chainOp (dead pointer warning), and unresolved chainNextId references.
2026-05-09 19:36:56 -07:00
"--gen-pcn", "--gen-pcn-quest-gates", "--gen-pcn-composite",
"--info-wpcn", "--validate-wpcn",
feat(editor): add WPCN JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the player condition catalog format shipped this batch. --export-wpcn-json emits all 11 scalar fields plus dual int + name forms for conditionKind / comparisonOp / chainOp so hand-edits can use either representation. --import-wpcn-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / quest-gates / composite — including chained conditions referencing other entries by chainNextId). 747 documented CLI flags.
2026-05-09 19:38:06 -07:00
"--export-wpcn-json", "--import-wpcn-json",
feat(pipeline): add WTSK (Wowee Trade Skill / Recipe) catalog New open format — replaces SkillLineAbility.dbc plus the recipe portions of SkillLine.dbc plus the AzerothCore trade_skill SQL tables. Closes the crafting gap left by WSKL (which carries skill lines but not the recipes that bind to them). 14 professions (Blacksmithing, Tailoring, Engineering, Alchemy, Enchanting, Leatherworking, Jewelcrafting, Inscription, Mining, Skinning, Herbalism, Cooking, FirstAid, Fishing). Each recipe has 4 skill-up bracket thresholds (orange / yellow / green / gray) for skill-up probability, a craft spell cross-ref (WSPL), produced item cross-ref (WIT) with min/max quantity range, an optional tool item, and up to 4 reagent slots (itemId + count). Cross-references with prior formats — craftSpellId points at WSPL.spellId, producedItemId / toolItemId / reagent[].itemId all point at WIT.itemId, and skillId points at WSKL.skillId. CLI: --gen-tsk (3-recipe entry-tier starter), --gen-tsk- blacksmithing (5-recipe progression rough sharpening through truesilver champion), --gen-tsk-alchemy (5-recipe progression minor healing through flask of titans), --info-wtsk, --validate-wtsk with --json variants. Validator catches id=0/duplicates, profession out of range, missing craft spell or produced item, monotonic-bracket check (must be orange <= yellow <= green <= gray), reagent itemId-without-count mismatch, and free-recipe warning (no reagents and no tool). Format graph now exposes 49 distinct binary formats. CLI flag count: 747 → 752.
2026-05-09 19:41:49 -07:00
"--gen-tsk", "--gen-tsk-blacksmithing", "--gen-tsk-alchemy",
"--info-wtsk", "--validate-wtsk",
feat(editor): add WTSK JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the trade skill recipe catalog format shipped last batch. --export-wtsk-json emits all 14 scalar fields plus a dual int + name form for profession, plus a nested reagents[] array — only non-empty slots are emitted to keep hand-edits compact. --import-wtsk-json zeroes the reagent slots before parsing (so a 2-element reagents array correctly clears slots 2 and 3) and accepts profession by either int or name. Verified byte-identical round-trip on all three preset emitters (starter / blacksmithing / alchemy — including recipes with 3 reagent slots populated). 754 documented CLI flags.
2026-05-09 19:43:16 -07:00
"--export-wtsk-json", "--import-wtsk-json",
feat(pipeline): add WCEQ (Wowee Creature Equipment) — 50th open format Replaces the AzerothCore-style creature_equip_template SQL tables plus the visible-weapon / shield / ranged-slot data that was traditionally embedded in creature templates. Closes a long-standing gap in the creature subsystem: until now WCRT defined a creature's stats, WSPN placed it in the world, and WLOT defined what it drops — but nothing defined what items it visibly equips. Each entry binds a creatureId to up to three equipped items (main hand / off hand / ranged) plus the visual kit that fires when the main-hand weapon is brandished. equipFlags bits encode hidden / dual-wield / shield-offhand / thrown-ranged / 2H polearm to drive the renderer's attachment-point selection. Cross-references with prior formats — creatureId points at WCRT.creatureId, mainHandItemId / offHandItemId / rangedItemId all point at WIT.itemId, and mainHandVisualId points at WSVK.visualKitId so brandished weapons can play their signature glow / aura. CLI: --gen-ceq (3 generic guard/hunter/rogue starters), --gen-ceq-bosses (4 iconic loadouts incl. Frostmourne and Illidan's warglaives, with WSVK visual cross-refs), --gen-ceq-ranged (3 ranged-only rifle/bow/crossbow loadouts), --info-wceq, --validate-wceq with --json variants. Validator catches id=0/duplicates, missing creatureId, all-empty-slots warning, kFlagDualWield without both hand items, kFlagShield without offhand item, mutually-exclusive dual-wield + shield, and 2H polearm with offhand item filled. Format graph milestone: 50 distinct binary formats. CLI flag count: 754 → 760.
2026-05-09 19:48:13 -07:00
"--gen-ceq", "--gen-ceq-bosses", "--gen-ceq-ranged",
"--info-wceq", "--validate-wceq",
feat(editor): add WCEQ JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the creature equipment catalog format shipped last batch (50th open format). All fields are scalar — no enum widening — so the JSON mapping is a direct dump. Slot fields default to the canonical attachment-table values (mainhand=16, offhand=17, ranged=18) when omitted from a sidecar, so hand-edits don't need to spell out the slot numbers for typical loadouts. Verified byte-identical round-trip on all three preset emitters (starter / bosses / ranged). 762 documented CLI flags.
2026-05-09 19:50:20 -07:00
"--export-wceq-json", "--import-wceq-json",
feat(pipeline): add WSET (Wowee Item Set / Tier Bonus) catalog 51st open format — replaces ItemSet.dbc + ItemSetSpell.dbc plus the AzerothCore-style item_set_spell SQL data. Closes the tier-bonus gap left by WIT (which describes individual items but not the set bonuses they grant when worn together). Each entry binds up to 8 piece item IDs to up to 4 bonus thresholds — at N pieces worn, the matching bonus spell activates as an aura. Standard 2/4/6/8-piece tier set pattern is the canonical case; 5-piece PvP sets with 2/4 bonuses are also supported. Cross-references with prior formats — itemIds[] point at WIT.itemId, bonusSpellIds[] point at WSPL.spellId, and requiredSkillId points at WSKL.skillId. requiredClassMask is a 32-bit field (uint32_t) so bit positions match WCHC's classId enum directly — Druid (bit 11 = 0x800) and Mage (bit 8 = 0x100) wouldn't fit in a uint8_t. CLI: --gen-itset (2 raid sets — Battlegear of Wrath + Stormrage Raiment, real WoW item/spell IDs), --gen-itset-tier (4 tier-1 progression sets covering plate / cloth / leather / holy plate), --gen-itset-pvp (3 PvP gladiator 5-piece sets with honor-rank skill thresholds), --info-wset, --validate-wset with --json variants. Validator catches id+name+pieceCount required, pieceCount/bonusCount within array bounds, piece- slot drift (0 IDs within count or non-0 IDs past count), bonus thresholds strictly ascending, no bonus threshold exceeding pieceCount (would never trigger), and spellId=0 in any populated bonus slot. Format graph: 50 → 51 binary formats. CLI flag count: 762 → 767.
2026-05-09 19:54:36 -07:00
"--gen-itset", "--gen-itset-tier", "--gen-itset-pvp",
"--info-wset", "--validate-wset",
feat(editor): add WSET JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the item set catalog format shipped this batch. --export-wset-json emits all 8 scalar fields plus two nested arrays — itemIds[] (only the populated slots) and bonuses[{threshold, spellId}] (only the populated bonus pairs). --import-wset-json derives pieceCount and bonusCount from the array sizes (the explicit count fields in the binary header are recomputed on import) and clears any trailing slots so a 5-piece PvP set imported from JSON correctly leaves slots 5-7 zero. requiredClassMask is dumped as a raw uint32 — users hand-edit using WCHC bit positions (Druid=0x800, Mage=0x100, Paladin=0x04 etc). Verified byte-identical round-trip on all three preset emitters (starter / tier / PvP — including the 5-piece PvP variant with 2/4-piece bonuses). 769 documented CLI flags.
2026-05-09 19:55:50 -07:00
"--export-wset-json", "--import-wset-json",
feat(pipeline): add WGTP (Wowee Game Tips) catalog 52nd open format — replaces GameTips.dbc plus loading-screen tutorial hint tables. Defines the rotating tips shown during world loads, the contextual tutorial hints that fire on first gameplay events (first quest accept, first death, first dungeon entry), and the persistent tooltip-help strings that explain UI elements. 4 display kinds (LoadingScreen / Tutorial / TooltipHelp / Hint), 7 audience-filter bits (Alliance / Horde / NewPlayer / Hardcore / PvE / PvP / Roleplay) for pool selection, level range gating (minLevel + maxLevel), displayWeight for relative frequency within the pool, optional WPCN condition cross-ref for further gating, and class-mask restriction matching WCHC bit positions. Cross-references with prior formats — conditionId points at WPCN.conditionId for advanced gating; requiredClassMask uses the same WCHC.classId bit layout as WGLY/WSET. CLI: --gen-tips (3 generic loading-screen tips), --gen-tips- new-player (5 onboarding Tutorial-kind tips for level 1-15, weighted higher for new players), --gen-tips-advanced (4 endgame tips for level 70+ covering raid mechanics / arena / daily professions / dungeon finder), --info-wgtp, --validate-wgtp with --json variants. Validator catches id/name/text required, kind 0..3, audienceFilter=0 (tip never shown), invalid level range, displayWeight=0 (in pool but never picked) warning, and brevity check (>280 chars) on Tutorial / Hint kinds that need to fit on screen. Format graph: 51 → 52 binary formats. CLI flag count: 770 → 775.
2026-05-09 20:00:56 -07:00
"--gen-tips", "--gen-tips-new-player", "--gen-tips-advanced",
"--info-wgtp", "--validate-wgtp",
feat(editor): add WGTP JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the game tips catalog format shipped this batch. --export-wgtp-json emits all 11 scalar fields plus a dual int + name form for displayKind so hand-edits can use either representation. --import-wgtp-json defaults audienceFilter to kAudienceAll when omitted (so a sidecar without that field doesn't accidentally produce a tip that is never shown). Verified byte-identical round-trip on all three preset emitters (starter / new-player / advanced). 777 documented CLI flags.
2026-05-09 20:02:02 -07:00
"--export-wgtp-json", "--import-wgtp-json",
feat(pipeline): add WCMP (Wowee Companion Pet) catalog 53rd open format — replaces the companion-pet portions of CreatureFamily.dbc plus the AzerothCore-style critter / vanity- pet SQL data. Distinct from WPET (which covers hunter combat pets and warlock minions); WCMP covers non-combat "vanity" pets that follow the player around for cosmetic reasons — Mechanical Squirrel, Mini Diablo, Panda Cub, dragon hatchlings. 8 companion kinds (Critter, Mechanical, DragonHatchling, Demonic, Spectral, Elemental, Plush, UndeadCritter), 4 rarity tiers (Common / Uncommon / Rare / Epic), and 3 faction restrictions (AnyFaction / AllianceOnly / HordeOnly). Cross-references with prior formats — creatureId points at WCRT.creatureId (the rendered model), learnSpellId at WSPL.spellId (the spell that summons the pet), itemId at WIT.itemId (the item that teaches the spell), and idleSoundId at WSND.soundId (idle ambient noise). CLI: --gen-cmp (3 common vendor pets), --gen-cmp-rare (4 promo / collector pets at Epic rarity — Mini Diablo, Panda Cub, Zergling, Murky), --gen-cmp-faction (3 faction- restricted Alliance Lion Cub / Horde Mottled Boar / neutral Argent Squire), --info-wcmp, --validate-wcmp with --json variants. Validator catches id+name+creatureId+ learnSpellId required, kind 0..7 / rarity 0..3 / faction 0..2 range, and Epic-rarity-no-itemId warning (most promo pets need a redemption-code item). Format graph: 52 → 53 binary formats. CLI flag count: 777 → 782.
2026-05-09 20:05:06 -07:00
"--gen-cmp", "--gen-cmp-rare", "--gen-cmp-faction",
"--info-wcmp", "--validate-wcmp",
feat(editor): add WCMP JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the companion pet catalog format shipped last batch. --export-wcmp-json emits all 9 scalar fields plus dual int + name forms for companionKind (8 values) / rarity (4 values) / factionRestriction (3 values) so hand-edits can use either representation. --import-wcmp-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / rare / faction). 784 documented CLI flags.
2026-05-09 20:06:33 -07:00
"--export-wcmp-json", "--import-wcmp-json",
feat(pipeline): add WSMC (Wowee Spell Mechanic) catalog 54th open format — replaces SpellMechanic.dbc plus the AzerothCore-style diminishing-returns (DR) tables. Defines crowd-control mechanic categories that spells reference: Stun, Silence, Polymorph, Sleep, Fear, Root, Snare, Slow, Knockback, etc. Each mechanic carries gameplay metadata (breaks-on-damage, can-be-dispelled, default duration, max stacks) plus DR category and dispel type. 8 DR categories (DRNone / DRStun / DRDisorient / DRSilence / DRRoot / DRPolymorph / DRControlled / DRMisc) — the runtime uses these to gate repeated CC on the same target. 7 dispel types (DispelNone / Magic / Curse / Disease / Poison / Enrage / Stealth) bind which dispel spells can remove the mechanic. conflictsMask is a bitmask of OTHER mechanic IDs — only one mechanic from a conflict-group can apply to a target simultaneously. Cross-references with prior formats — mechanicId is referenced by WSPL.spellId entries that apply this CC; this catalog is referenced from spell tags rather than referencing out. CLI: --gen-smc (3 baseline Stun/Silence/Snare), --gen-smc- hard (5 hard-CC: Stun/Polymorph/Sleep/Fear/Knockback with conflictsMask wiring), --gen-smc-roots (4 movement-impair: Root/Snare/Slow stacking 5x/GroundPin breaks-on-damage), --info-wsmc, --validate-wsmc with --json variants. Validator catches id+name required, DR category 0..7, dispel type 0..6, maxStacks=0 (mechanic could never apply), canBeDispelled+DispelNone inconsistency, and self-conflict bit set in conflictsMask (mechanic blocking itself). Format graph: 53 → 54 binary formats. CLI flag count: 784 → 789.
2026-05-09 20:09:44 -07:00
"--gen-smc", "--gen-smc-hard", "--gen-smc-roots",
"--info-wsmc", "--validate-wsmc",
feat(editor): add WSMC JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the spell mechanic catalog format shipped this batch. --export-wsmc-json emits all 9 scalar fields plus dual int + name forms for drCategory (8 values) and dispelType (7 values). --import-wsmc-json accepts either form. conflictsMask is dumped/parsed as a raw uint32 since it's a free-form bitmask of OTHER mechanic IDs (no enum to widen). Verified byte-identical round-trip on all three preset emitters (starter / hard-CC with conflictsMask bits set / roots with stacking flag). 791 documented CLI flags.
2026-05-09 20:10:59 -07:00
"--export-wsmc-json", "--import-wsmc-json",
feat(pipeline): add WKBD (Wowee Keybinding) catalog 55th open format — replaces KeyBinding.dbc plus the AzerothCore-style default-keybind SQL data. Defines the key bindings shipped with the game: movement (W/A/S/D), targeting (Tab), action bars (1-9, 0, -, =), UI panels (C/I/B/P/N/L), chat (Enter), camera (Insert/Delete). Each binding has an internal action name (SCREAMING_SNAKE convention — "MOVE_FORWARD"), a primary key, an optional alternate key, a category for the keybindings UI grouping, and a flag indicating whether the user can override it. Hardcoded engine bindings (alt-F4, ESC) set isUserOverridable=0 so the rebind dialog can't accidentally break them. 9 categories (Movement / Combat / Targeting / Camera / UIPanels / Chat / Macro / Bar / Other) for the rebind dialog grouping. CLI: --gen-kbd (3 essential WASD/Tab/C bindings), --gen-kbd- movement (8 movement: WASD + arrow alternates + jump + autorun), --gen-kbd-ui (10 UI panel bindings covering all the standard interface windows), --info-wkbd, --validate-wkbd with --json variants. Validator catches id+actionName+ defaultKey required, category 0..8, alternateKey == defaultKey (no point in alt), action-name lowercase warning (should be SCREAMING_SNAKE), duplicate primary keys (would silently shadow earlier binding), and duplicate action names. Format graph: 54 → 55 binary formats. CLI flag count: 791 → 796.
2026-05-09 20:13:37 -07:00
"--gen-kbd", "--gen-kbd-movement", "--gen-kbd-ui",
"--info-wkbd", "--validate-wkbd",
feat(editor): add WKBD JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the keybinding catalog format shipped last batch. --export-wkbd-json emits all 7 scalar fields plus a dual int + name form for category (9 values) so hand-edits can use either representation. --import-wkbd-json defaults isUserOverridable to 1 when omitted (matches typical case for game-action bindings; hardcoded engine bindings must explicitly set it to 0). Verified byte-identical round-trip on all three preset emitters (starter / movement with primary+alt keys / UI panels). 798 documented CLI flags.
2026-05-09 20:15:02 -07:00
"--export-wkbd-json", "--import-wkbd-json",
feat(pipeline): add WSCH (Wowee Spell School) catalog 56th open format — replaces SpellSchools.dbc plus the Resistances.dbc resistance-cap tables. Defines damage schools spells use: Physical, Holy, Fire, Nature, Frost, Shadow, Arcane, plus combined / hybrid schools that count as multiple types simultaneously (Spellfire, Spellshadow, Spellfrost — relevant for resistance-bypass mechanics). 7 canonical schools with single-bit IDs (1, 2, 4, 8, 16, 32, 64) so combinedSchoolMask values line up directly with the spell engine's school-bit enum. Hybrid schools use high-bit IDs (0x80000001+) and their combinedSchoolMask references the canonical bits they qualify as. Each school carries visual identity (color tint, icon), gameplay rules (canBeImmune / canBeAbsorbed / canBeReflected / canCrit), resistance cap at max level, and cast / impact sound IDs. Cross-references with prior formats — castSoundId and impactSoundId point at WSND.soundId; combinedSchoolMask is a bitmask of OTHER WSCH.schoolId values within the same catalog. CLI: --gen-sch (3 base — Physical / Fire / Holy showing non-resistable Holy + non-reflectable Physical), --gen-sch- magical (6 canonical magical schools with proper colors + 365 max-level resistance caps), --gen-sch-combined (3 hybrids — Spellfire / Spellshadow / Spellfrost with multi-bit combinedSchoolMask), --info-wsch, --validate-wsch with --json variants. Validator catches id+name required, reflected-without-absorbed warning (reflected damage should be absorbable), self-referential combinedSchoolMask (school qualifying as itself), and combined-mask references to bits not defined in the same catalog (resolved at runtime across catalogs). Format graph: 55 → 56 binary formats. CLI flag count: 798 → 804.
2026-05-09 20:19:34 -07:00
"--gen-sch", "--gen-sch-magical", "--gen-sch-combined",
"--info-wsch", "--validate-wsch",
feat(editor): add WSCH JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the spell school catalog format shipped last batch. WSCH has no enum fields with name forms — just raw numeric school bits and flag bytes — so the JSON mapping is a direct dump. --import-wsch-json defaults canBeImmune/Absorbed/Crit to 1 and canBeReflected to 0 when omitted, matching the WoW canonical behavior for most schools (only Holy is non-immune, only Physical isn't reflectable). Verified byte-identical round-trip on all three preset emitters (starter / magical / combined). 806 documented CLI flags.
2026-05-09 20:20:55 -07:00
"--export-wsch-json", "--import-wsch-json",
feat(pipeline): add WLFG (Wowee Looking-for-Group) catalog 57th open format — replaces LFGDungeons.dbc plus the AzerothCore-style dungeon-finder reward tables. Defines the dungeons / raids that the Dungeon Finder / Raid Browser presents to players, with their level brackets, group-size requirements, role requirements (tank / heal / DPS), and queue-completion rewards. 4 difficulty levels (Normal / Heroic / Mythic / Hardmode — the latter for Ulduar-style toggleable boss difficulty), 4 expansion gates (Classic / TBC / WotLK / TurtleWoW), and 3 role-requirement bits (Tank / Heal / DPS — typically all three for queue-formed groups). Cross-references with prior formats — mapId points at WMS.mapId (the instance map), queueRewardItemId points at WIT.itemId (the random reward bag), firstClearAchievement points at WACH.achievementId. CLI: --gen-lfg (3 classic 5-mans Ragefire/Wailing/Deadmines with real WoW mapIds + level brackets), --gen-lfg-heroic (5 WotLK 80-level heroic 5-mans with emblem rewards + real first-clear achievement IDs from Halls of Lightning through Old Kingdom), --gen-lfg-raid (3 raid entries — Naxx-25, Ulduar-25 Hardmode, ToC-25 Mythic), --info-wlfg, --validate-wlfg with --json variants. Validator catches id+name+mapId required, difficulty 0..3, expansion 0..3, minLevel<=maxLevel, recommended-level outside range warning, unusual groupSize warning (5/10/25/40 are canonical), and zero role mask (queue can't form a balanced group). Format graph: 56 → 57 binary formats. CLI flag count: 804 → 811.
2026-05-09 20:24:21 -07:00
"--gen-lfg", "--gen-lfg-heroic", "--gen-lfg-raid",
"--info-wlfg", "--validate-wlfg",
feat(editor): add WLFG JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the LFG dungeon catalog format shipped this batch. --export-wlfg-json emits all 13 scalar fields plus dual int + name forms for difficulty (4 values) and expansionRequired (4 values) so hand-edits can use either representation. --import-wlfg-json defaults groupSize to 5 (dungeon) and requiredRolesMask to kRoleAll (all three role types) when omitted — matches the typical queue setup for cross-realm dungeon finder. Verified byte-identical round-trip on all three preset emitters (starter classic dungeons / heroic 5-mans / 25-man raids). 813 documented CLI flags.
2026-05-09 20:25:30 -07:00
"--export-wlfg-json", "--import-wlfg-json",
feat(pipeline): add WMAC (Wowee Macro / Slash Command) catalog 58th open format — novel format with no direct DBC equivalent. WoW historically stored player macros client-side in the user profile and system slash commands as hardcoded engine handlers; WMAC unifies both into a single structured catalog so default macros, system slash commands, and shipped player presets can be authored, validated, and shipped as content alongside the rest of the open-format graph. 5 macro kinds (SystemSlash for engine /sit /dance handlers, DefaultMacro for shipped presets, PlayerTemplate for user templates, GuildMacro for guild-shared, SharedMacro for account-wide). Multi-line macro bodies are stored verbatim with literal '\n' separators — the client parses /cast / /target / /run lines at runtime. Cross-references with prior formats — requiredClassMask uses WCHC.classId bit positions (Warrior=0x02, etc, same as WGLY/ WSET/WGTP). CLI: --gen-mac (3 system slash — /sit, /dance, /target with [@mouseover] modifier), --gen-mac-combat (4 warrior combat templates — heroic strike spam, charge/intercept stance dance, intercept stance switch, victory rush+bloodthirst fallback — each with default key bindings), --gen-mac-utility (3 universal utility — /follow target, mass /inv with %targetN tokens, /releasecorpse via RepopMe()), --info-wmac, --validate-wmac with --json variants. Validator catches id+name+body required, kind 0..4, body within maxLength cap, body starting with '/' or '#' (slash command or showtooltip annotation), and SystemSlash + classMask warning (slash commands are class- agnostic — restricting them to a class makes no sense). Format graph: 57 → 58 binary formats. CLI flag count: 814 → 819.
2026-05-09 20:30:17 -07:00
"--gen-mac", "--gen-mac-combat", "--gen-mac-utility",
"--info-wmac", "--validate-wmac",
feat(editor): add WMAC JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the macro catalog format shipped this batch. --export-wmac-json emits all 8 scalar fields plus a dual int + name form for macroKind. The macroBody string is dumped verbatim — multi-line bodies preserve embedded '\n' as JSON-escape sequences which most editors render readably (e.g. nlohmann pretty-print expands \n to actual newlines in the rendered output). --import-wmac-json defaults maxLength to 255 (the WoW canonical UI cap) when omitted. Verified byte-identical round-trip on all three preset emitters (starter / combat multi-line bodies / utility). 821 documented CLI flags.
2026-05-09 20:31:37 -07:00
"--export-wmac-json", "--import-wmac-json",
feat(pipeline): add WCHF (Wowee Character Customization Feature) catalog 59th open format — replaces CharHairGeosets.dbc + CharFacialHairStyles.dbc plus the variation portions of CharSections.dbc. Defines per-(race, sex) customization options the character creation screen exposes: skin colors, face variations, hair styles, hair colors, facial hair (beards / mustaches), and race-specific markings (Tauren horns, Draenei tendrils, Blood Elf ears). 9 feature kinds (SkinColor / FaceVariation / HairStyle / HairColor / FacialHair / FacialColor / EarStyle / Horns / Markings) cover the full canonical customization surface. Each entry is one selectable carousel choice for one (race, sex, kind) tuple — variationIndex disambiguates. expansionGate enum gates Blood Elf / Draenei (TBC) and DK features (WotLK) behind the right expansion unlock. Cross-references with prior formats — raceId points at WCHC.race.raceId. requiresExpansion bit positions match the WLFG expansion enum (Classic=0, TBC=1, WotLK=2, Turtle=3) for consistency. CLI: --gen-chf (5 Human Male starter — skin / face / 2 hair styles / facial hair), --gen-chf-bloodelf (8 Blood Elf Female hair styles, requiresExpansion=TBC — the iconic TBC race feature), --gen-chf-tauren (6 Tauren Male features using race-specific Horns kind + 3 facial hair variations), --info-wchf, --validate-wchf with --json variants. Validator catches id+name+raceId+texturePath required, kind 0..8 / sex 0..1 / expansion 0..3, and the critical (race, sex, kind, variation) tuple-uniqueness check — duplicates would shadow each other in the create- character carousel. Format graph: 58 → 59 binary formats. CLI flag count: 819 → 826.
2026-05-09 20:35:21 -07:00
"--gen-chf", "--gen-chf-bloodelf", "--gen-chf-tauren",
"--info-wchf", "--validate-wchf",
feat(editor): add WCHF JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the character customization feature catalog format shipped last batch. --export-wchf-json emits all 9 scalar fields plus dual int + name forms for featureKind (9 values) / sexId (2 values) / requiresExpansion (4 values) so hand-edits can use either representation. --import-wchf-json accepts either form. Verified byte-identical round-trip on all three preset emitters (starter Human Male / Blood Elf Female hair / Tauren Male horns + facial hair). 828 documented CLI flags.
2026-05-09 20:37:01 -07:00
"--export-wchf-json", "--import-wchf-json",
feat(pipeline): add WPVP (Wowee PvP Honor / Rank) — 60th open format 60th open format milestone — replaces the AzerothCore-style PvP rank tables plus the vanilla honor-rank reward chains. Defines PvP progression rungs: vanilla honor ranks (Private through Grand Marshal / High Warlord), arena rating brackets (Combatant / Challenger / Rival / Duelist / Gladiator), and battleground rated tiers. 5 rank kinds (VanillaHonor / ArenaRating / BattlegroundRated / WorldPvP / ConquestPoint) cover the canonical PvP progression surface. Each entry carries an alliance-specific name and a horde-specific name (Grand Marshal = High Warlord; arena tiers share the same name on both factions), an honor or rating threshold, and optional gear cross-refs (chest, gloves, shoulders) into WIT. Cross-references with prior formats — titleId points at WTTL.titleId (the unlock title), chest/gloves/shoulders point at WIT.itemId for the matching PvP set, bracketBgId points at WBGD.bgId for battleground-bracket gating. CLI: --gen-pvp (3 vanilla entry tiers Rank2-4 with alliance vs horde alternate names), --gen-pvp-alliance (9 vanilla ranks 6-14 with WTTL+WIT cross-refs and ramping honor thresholds 50k → 260k), --gen-pvp-arena (5 arena rating brackets 1500/1750/2000/2200/2400 with 10/20/40/80/160 emblem rewards), --info-wpvp, --validate-wpvp with --json variants. Validator catches id+name required, kind 0..4, level range valid, faction-name pairing (one set without the other is a typo), threshold monotonicity within a rankKind, arena rating below 1500 floor, and VanillaHonor with minHonor=0 baseline warning. Format graph: 59 → 60 binary formats (milestone). CLI flag count: 826 → 833.
2026-05-09 20:41:09 -07:00
"--gen-pvp", "--gen-pvp-alliance", "--gen-pvp-arena",
"--info-wpvp", "--validate-wpvp",
feat(editor): add WPVP JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the PvP rank catalog format shipped this batch. --export-wpvp-json emits all 12 scalar fields plus a dual int + name form for rankKind (5 values) so hand-edits can use either representation. --import-wpvp-json defaults bracket level to 1..80 (no level gate) when omitted — matches the typical case for vanilla honor ranks which weren't level-gated beyond the cap. Verified byte-identical round-trip on all three preset emitters (starter / alliance vanilla 9-rank ladder / arena 5-tier ladder). 835 documented CLI flags.
2026-05-09 20:42:21 -07:00
"--export-wpvp-json", "--import-wpvp-json",
feat(pipeline): add WBNK (Wowee Bag / Bank Slot) catalog 61st open format — replaces ItemBag.dbc plus the bank-storage and special-purpose container tables. Defines every slot the player has access to: equipped bags, bank bags, keyring, soul shard bag, quiver, reagent bag, hunter pet stable. 8 bag kinds (Inventory / Bank / Keyring / Quiver / SoulShard / Stable / Reagent / Wallet) cover the canonical container surface. Each entry has a fixed capacity (or 0 = variable, size set by equipped bag), a display order in the inventory UI, an unlock state with optional gold cost (bank bags ramp through 10s / 1g / 10g / 25g / 50g / 100g matching canonical WoW prices), and an accepts-bag-subclass mask gating which container kinds may be equipped (generic / herb / enchanting / engineer / gem / mining / leather / inscription / quiver / ammo pouch). Cross-references with prior formats — fixedBagItemId points at WIT.itemId for the bag item that always occupies a fixed slot (0 = player-equipable variable slot). CLI: --gen-bnk (5 inventory slots — 16-slot fixed main backpack + 4 player-equippable bag slots accepting generic containers + herb + enchanting bags), --gen-bnk-bank (8 bank bag slots with the canonical WoW unlock cost ramp), --gen-bnk-special (4 special-purpose: 32-slot Keyring fixed, warlock SoulShardBag, hunter ArrowQuiver, hunter HuntersStable for 5 pets), --info-wbnk, --validate-wbnk with --json variants. Validator catches id+name required, kind 0..7, locked-with-zero-cost (slot can never be unlocked), fixed-slot-with-non-zero-mask (equippable bag would be ignored), variable slot with empty mask (no bag can fit), and ambiguous (bagKind, displayOrder) tuples (UI sort would flicker). Format graph: 60 → 61 binary formats. CLI flag count: 833 → 840.
2026-05-09 20:46:06 -07:00
"--gen-bnk", "--gen-bnk-bank", "--gen-bnk-special",
"--info-wbnk", "--validate-wbnk",
feat(editor): add WBNK JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the bag/bank catalog format shipped last batch. --export-wbnk-json emits all 8 scalar fields plus a dual int + name form for bagKind so hand-edits can use either representation. --import-wbnk-json defaults isUnlocked to 1 and acceptsBagSubclassMask to kAcceptsAny Container when omitted — matches the typical case for inventory and bank slots so a sparse sidecar still produces a working catalog. Verified byte-identical round-trip on all three preset emitters (starter inventory / 8-slot bank with gold cost ramp / 4 special slots covering keyring + soul shard + quiver + stable). 842 documented CLI flags.
2026-05-09 20:47:38 -07:00
"--export-wbnk-json", "--import-wbnk-json",
feat(pipeline): add WRUN (Wowee DK Rune Cost) catalog 62nd open format — replaces RuneCost.dbc plus the DK-specific portions of ChrPowerType. Defines per-spell rune costs (Blood / Frost / Unholy) and runic-power generation / consumption for the Death Knight class. 4 spell tree branches (BloodTree / FrostTree / UnholyTree / Generic) classify which spec uses each rune cost. Each entry binds a spell to its rune cost (how many of each rune kind the spell consumes), an optional anyDeathConvertCost (extra Death-rune-acceptable cost for procced abilities), and a runicPowerCost (negative = generator, positive = spender). Cross-references with prior formats — spellId points at WSPL.spellId (the spell that uses this rune cost). CLI: --gen-rune (3 baseline DK abilities — Death Strike 1F+1U + 20RP gen, Frost Strike pure 40 RP spender, Heart Strike 1B + 10RP gen), --gen-rune-blood (4 blood-tree DK abilities — Heart Strike, Death and Decay AoE, Vampiric Blood tank cooldown, Rune Tap self-heal), --gen-rune-frost (4 frost-tree — Frost Strike, Howling Blast AoE, Obliterate finisher, Icy Touch ranged opener applying Frost Fever), --info-wrun, --validate-wrun with --json variants. Validator catches id+name+spellId required, branch 0..3, no rune cost > 2 (DK only has 2 of each rune type so a higher cost can never be paid), runicPowerCost > 100 (DK RP cap), no-cost warning (spell consumes nothing — verify it's a passive/stance/form), and high-RP-generator warning (> 25 RP per cast is unusual). Format graph: 61 → 62 binary formats. CLI flag count: 840 → 847.
2026-05-09 20:52:19 -07:00
"--gen-rune", "--gen-rune-blood", "--gen-rune-frost",
"--info-wrun", "--validate-wrun",
feat(editor): add WRUN JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the DK rune cost catalog format shipped this batch. --export-wrun-json emits all 9 scalar fields plus a dual int + name form for spellTreeBranch (4 values) so hand-edits can use either representation. --import-wrun-json accepts either form. Verified byte- identical round-trip on all three preset emitters (starter 3-cost / blood-tree 4-cost / frost-tree 4-cost). 849 documented CLI flags.
2026-05-09 20:55:07 -07:00
"--export-wrun-json", "--import-wrun-json",
feat(pipeline): add WLDS (Wowee Loading Screen) catalog 63rd open format — replaces LoadingScreens.dbc plus the per-zone background-image tables. Defines the loading-screen images shown when the client crosses into a new map / instance, with optional level-bracket gating and expansion gating (TBC art only shown if expansion installed). When multiple screens match the player's current map + level + expansion, displayWeight selects randomly between them — a zone with 3 weighted variants gets a different image roughly proportional to weight. 4 expansion gates (Classic / TBC / WotLK / TurtleWoW), isAnimated flag for screens with subtle animation, isWideAspect flag for 16:9 raid intro art (vs 4:3 standard). Cross-references with prior formats — mapId points at WMS.map.mapId (which map triggers this loading screen); mapId=0 is the catch-all sentinel for screens shown when no map-specific screen matches. CLI: --gen-lds (3 base screens — Elwynn level 1-30, Orgrimmar, GenericFallback level 31-80 catch-all), --gen-lds-instances (5 WotLK dungeon screens with mapId+expansion cross-refs: Halls of Lightning/Stone, Utgarde Pinnacle, Violet Hold, Old Kingdom), --gen-lds-raid (3 raid intro screens — Naxxramas/Ulduar/ToC at isWideAspect=1 with weight=3), --info-wlds, --validate-wlds with --json variants. Validator catches id+name+texture required, expansion 0..3, level range valid, weight=0 (in pool but never picked), and the practical catch-all overlap warning when multiple mapId=0 screens share overlapping level brackets (random pick becomes non-deterministic). Format graph: 62 → 63 binary formats. CLI flag count: 847 → 854.
2026-05-09 20:59:25 -07:00
"--gen-lds", "--gen-lds-instances", "--gen-lds-raid",
"--info-wlds", "--validate-wlds",
feat(editor): add WLDS JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the loading screen catalog format shipped last batch. --export-wlds-json emits all 11 scalar fields plus a dual int + name form for expansionRequired so hand-edits can use either representation. --import-wlds-json accepts either form, defaulting minLevel to 1 and maxLevel to 80 when omitted (full level range). Verified byte-identical round-trip on all three preset emitters (starter / WotLK instances / raid intros with isWideAspect=1). 856 documented CLI flags.
2026-05-09 21:01:53 -07:00
"--export-wlds-json", "--import-wlds-json",
feat(pipeline): add WSUF (Wowee Item Random Suffix) catalog 64th open format — replaces ItemRandomProperties.dbc + ItemRandomSuffix.dbc plus the AzerothCore-style suffix-roll tables. Defines random "of the X" suffixes that roll on green and blue items at world drop ("Sturdy Cloth Cap of the Bear" = base item + STR + STA suffix). 5 suffix categories (Generic / Elemental / Defensive / PvPSuffix / Crafted), per-suffix item-quality bracket gating (only blue+ items can roll PvPSuffix), restricted-slot mask that limits which equipment slots a suffix can apply to (15 slot bits matching WCEQ slot enum), and up to 5 stat bonus slots per suffix matching WoW canonical max. statValuePoints isn't an absolute number — it's a scaling base that the runtime multiplies by an item-level coefficient to compute the final per-item bonus, so "of the Bear" gives proportionally more strength on a level-60 item than on a level-20 item. Cross-references with prior formats — statKind values match WIT.statType enum (STR=4, AGI=3, INT=5, SPI=6, STA=7) so item generators roll consistent stats with base items. CLI: --gen-suf (3 generic stat triads — Bear STR+STA, Eagle INT+SPI, Tiger STR+AGI), --gen-suf-magical (4 elemental spell-power suffixes restricted to caster-eligible slots), --gen-suf-pvp (3 PvPSuffix entries with resilience + offensive stats, blue+ quality only), --info-wsuf, --validate-wsuf with --json variants. Validator catches id+name required, category 0..4, quality range valid (0..7 covers heirloom), itemQuality floor<=ceiling, stat-kind/value pairing (kind=0 with value!=0 is a typo, vice versa), and no-stats warning (suffix renames item without changing it). Format graph: 63 → 64 binary formats. CLI flag count: 854 → 861.
2026-05-09 21:05:49 -07:00
"--gen-suf", "--gen-suf-magical", "--gen-suf-pvp",
"--info-wsuf", "--validate-wsuf",
feat(editor): add WSUF JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the item-suffix catalog format shipped this batch. --export-wsuf-json emits all 5 scalar fields plus a dual int + name form for suffixCategory and a nested stats[] array — only populated stat slots are emitted to keep hand-edits compact. --import-wsuf-json clears the trailing stat slots before parsing (so a 2-stat sidecar correctly leaves slots 2-4 zero) and accepts suffixCategory by either int or name. Verified byte- identical round-trip on all three preset emitters (starter 2-stat / magical 1-stat / PvP 3-stat). 863 documented CLI flags.
2026-05-09 21:07:58 -07:00
"--export-wsuf-json", "--import-wsuf-json",
feat(pipeline): add WCRR (Wowee Combat Rating Conversion) catalog 65th open format — replaces gtCombatRatings.dbc plus the per-level rating-to-percentage tables in gtRegenHPPerSpt.dbc and related stat-curve DBCs. Defines per-rating-type conversion factors at canonical level breakpoints (1 / 60 / 70 / 80) — the runtime linearly interpolates between breakpoints for intermediate levels. pointsAtLevelN is "how many rating points equal 1% of the benefit at that level." Higher level = more rating needed for the same %. Standard WoW WotLK example: 14 crit rating = 1% crit at L60, but 45.91 = 1% at L80. 5 rating kinds (Combat / Defense / Spell / Resilience / Other) classify what stat resolver category each rating belongs to. CLI: --gen-crr (3 essential combat ratings — Hit/Crit/Haste at canonical WoW WotLK conversion values), --gen-crr-defensive (4 defensive — Defense/Dodge/Parry/Block with diminishing- returns soft-cap percentages), --gen-crr-spell (3 spell — SpellPower direct 1:1, SpellPenetration flat, MP5 mana regen), --info-wcrr, --validate-wcrr with --json variants. Validator catches id+name required, kind 0..4, all pointsAtLN > 0 (otherwise stat resolver would div-by-zero), maxBenefitPercent > 0 (rating would never grant any benefit), and non-monotonic conversion curve warning (rating cost typically ascends with level for non-flat ratings like SpellPower). Format graph: 64 → 65 binary formats. CLI flag count: 861 → 868.
2026-05-09 21:11:26 -07:00
"--gen-crr", "--gen-crr-defensive", "--gen-crr-spell",
"--info-wcrr", "--validate-wcrr",
feat(editor): add WCRR JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the combat rating conversion catalog format shipped last batch. --export-wcrr-json emits all 10 scalar fields plus a dual int + name form for ratingKind so hand-edits can use either representation. --import-wcrr-json defaults pointsAtL1/L60/L70/L80 to canonical WoW WotLK starter values when omitted (1 / 14 / 22 / 45) — matches typical combat rating curves so a sparse sidecar still produces a working catalog. Verified byte-identical round-trip on all three preset emitters (starter Hit/Crit/Haste / defensive Defense+Dodge+Parry+Block / spell SpellPower+Pen+MP5). 870 documented CLI flags.
2026-05-09 21:14:18 -07:00
"--export-wcrr-json", "--import-wcrr-json",
feat(pipeline): add WUMV (Wowee Unit Movement Type) catalog 66th open format — replaces UnitMovement.dbc plus the movement-modifier portions of CreatureModelData.dbc. Defines movement speed types (walk / run / swim / flight / fly / pitch) with their canonical baseline speeds in yards-per- second, plus the temp speed buffs that stack on top (Sprint, Aspect of the Cheetah, Travel Form). 12 movement categories cover the canonical surface (Walk / Run / Backward / Swim / SwimBack / Turn / Flight / FlightBack / Pitch / Fly / FlyBack / TempBuff). baseSpeed is yards/second for baseline categories and ignored for TempBuff entries (which use baseMultiplier instead). maxMultiplier caps stacking — Sprint capped at 1.4 means Sprint + Aspect of Cheetah doesn't exceed 1.4× run speed. stackingPriority resolves conflicts when multiple buffs of equal multiplier compete (higher wins). CLI: --gen-umv (4 baseline at canonical WoW vanilla speeds: Walk 2.5y/s, Run 7.0y/s, Swim 4.7y/s, Turn π rad/s), --gen-umv-flight (5 flight entries — ground-rail Flight 7y/s, free Fly 14y/s, Pitch 1.5 rad/s, backward variants at slower 4.5y/s), --gen-umv-buffs (5 temp speed buffs matching real WoW spell auras with proper durations and stacking priorities), --info-wumv, --validate-wumv with --json variants. Validator catches id+name required, category 0..11, baseMultiplier > 0 (otherwise unit freezes in place), maxMultiplier >= baseMultiplier (cap below floor would clamp the base down), baseline categories need baseSpeed > 0, and Run < 3.0y/s warning (canonical is 7.0y/s). Format graph: 65 → 66 binary formats. CLI flag count: 870 → 875.
2026-05-09 21:18:03 -07:00
"--gen-umv", "--gen-umv-flight", "--gen-umv-buffs",
"--info-wumv", "--validate-wumv",
feat(editor): add WUMV JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the unit movement catalog format shipped this batch. --export-wumv-json emits all 11 scalar fields plus a dual int + name form for movementCategory (12 values) so hand-edits can use either representation. --import-wumv-json defaults baseMultiplier to 1.0 and maxMultiplier to 1.4 (canonical Sprint cap) when omitted. Verified byte-identical round-trip on all three preset emitters (starter / flight / buffs). 877 documented CLI flags.
2026-05-09 21:20:13 -07:00
"--export-wumv-json", "--import-wumv-json",
feat(pipeline): add WQSO (Wowee Quest Sort) catalog 67th open format — replaces QuestSort.dbc plus the quest-log categorization fields in QuestInfo.dbc. Defines the categories that quests fall into for the quest-log UI: class quests (Warrior trial, etc), profession quests, daily quests, holiday events, reputation grinds, dungeon / heroic / raid quests, repeatables, PvP, tournament. 12 sort kinds (General / ClassQuest / Profession / Daily / Holiday / Reputation / Dungeon / Raid / Heroic / Repeatable / PvP / Tournament). Each WQT (quest) entry can reference a sortId here to be grouped under the right header in the quest log. Sorts can be class-restricted (Warrior quests only show for warriors), profession-restricted, or faction-reputation-gated. Cross-references with prior formats — targetClassMask uses WCHC.classId bit positions (matches WGLY/WSET/WGTP convention), targetProfessionId points at WTSK.profession enum, targetFactionId points at WFAC.factionId. CLI: --gen-qso (3 generic sorts — General catch-all, Daily reset, Repeatable non-daily), --gen-qso-class (10 class- specific sorts with proper bit masks for Warrior 0x02 through Druid 0x800), --gen-qso-profession (8 profession sorts with WTSK profession enum cross-refs), --info-wqso, --validate-wqso with --json variants. Validator catches id+name+displayName required, kind 0..11, ClassQuest with classMask=0 (not actually class-restricted), Profession with profId=0 + non-Blacksmithing-name (likely typo since 0=Blacksmithing in WTSK), and Reputation with factionId=0 (no faction to grind). Format graph: 66 → 67 binary formats. CLI flag count: 877 → 882.
2026-05-09 21:23:38 -07:00
"--gen-qso", "--gen-qso-class", "--gen-qso-profession",
"--info-wqso", "--validate-wqso",
feat(editor): add WQSO JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the quest sort catalog format shipped last batch. --export-wqso-json emits all 9 scalar fields plus a dual int + name form for sortKind (12 values) so hand-edits can use either representation. --import-wqso-json accepts either form. Verified byte- identical round-trip on all three preset emitters (starter 3-sort generic / 10-class with WCHC bit masks / 8-profession with WTSK enum cross-refs). 884 documented CLI flags.
2026-05-09 21:25:12 -07:00
"--export-wqso-json", "--import-wqso-json",
feat(editor): add WSRG (Spell Range Index) open catalog format Open replacement for Blizzard's SpellRange.dbc plus the per-spell range-bucket fields in Spell.dbc. Defines the categorical range buckets that spells reference instead of carrying their own min/max yards (every Frostbolt shares one 30y bucket; every Heal shares one 40y friendly bucket). Each entry carries separate min/max for hostile vs friendly targets so heals can reach further on allies than nukes do on enemies, plus an icon color for HUD range indicators. Three preset emitters: --gen-srg (3 baseline buckets: Self/Melee/Spell), --gen-srg-ranged (5 ranged spell buckets: Short/Medium/Long/VeryLong/Unlimited), --gen-srg-friendly (3 friendly-only buckets where hostile range is 0). --info-wsrg and --validate-wsrg round out the per-format surface; validation catches negative ranges, min>max, duplicate ids, out-of-range rangeKind, and warns on Self+nonzero range or Melee>8y. Wired through the cross-format table so WSRG appears automatically in --list-formats, --info-magic, --diff-headers, --summary-dir, --rename-by-magic, --catalog-grep, --tree-summary-md, and --touch-tree. Format count 67 -> 68; CLI flag count 885 -> 890.
2026-05-09 21:33:17 -07:00
"--gen-srg", "--gen-srg-ranged", "--gen-srg-friendly",
"--info-wsrg", "--validate-wsrg",
feat(editor): add WSRG JSON round-trip (--export/--import-wsrg-json) Closes the editing loop on the spell-range bucket catalog: dump a .wsrg to a JSON sidecar, hand-edit the buckets (rename, retune yards, recolor HUD indicator), re-import to a byte-identical binary. The exporter emits both the int rangeKind (0..6) and the human-readable rangeKindName ("self", "melee", "short", "ranged", "long", "very-long", "unlimited"); the importer accepts either, so JSON sidecars stay readable without losing the canonical binary encoding. Verified byte-identical round-trip on all three presets (starter, ranged, friendly). CLI flag count 890 -> 892.
2026-05-09 21:34:43 -07:00
"--export-wsrg-json", "--import-wsrg-json",
feat(editor): add WSCT (Spell Cast Time Index) open catalog format Companion to WSRG: open replacement for SpellCastTimes.dbc plus the per-spell castTime fields in Spell.dbc. Defines categorical cast-time buckets (Instant 0ms / FastCast 1s / MediumCast 1.5s / LongCast 3s) that thousands of spells reference instead of each embedding their own ms count. Together WSRG and WSCT let the spell engine resolve "Frostbolt's range bucket = id 3" and "Frostbolt's cast time bucket = id 5" with two table reads instead of duplicating per-rank data. Cast time can scale with character level via perLevelMs (a rank-1 spell at 1000ms can grow to 2200ms at lvl 60), then the bucket result is clamped to [minCastMs, maxCastMs] before haste is applied. resolveAtLevel() does the math for engine consumers. Three preset emitters: --gen-sct (4 baseline buckets), --gen-sct-channel (3 channeled-spell durations), --gen-sct-ramp (4 level-scaled buckets with non-zero perLevelMs). Validation catches negative baseCastMs, min>max, duplicate ids, warns on Instant kind with non-zero base (cast bar would still show), and errors on Channel kind with zero base (would tick once and end). Wired through the cross-format table; WSCT appears automatically in all 9 cross-format utilities. Format count 68 -> 69; CLI flag count 892 -> 897.
2026-05-09 21:37:42 -07:00
"--gen-sct", "--gen-sct-channel", "--gen-sct-ramp",
"--info-wsct", "--validate-wsct",
feat(editor): add WSCT JSON round-trip (--export/--import-wsct-json) Closes the editing loop on the spell-cast-time bucket catalog: dump a .wsct to JSON, hand-edit baseCastMs / perLevelMs / clamp bounds (retune a Pyroblast bucket from 3000ms to 2800ms across every spell that references it), re-import to a byte-identical binary. The exporter emits both castKind (int 0..4) and the human-readable castKindName ("instant", "cast", "channel", "delayed", "charge"); the importer accepts either. Verified byte-identical round-trip on all three presets (starter / channel / ramp). CLI flag count 897 -> 899.
2026-05-09 21:38:56 -07:00
"--export-wsct-json", "--import-wsct-json",
feat(editor): add WSDR (Spell Duration Index) — completes WSRG/WSCT/WSDR triplet Open replacement for SpellDuration.dbc plus per-spell duration fields in Spell.dbc. Defines the categorical duration buckets that auras / DoTs / HoTs / buffs reference (5s / 30s / 5min / 1hr / UntilCancelled / UntilDeath). Together with WSRG (range) and WSCT (cast time), this completes a small triplet of spell-metadata catalogs: instead of every Frostbolt rank embedding its own range, cast time, and chill-debuff duration as duplicate fields, each spell holds three small integer ids that resolve through these three tables. The engine retunes thousands of spells at once by editing one bucket. Duration scales with caster level via perLevelMs (a rank-1 Renew at 9s grows to 12s at lvl 60), then is clamped to maxDurationMs. Negative baseDurationMs is the canonical sentinel for "no timer" (UntilCancelled / UntilDeath); resolveAtLevel returns -1 for those so HUD code can render the indefinite-duration glyph. Three preset emitters: --gen-sdr (5 baseline tiers from instant to one-hour), --gen-sdr-buffs (4 long-duration buffs including UntilDeath), --gen-sdr-dot (4 tick-based DoT/HoT buckets at 3s ticks). Validation enforces base>0 for Timed/TickBased, base<0 for permanent kinds, max>=base, durationKind 0..4, no duplicate ids, and warns on Instant+nonzero base. Wired through the cross-format table; WSDR appears automatically in all 9 cross-format utilities. Format count 69 -> 70; CLI flag count 899 -> 904.
2026-05-09 21:41:55 -07:00
"--gen-sdr", "--gen-sdr-buffs", "--gen-sdr-dot",
"--info-wsdr", "--validate-wsdr",
feat(editor): add WSDR JSON round-trip (--export/--import-wsdr-json) Closes the editing loop on the spell-duration bucket catalog: dump a .wsdr to JSON, hand-edit baseDurationMs / perLevelMs / clamp / durationKind (e.g. retune Renew from 9s to 10s base across every spell that references the HoT5Tick bucket), re-import to a byte-identical binary. The exporter emits both durationKind (int 0..4) and the human-readable durationKindName ("instant", "timed", "tick", "until-cancelled", "until-death"); the importer accepts either, so JSON sidecars stay readable without losing the canonical binary encoding. Verified byte-identical round-trip on all three presets (starter / buffs / dot). CLI flag count 904 -> 906.
2026-05-09 21:43:16 -07:00
"--export-wsdr-json", "--import-wsdr-json",
feat(editor): add WSCD (Spell Cooldown Category) open catalog format Open replacement for SpellCooldown.dbc plus the per-spell category-cooldown fields in Spell.dbc. Defines the shared-cooldown buckets that related spells reference: casting one spell triggers a cooldown on every other spell in the same bucket. Mage Polymorph variants (Sheep / Pig / Turtle / Cat) all share one bucket so morphing a target locks all variants at once. Healing potions and mana potions share the SharedWithItems bucket so consuming one locks the other. Distinct from WSDR (which times how long an aura stays on a target) — WSCD times how long before a spell can be cast again. The global cooldown (GCD) is itself just one bucket of this kind, flagged with OnGCDStart so the engine triggers it at cast start rather than cast finish. Three preset emitters: --gen-cdb (4 baseline buckets including GCD), --gen-cdb-class (5 mage-specific class cooldowns including the Polymorph family), --gen-cdb-items (5 item cooldowns including the heal/mana potion shared bucket and the 60min Hearthstone family). Validation enforces id+name presence, bucketKind 0..4, no duplicate ids, and warns on Global without OnGCDStart (engine wouldn't trigger on cast start) and Spell kind with SharedWithItems (contradictory). categoryFlags is a bitfield (AffectedByHaste / SharedWithItems / OnGCDStart / IgnoresCooldownReduction); --info-wscd decodes the bits to label list. Wired through the cross-format table; WSCD appears automatically in all 9 cross-format utilities. Format count 70 -> 71; CLI flag count 907 -> 912.
2026-05-09 21:49:13 -07:00
"--gen-cdb", "--gen-cdb-class", "--gen-cdb-items",
"--info-wscd", "--validate-wscd",
feat(editor): add WSCD JSON round-trip (--export/--import-wscd-json) Closes the editing loop on the spell-cooldown bucket catalog: dump a .wscd to JSON, hand-edit cooldownMs / bucketKind / category flags (e.g. retune the global cooldown from 1.5s to 1.0s, mark a bucket as IgnoresCooldownReduction, add Polymorph variants to the class family bucket), re-import to a byte-identical binary. The exporter emits both bucketKind (int 0..4) and the human- readable bucketKindName ("spell", "item", "class", "global", "misc"); same dual form for categoryFlags (int bitfield AND "AffectedByHaste|OnGCDStart" pipe-separated label string). The importer prefers the int form for categoryFlags when both are present so unknown flag bits round-trip losslessly, falling back to the label form for hand-edited sidecars. Verified byte-identical round-trip on all three presets (starter / class / items). CLI flag count 912 -> 914.
2026-05-09 21:50:39 -07:00
"--export-wscd-json", "--import-wscd-json",
feat(editor): add WCEF (Creature Family) open catalog format Open replacement for CreatureFamily.dbc plus the per-creature family fields in Creature.dbc. Defines the family categorization that pet-able beasts share (Bear / Cat / Wolf / Boar / Crab / Raptor / Devilsaur / etc), each with its own pet talent tree (Ferocity / Tenacity / Cunning), food preferences as a bitmask (Meat / Fish / Bread / Cheese / Fruit / Fungus / Raw), the skill line that family-specific abilities reference, and the minimum hunter level required to tame it. Used by the hunter pet system to decide which talent tree a tamed pet uses, validate that a hunter can tame a creature, match feeding-table food items to pet preferences, and gate exotic-beast families behind the Beast Master 51-point talent. Cross-references back to WCRT (creature.familyId points here) and WSPL (family-specific abilities reference WSPL spellId via the skillLine field). Three preset emitters: --gen-cef (5 baseline families covering both major talent trees), --gen-cef-ferocity (4 DPS-tree pets with bleed/howl/armor-shred mechanics), --gen-cef-exotic (4 exotic Beast Master families requiring 51-point talent). Validation enforces id+name presence, familyKind 0..5, talent tree 0..3, no duplicate ids, and warns on: - NotPet families with a non-None talent tree (irrelevant) - Exotic families with minLevelForTame > 80 (level-cap unreachable) - Beast/Exotic families with no food types set (pet would starve) Wired through the cross-format table; WCEF appears automatically in all 10 cross-format utilities. Format count 71 -> 72; CLI flag count 914 -> 919.
2026-05-09 21:54:00 -07:00
"--gen-cef", "--gen-cef-ferocity", "--gen-cef-exotic",
"--info-wcef", "--validate-wcef",
feat(editor): add WCEF JSON round-trip (--export/--import-wcef-json) Closes the editing loop on the creature-family catalog: dump a .wcef to JSON, hand-edit familyKind / petTalentTree / minLevelForTame / petFoodTypes (e.g. add Bread to Bear's diet, move Boar from Tenacity to Cunning, drop the tame requirement on exotic Worm from 50 to 45), re-import to a byte-identical binary. Three different field types each take dual int+name forms: - familyKind: int 0..5 OR "beast"/"demon"/"undead"/"elemental"/ "not-pet"/"exotic" - petTalentTree: int 0..3 OR "none"/"ferocity"/"tenacity"/ "cunning" - petFoodTypes: int bitfield OR pipe-separated label string ("Meat|Fish|Raw"). Importer prefers the int form when both are present so unknown bits round-trip losslessly. Verified byte-identical round-trip on all three presets (starter / ferocity / exotic). CLI flag count 919 -> 921.
2026-05-09 21:55:23 -07:00
"--export-wcef-json", "--import-wcef-json",
feat(editor): add WSPC (Spell Power Cost) — completes spell-bucket five-pack Open replacement for the per-spell power-cost fields in Spell.dbc plus SpellPowerCost-related side tables. Defines categorical power-cost buckets that spells reference (LowMana 5% / MediumMana 15% / HighMana 30% of caster max mana; fixed Rage-30 / Energy-40 / Runic-30 / etc), so spells share cost metadata across ranks instead of embedding per-rank cost numbers. Completes the small lookup-bucket five-pack: WSRG — range bucket WSCT — cast time bucket WSDR — duration bucket WSCD — cooldown bucket WSPC — power cost bucket (this catalog) Five small integer ids per spell (range / cast / dur / cd / cost) replace the dozens of duplicate per-rank fields that Blizzard's Spell.dbc carries. Editing one bucket here retunes every spell that references it — change LowMana from 5% to 4% and every rank-1 bolt across every caster class becomes cheaper. Cost can be flat (baseCost), per-level scaled (perLevelCost), or percentage-of-max-power (percentOfBase) — the engine sums whichever fields are non-zero. resolveCost(id, level, maxPower) does the math. Twelve power types covering every WoW resource (Mana / Rage / Focus / Energy / Happiness / Runic Power / Runes / Soul Shards / Holy Power / Eclipse / Health / NoCost). Three preset emitters: --gen-spc (4 baseline mana tiers), --gen-spc-rage (4 fixed warrior rage costs including stance-locked Whirlwind), --gen-spc-mixed (5 cross-class costs covering every non-mana power type with refund-on-miss flag for energy). Validation enforces id+name presence, powerType 0..11, no duplicate ids; warns on percentOfBase outside [0,1] (would overflow), NoCost type with non-zero cost fields, and non-NoCost types with no cost set (would cast for free — easy bug to ship). Wired through the cross-format table; WSPC appears automatically in all 11 cross-format utilities. Format count 72 -> 73; CLI flag count 922 -> 927.
2026-05-09 22:00:55 -07:00
"--gen-spc", "--gen-spc-rage", "--gen-spc-mixed",
"--info-wspc", "--validate-wspc",
feat(editor): add WSPC JSON round-trip (--export/--import-wspc-json) Closes the editing loop on the spell-power-cost bucket catalog: dump a .wspc to JSON, hand-edit baseCost / perLevelCost / percentOfBase / powerType / costFlags (e.g. retune LowMana from 5% to 4%, add ScalesWithMastery to a class bucket, switch a Whirlwind cost from 25 rage to 20), re-import to a byte-identical binary. The exporter emits both powerType (int 0..11) and the human- readable powerTypeName ("mana" / "rage" / "focus" / "energy" / "happiness" / "runic-power" / "runes" / "soul-shards" / "holy-power" / "eclipse" / "health" / "no-cost"). costFlags is emitted as both int bitfield AND pipe-separated label string. The importer prefers the int form for costFlags when both are present so unknown flag bits round-trip losslessly. Verified byte-identical round-trip on all three presets (starter / rage / mixed). CLI flag count 927 -> 929.
2026-05-09 22:02:08 -07:00
"--export-wspc-json", "--import-wspc-json",
feat(editor): add WGFS (Glyph Slot) open catalog format Open replacement for Blizzard's GlyphSlot.dbc. Defines the per-class glyph slot layout: which slots a class has (Major / Minor / Prime), in which display order they appear in the spellbook UI, and at which character level each slot becomes available for use. Distinct from WGLY (GlyphProperties) which defines the individual glyphs themselves. WGLY says "Glyph of Polymorph exists, costs 1 inscription dust, modifies Polymorph"; WGFS says "the slot that holds Glyph of Polymorph is the second Major Glyph Slot, unlocks at level 25, and only Mages have it". Layout grew across expansions, captured by the three presets: - --gen-gfs — 6 slots: 3 Major + 3 Minor all-class baseline (25/50/75 each) - --gen-gfs-wotlk — 6 slots: 3 Major (15/30/50) + 3 Minor (15/50/70) matching WotLK 3.3.5a - --gen-gfs-cata — 9 slots: 3 Prime + 3 Major + 3 Minor matching Cataclysm Cross-references back to WGLY (glyphs reference slotKind to constrain which glyph fits which slot) and WCHC (requiredClassMask uses the same bit layout as WCHC class IDs). Validation enforces id+name+classMask presence (classMask=0 means no class can use the slot — usually a config bug), slotKind 0..2, no duplicate ids; warns on minLevelToUnlock>80 (would never unlock at WotLK cap), displayOrder>4 (UI typically shows 3-4), and (kind+order) collisions for overlapping classMask (two slots claiming the same UI position would render on top of each other). isUnlockedFor(id, classBit, level) is the engine helper. Wired through the cross-format table; WGFS appears automatically in all 11 cross-format utilities. Format count 73 -> 74; CLI flag count 929 -> 934.
2026-05-09 22:05:05 -07:00
"--gen-gfs", "--gen-gfs-wotlk", "--gen-gfs-cata",
"--info-wgfs", "--validate-wgfs",
feat(editor): add WGFS JSON round-trip (--export/--import-wgfs-json) Closes the editing loop on the glyph-slot catalog: dump a .wgfs to JSON, hand-edit slotKind / displayOrder / minLevelToUnlock / requiredClassMask (e.g. add a fourth Major slot, lower a Minor slot's unlock from 75 to 70, restrict a Prime slot to Mages only), re-import to a byte-identical binary. The exporter emits both slotKind (int 0..2) and the human- readable slotKindName ("major", "minor", "prime"); the importer accepts either form. Verified byte-identical round-trip on all three presets (starter / wotlk / cata). CLI flag count 934 -> 936.
2026-05-09 22:06:16 -07:00
"--export-wgfs-json", "--import-wgfs-json",
feat(editor): add WCDF (Creature Difficulty) open catalog format Open replacement for Blizzard's CreatureDifficulty.dbc. Maps a base creature entry to its difficulty variants: Normal-10 / Normal-25 / Heroic-10 / Heroic-25 in WotLK raid format. Each variant is itself a separate WCRT creature entry with its own stats, abilities, and loot. When a 25-man party engages an instance, the engine looks up the encounter base creature's difficultyId, reads the normal25Id field, and spawns that variant instead. This is how Lord Marrowgar in 25-Heroic ICC has 30M HP and hits for 80k while the same encounter in 10-Normal has 5M HP and hits for 25k — same spawn point, different WCRT entries. 5-man dungeons typically use only normal10Id + heroic10Id (the 25-man fields stay 0 — engine falls through to the 10-man variant when 25-man is queried). World bosses don't scale at all (all 4 variant fields stay 0, engine falls back to the base entry). Cross-references back to WCRT — every non-zero variant id field points at a WCRT.creatureId entry; the base creature itself lives in WCRT too. Three preset emitters: --gen-cdf (4 example bosses with full 4-variant routing), --gen-cdf-wotlk-raid (4 ICC-style raid bosses Marrowgar/Deathwhisper/Saurfang/LK with all 4 difficulty variants), --gen-cdf-fiveman (4 5-man dungeon bosses with only Normal+Heroic 10-man set). resolveVariant(id, mode) is the engine helper. Validation enforces id+name+baseCreatureId presence, spawnGroupKind 0..5, no duplicate ids; warns on: - WorldBoss kind with non-zero variant ids (world bosses don't scale) - duplicate baseCreatureId across routes (only first honored) - all-self-reference non-WorldBoss (creature doesn't actually scale) - Boss with n25 but not n10 (raid sequencing typo — n10 always comes with n25) Wired through the cross-format table; WCDF appears automatically in all 11 cross-format utilities. Format count 74 -> 75; CLI flag count 936 -> 941.
2026-05-09 22:10:09 -07:00
"--gen-cdf", "--gen-cdf-wotlk-raid", "--gen-cdf-fiveman",
"--info-wcdf", "--validate-wcdf",
feat(editor): add WCDF JSON round-trip (--export/--import-wcdf-json) Closes the editing loop on the creature-difficulty routing catalog: dump a .wcdf to JSON, hand-edit baseCreatureId / 4 variant ids / spawnGroupKind (e.g. swap a Lich King variant from heroic25Id 39168 to a custom encore template, change a 5-man boss from Boss to MiniBoss kind, route a new world boss through the WorldBoss kind), re-import to a byte-identical binary. The exporter emits both spawnGroupKind (int 0..5) and the human- readable spawnGroupKindName ("boss" / "mini-boss" / "rare-elite" / "trash" / "add" / "world-boss"); the importer accepts either form. Verified byte-identical round-trip on all three presets (starter / wotlk / fiveman). CLI flag count 941 -> 943.
2026-05-09 22:11:16 -07:00
"--export-wcdf-json", "--import-wcdf-json",
feat(editor): add WMAT (Item Material) open catalog format Open replacement for Blizzard's Material.dbc plus the Material and SheatheType fields in ItemDisplayInfo.dbc. Defines the material categorization that items reference (Cloth / Leather / Mail / Plate / Wood / Steel / Crystal / Ethereal / etc), each with its own foley sound (played on item use), impact sound (played on drop / hit), weight category, and material-property flags (IsBreakable / IsMagical / IsFlammable / IsConductive / IsHolyCharged / IsCursed). The engine plays a sword's metallic clang from impactSoundId when it hits a stone wall, but a cloth tabard makes no such sound — the difference is exactly the material assigned by this catalog. Every armor and weapon item in WIT references a materialId here. Twelve materialKind values cover the standard armor classes (Cloth/Leather/Mail/Plate/Hide), structural materials (Wood / Stone / Metal), and special categories (Liquid / Organic / Crystal / Ethereal). Three weight tiers (Light / Medium / Heavy) control encumbrance UI hints. Cross-references back to WSND (foleySoundId / impactSoundId reference WSND sound entries) and forward to WIT (item entries reference materialId here). Three preset emitters: --gen-mat (5 armor materials matching WoW's armor classes), --gen-mat-weapon (5 weapon materials from breakable+flammable Wood through enchanted endgame steel), --gen-mat-magical (4 magical materials with special flags including the IsHolyCharged anti-undead property). Validation enforces id+name presence, materialKind 0..11, weightCategory 0..2, no duplicate ids; warns on: - IsHolyCharged + IsCursed both set (engine picks one, typically IsCursed wins) - Plate kind that's not Heavy weight (canonical violation) - Cloth kind that's not Light weight (canonical violation) Wired through the cross-format table; WMAT appears automatically in all 11 cross-format utilities. Format count 75 -> 76; CLI flag count 943 -> 948.
2026-05-09 22:14:44 -07:00
"--gen-mat", "--gen-mat-weapon", "--gen-mat-magical",
"--info-wmat", "--validate-wmat",
feat(editor): add WMAT JSON round-trip (--export/--import-wmat-json) Closes the editing loop on the item-material catalog: dump a .wmat to JSON, hand-edit materialKind / weightCategory / foley / impact sound bindings / material flags (e.g. swap a Hide entry from Light to Medium weight, add IsBreakable to a wooden bow, re-bind Plate's foley to a different WSND entry, mark a new HolyForged variant), re-import to a byte-identical binary. Three different field types each take dual int+name forms: - materialKind: int 0..11 OR "cloth"/"leather"/"mail"/"plate"/ "wood"/"stone"/"metal"/"liquid"/"organic"/"crystal"/ "ethereal"/"hide" - weightCategory: int 0..2 OR "light"/"medium"/"heavy" - materialFlags: int bitfield OR pipe-separated label string ("IsMagical|IsBreakable|IsHolyCharged"). Importer prefers int form when both present so unknown bits round-trip losslessly. Verified byte-identical round-trip on all three presets (armor / weapon / magical). CLI flag count 948 -> 950.
2026-05-09 22:16:13 -07:00
"--export-wmat-json", "--import-wmat-json",
feat(editor): add WPSP (Player Spawn Profile) open catalog format Open replacement for AzerothCore's playercreateinfo SQL table plus the per-class/race starting fields in CharStartOutfit.dbc. Defines the initial state for a newly created character: starting map / zone / position / facing, bind point (Hearthstone destination), up to 4 starting items with counts, and up to 4 starting spells. One entry per (race, class) combination — a Human Warrior spawns at Northshire Abbey with a Worn Shortsword and Heroic Strike already learned, while an Orc Hunter spawns in Valley of Trials with Aimed Shot and a starter rifle. Death Knights have their own preset spawning at lvl 55 in Acherus, the Ebon Hold. The race+class fields are bitmasks (mirroring WCHC layout) so one profile entry can cover multiple class/race combinations that share starting state. findByRaceClass(raceBit, classBit) is the engine helper used by character creation. Cross-references back to WCHC (race/class bit layouts), WMS (map ids), WIT (starting item ids), and WSPL (starting spell ids). Three preset emitters: --gen-psp (5 Alliance combos covering each starting zone from Northshire to Ammen Vale), --gen-psp-horde (5 Horde combos from Valley of Trials to Sunstrider Isle), --gen-psp-dk (2 DK combos at lvl 55 in Acherus with Death Coil / Plague Strike / Death Grip starter loadout). Validation enforces id+name+race+class+startingLevel presence, no duplicate ids; warns on (0,0,0) spawn (uninitialized entry), item id/count mismatch (granted item without count or vice versa), startingLevel > 80 (above WotLK cap), and Death Knight class with startingLevel < 55 (DKs canonically start at 55). Wired through the cross-format table; WPSP appears automatically in all 12 cross-format utilities. Format count 76 -> 77; CLI flag count 951 -> 956.
2026-05-09 22:22:57 -07:00
"--gen-psp", "--gen-psp-horde", "--gen-psp-dk",
"--info-wpsp", "--validate-wpsp",
feat(editor): add WPSP JSON round-trip (--export/--import-wpsp-json) Closes the editing loop on the player-spawn-profile catalog: dump a .wpsp to JSON, hand-edit raceMask / classMask / spawn coords / bind point / starting items + counts / starting spell ids (e.g. move Northshire's spawn coords, swap a Hunter's starter weapon, give every Warrior a Hearthstone, retune a DK's spell loadout to include Frost Strike), re-import to a byte-identical binary. Verified byte-identical round-trip on all three presets (alliance / horde / dk). CLI flag count 956 -> 958.
2026-05-09 22:24:19 -07:00
"--export-wpsp-json", "--import-wpsp-json",
feat(editor): add WTLE (Talent Tab) open catalog format Open replacement for Blizzard's TalentTab.dbc plus the per-tab fields in Spell.dbc / Talent.dbc. Defines the three talent trees that each class has — Warrior: Arms / Fury / Protection; Mage: Arcane / Fire / Frost; Paladin: Holy / Protection / Retribution; etc. Each tab carries its own name, role hint (DPS / Tank / Healer / Hybrid / PetClass), display order in the talent UI, background artwork path (e.g. "WarriorArms" for the parchment background), icon path, and the class bitmask it belongs to. Distinct from WTAL (which defines individual talent points) — WTLE says "the Arms tree exists for Warriors, displays in tab 1, is a DPS spec"; WTAL says "Mortal Strike is a 1-point talent in the Arms tree, row 7, requires Improved Charge as a prerequisite". Cross-references back to WCHC (classMask uses the same bit layout) and forward to WTAL (talent entries reference tabId here). findByClass(classBit) returns all tabs for a class sorted by displayOrder — the talent UI uses this directly to populate its tab buttons. Three preset emitters: --gen-tle (Warrior 3 tabs with two DPS + one Tank), --gen-tle-mage (Mage 3 DPS tabs), --gen-tle-paladin (Paladin 3 tabs covering all three roles in one preset). Validation enforces id+name+classMask presence (classMask=0 means no class can use the tab — usually a config bug), roleHint 0..4, no duplicate ids; warns on empty iconPath (missing-texture render), empty backgroundFile (no panel art), displayOrder>3 (UI shows at most 4 tabs), and (classMask + displayOrder) collisions for overlapping classes (two tabs claiming the same UI slot for the same class). Wired through the cross-format table; WTLE appears automatically in all 12 cross-format utilities. Format count 77 -> 78; CLI flag count 958 -> 963.
2026-05-09 22:27:18 -07:00
"--gen-tle", "--gen-tle-mage", "--gen-tle-paladin",
"--info-wtle", "--validate-wtle",
feat(editor): add WTLE JSON round-trip (--export/--import-wtle-json) Closes the editing loop on the talent-tab catalog: dump a .wtle to JSON, hand-edit roleHint / classMask / displayOrder / iconPath / backgroundFile (e.g. swap a Mage Frost tab from DPS to Hybrid, point Holy Paladin's tab to a custom background art file, reorder displayOrder to put Protection first), re-import to a byte-identical binary. The exporter emits both roleHint (int 0..4) and the human- readable roleHintName ("dps" / "tank" / "healer" / "hybrid" / "pet"); the importer accepts either form. Verified byte-identical round-trip on all three presets (warrior / mage / paladin). CLI flag count 963 -> 965.
2026-05-09 22:28:28 -07:00
"--export-wtle-json", "--import-wtle-json",
feat(editor): add WCTR (Currency Type) open catalog format Open replacement for Blizzard's CurrencyTypes.dbc plus the per-currency cap tables in CurrencyCategory.dbc. Defines the in-game currencies that are NOT regular item stacks: Honor Points, Arena Points, Justice Points, Valor Points, Conquest Points, plus the various faction tokens (Champion's Seal, Wintergrasp Mark of Honor, Emblem of Frost). Distinct from regular items in WIT — currencies are tracked per-character as scalar quantities with weekly + absolute caps, not as stackable inventory slots. Some currencies are still backed by a WIT item entry for the icon and tooltip text (itemId field), while others (Honor, Arena) live entirely in the currency system. The cap model captures both shapes: - maxQuantity = absolute lifetime cap (Honor Points 75k) - maxQuantityWeekly = weekly earn cap, no absolute cap (Conquest Points 1650/wk) - both 0 = uncapped (faction tokens, Emblem of Frost) earnableNow(id, current, weekly) is the engine helper that returns the smaller of (remaining absolute, remaining weekly). Cross-references back to WIT (itemId for tooltip art) and WFAC (categoryId references factionId for FactionToken kind — the rep gate that lets you spend the token). Three preset emitters: --gen-ctr (4 PvP currencies covering absolute, weekly-only, and uncapped tiers), --gen-ctr-pve (4 PvE raid currencies with same cap variety), --gen-ctr-faction (4 faction tokens with their categoryId pointing at WFAC faction ids). Validation enforces id+name presence, currencyKind 0..5, no duplicate ids; warns on: - maxQuantityWeekly > maxQuantity (weekly cap will never be reached, absolute cap blocks first) - FactionToken kind with categoryId=0 (rep gate breaks) - no caps + no itemId + no iconPath (currency has no display data and unbounded earn rate) Wired through the cross-format table; WCTR appears automatically in all 12 cross-format utilities. Format count 78 -> 79; CLI flag count 965 -> 970.
2026-05-09 22:31:42 -07:00
"--gen-ctr", "--gen-ctr-pve", "--gen-ctr-faction",
"--info-wctr", "--validate-wctr",
feat(editor): add WCTR JSON round-trip (--export/--import-wctr-json) Closes the editing loop on the currency-type catalog: dump a .wctr to JSON, hand-edit currencyKind / cap values / categoryId / isAccountWide / iconPath (e.g. raise Conquest Points weekly cap from 1650 to 2200, retag a server-custom currency from Misc to FactionToken kind, mark Honor Points as account-wide for a casual server), re-import to a byte-identical binary. The exporter emits both currencyKind (int 0..5) and the human- readable currencyKindName ("pvp-honor" / "pve-raid" / "faction-token" / "event-token" / "crafting" / "misc"); the importer accepts either form. isAccountWide round-trips as a JSON bool but accepts int as well so machine-generated sidecars work too. Verified byte-identical round-trip on all three presets (pvp / pve / faction). CLI flag count 970 -> 972.
2026-05-09 22:33:12 -07:00
"--export-wctr-json", "--import-wctr-json",
feat(editor): add WSPR (Spell Reagent) — 80th open format milestone Open replacement for the per-spell reagent fields in Spell.dbc (Reagent[8] + ReagentCount[8]). Defines the item reagents that a spell consumes from the caster's inventory each time it's cast — Mage Portal needs a Rune of Portals, Resurrection needs a Holy Candle (focused, not consumed), Warlock summons consume Soul Shards. One entry per reagent-using spell — most spells have no reagents and are absent from this catalog. Each entry can list up to 8 (itemId, count) pairs which all must be present for the spell to cast. Five reagentKind values capture the variety of reagent semantics: - Standard — ordinary consumed reagent - SoulShard — warlock-specific shard tracking - FocusedItem — required to cast but NOT consumed (Symbol of Divinity for Resurrection) - Catalyst — enables a stronger version of the spell - Tradeable — crafting reagent for trade-skill recipes Cross-references back to WSPL (every entry references a spellId) and WIT (every reagent itemId references an item entry). findBySpell(spellId) is the primary engine lookup. Three preset emitters: --gen-spr (4 mage portal/teleport reagents using Rune of Teleportation 17031), --gen-spr-warlock (4 demon summons each consuming 1 Soul Shard 6265), --gen-spr-rez (3 resurrection variants demonstrating each ReagentKind including a no-reagent Druid Rebirth and a focused-item Priest Resurrection). Validation enforces id+name+spellId presence, reagentKind 0..4, no duplicate ids; warns on: - slot itemId/count mismatch (id without count or vice versa) - SoulShard kind with non-canonical reagent (not item 6265) - FocusedItem kind with no reagent slots set (focused-item gating has nothing to gate) - duplicate spellId across entries (engine honors only first) This is the 80th open format milestone. Wired through the cross-format table; WSPR appears automatically in all 14 cross-format utilities. Format count 79 -> 80; CLI flag count 974 -> 979.
2026-05-09 22:38:36 -07:00
"--gen-spr", "--gen-spr-warlock", "--gen-spr-rez",
"--info-wspr", "--validate-wspr",
feat(editor): add WSPR JSON round-trip (--export/--import-wspr-json) Closes the editing loop on the spell-reagent catalog: dump a .wspr to JSON, hand-edit reagentKind / spellId / per-slot itemId+count pairs (e.g. swap a Mage Portal's reagent from Rune of Portals to a server-custom item, change a Warlock summon to need 2 Soul Shards instead of 1, add Tier-3 Catalyst entries for upgraded spell variants), re-import to a byte-identical binary. Reagent slot arrays (8 itemIds, 8 counts) are exported as JSON arrays — easier to read and edit than 16 individual numbered fields. Importer pads arrays shorter than 8 with zeros and silently truncates longer arrays, so hand-edited sidecars don't need to spell out every empty slot. The exporter emits both reagentKind (int 0..4) and the human- readable reagentKindName ("standard" / "soul-shard" / "focused-item" / "catalyst" / "tradeable"); the importer accepts either form. Verified byte-identical round-trip on all three presets (mage / warlock / rez). CLI flag count 979 -> 981.
2026-05-09 22:40:12 -07:00
"--export-wspr-json", "--import-wspr-json",
feat(editor): add WACR (Achievement Criteria) open catalog format Open replacement for Blizzard's Achievement_Criteria.dbc. Defines the individual progression criteria that a character must complete to earn an achievement. Each WACH achievement has a tree of WACR criteria — "Kill 100 boars" is one criteria entry with criteriaType=KillCreature, targetId=boarCreatureId, requiredCount=100. Multi-criteria achievements (e.g. "Visit all 3 capital cities") have one entry per sub-objective, all referencing the same achievementId, with progressOrder determining their display sequence in the achievement UI. Thirteen criteriaType values cover the full progression variety: KillCreature / ReachLevel / CompleteQuest / EarnGold / GainHonor / EarnReputation / ExploreZone / LootItem / UseItem / CastSpell / PvPKill / DungeonRun / Misc The targetId field is type-polymorphic — for KillCreature it references WCRT.creatureId, for CompleteQuest it references WQT.questId, for ExploreZone it's a WMS.zoneId, etc. The engine interprets it based on criteriaType. Cross-references back to WACH (achievementId), WCRT (KillCreature.targetId), WQT (CompleteQuest.targetId), WIT (LootItem/UseItem.targetId), WMS (ExploreZone.targetId), WSPL (CastSpell.targetId). findByAchievement(achId) returns all criteria for an achievement sorted by progressOrder — used directly by the achievement UI to render the progress checklist. Three preset emitters: --gen-acr (5 kill criteria under one composite achievement showing different creature targets), --gen-acr-quest (4-step quest progression), --gen-acr-mixed (5 cross-type criteria demonstrating the full CriteriaType variety). Validation enforces id+name+achievementId presence, criteriaType 0..12, no duplicate ids; warns on: - missing targetId for type-specific kinds (KillCreature, CompleteQuest, etc. — engine cannot track without it) - ReachLevel with requiredCount > 80 (above WotLK cap) - timeLimitMs set on non-time-sensitive types (engine ignores it for ReachLevel / EarnGold) - requiredCount=0 (criteria completes instantly on first progress event — usually a misconfig) Wired through the cross-format table; WACR appears automatically in all 14 cross-format utilities. Format count 80 -> 81; CLI flag count 981 -> 986.
2026-05-09 22:43:44 -07:00
"--gen-acr", "--gen-acr-quest", "--gen-acr-mixed",
"--info-wacr", "--validate-wacr",
feat(editor): add WACR JSON round-trip (--export/--import-wacr-json) Closes the editing loop on the achievement-criteria catalog: dump a .wacr to JSON, hand-edit criteriaType / targetId / requiredCount / timeLimitMs / progressOrder (e.g. retune a kill-count from 50 boars to 25, swap a quest progression target, add a time limit to turn a normal achievement into a speedrun, reorder progressOrder so the easiest sub-objective shows first in the UI), re-import to a byte-identical binary. The exporter emits both criteriaType (int 0..12) and the human- readable criteriaTypeName ("kill-creature" / "reach-level" / "complete-quest" / "earn-gold" / "gain-honor" / "earn-reputation" / "explore-zone" / "loot-item" / "use-item" / "cast-spell" / "pvp-kill" / "dungeon-run" / "misc"); the importer accepts either form. The 13-way enum is the largest single-field dual-encoding implemented so far in any catalog round-trip. Verified byte-identical round-trip on all three presets (kill / quest / mixed). CLI flag count 986 -> 988.
2026-05-09 22:45:02 -07:00
"--export-wacr-json", "--import-wacr-json",
feat(editor): add WSEF (Spell Effect Type) open catalog format Open replacement for the SpellEffect.Effect field meanings in Spell.dbc plus the engine's hard-coded effect dispatch table. Defines what each spell-effect integer value actually does — SCHOOL_DAMAGE=2 deals magical damage, DUMMY=3 is a script hook, HEAL=10 restores health, ENERGIZE=30 restores power, APPLY_AURA=6 attaches a buff/debuff, etc. WotLK's Spell.dbc has 192+ effect type integers, each with its own resolver in the spell engine. This catalog lets the engine look up "given effect=10, what resolution behavior do I run?" via a single table lookup instead of a hard-coded switch statement, and lets server-custom spells reference new effect IDs without touching engine code. Ten effectKind values capture the major behavior families (Damage / Heal / Aura / Energize / Trigger / Movement / Summon / Dispel / Dummy / Misc), and a 6-bit behaviorFlags field captures targeting/gating semantics: - RequiresTarget — must have a target - RequiresLineOfSight — LoS check on target - IsHostileEffect — hostile only (PvP gating) - IsBeneficialEffect — friendly only - IgnoresImmunities — bypasses Bubble / IBF / etc - TriggersGCD — counts toward GCD Distinct from WAUR (Spell Aura Type, future format) which is the secondary classification used when effectType is APPLY_AURA. The two together cover the full spell-effect classification space. Three preset emitters: --gen-sef (5 damage effects covering typical Spell.dbc damage IDs), --gen-sef-healing (4 heal effects all flagged IsBeneficialEffect), --gen-sef-aura (5 aura-application effects covering single-target / pet / party-wide / area variants). Validation enforces name presence, effectKind 0..9, no duplicate ids; warns on: - both Hostile and Beneficial flags set (engine picks Hostile, contradiction suggests config bug) - Damage kind without TriggersGCD (most damage should be on GCD — env damage is the canonical exception) - Heal kind without IsBeneficialEffect (engine treats heal as ungated, may damage enemies) Wired through the cross-format table; WSEF appears automatically in all 15 cross-format utilities. Format count 81 -> 82; CLI flag count 989 -> 994.
2026-05-09 22:50:13 -07:00
"--gen-sef", "--gen-sef-healing", "--gen-sef-aura",
"--info-wsef", "--validate-wsef",
feat(editor): add WSEF JSON round-trip (--export/--import-wsef-json) Closes the editing loop on the spell-effect-type catalog: dump a .wsef to JSON, hand-edit effectKind / behaviorFlags / baseAmount (e.g. tag a server-custom effect ID as Damage kind, add IgnoresImmunities to a custom dispel, retune ScriptedHeal's default baseAmount), re-import to a byte-identical binary. Two dual-encoded fields: - effectKind: int 0..9 OR "damage" / "heal" / "aura" / "energize" / "trigger" / "movement" / "summon" / "dispel" / "dummy" / "misc" - behaviorFlags: int bitfield OR pipe-separated label string ("RequiresTarget|IsHostileEffect|TriggersGCD"). Importer prefers int form when both present so unknown bits round- trip losslessly. Verified byte-identical round-trip on all three presets (damage / healing / aura). CLI flag count 994 -> 996.
2026-05-09 22:51:40 -07:00
"--export-wsef-json", "--import-wsef-json",
feat(editor): add WAUR (Spell Aura Type) — companion to WSEF, CLI flag count breaks 1000 Open replacement for the SpellEffect.EffectAuraType field meanings used when SpellEffect.Effect=APPLY_AURA. Defines what each aura-type integer value actually does once an aura is attached to a unit — PERIODIC_DAMAGE ticks damage every N seconds, MOD_STAT adds a stat bonus, MOD_INCREASE_SPEED scales movement, MOD_DAMAGE_PERCENT_DONE scales spell power, etc. Companion to WSEF — together they cover the full spell-effect classification space: WSEF: outer effect ID — what does the effect DO? (APPLY_AURA, SCHOOL_DAMAGE, HEAL, etc) WAUR: inner aura type — when WSEF=APPLY_AURA, what KIND of aura is applied? (PERIODIC_DAMAGE, MOD_STAT, STUN, ROOT, etc) Nine auraKind values (Periodic / StatMod / DamageMod / Movement / Visual / Trigger / Resource / Control / Misc) classify the major behavior families. Periodic auras carry an updateFrequencyMs (canonical 3s for DoT/HoT, 2s for energize, 1s for fast triggers). Stackable auras carry a maxStackCount. Cross-references back to WSEF (this catalog is the secondary classification that WSEF entry id 6 (APPLY_AURA) dispatches into) and forward to WSPL (spell entries with effect=APPLY_AURA reference an auraTypeId here). Three preset emitters: --gen-aur (5 periodic auras with canonical tick intervals), --gen-aur-stats (5 stat-modifier auras instantly applied on attach), --gen-aur-movement (4 movement-impairing CC auras typical of crowd-control spells). Validation enforces name presence, auraKind 0..8, targetingHint 0..3, no duplicate ids; errors on Periodic kind without updateFrequencyMs (would never tick); warns on: - non-Periodic/Trigger kinds with updateFrequencyMs > 0 (engine ignores tick interval) - maxStackCount > 0 with isStackable=false (cap unreachable) Wired through the cross-format table; WAUR appears automatically in all 15 cross-format utilities. Format count 82 -> 83; CLI flag count 996 -> 1001 — broke the 1000-flag mark.
2026-05-09 22:54:53 -07:00
"--gen-aur", "--gen-aur-stats", "--gen-aur-movement",
"--info-waur", "--validate-waur",
feat(editor): add WAUR JSON round-trip (--export/--import-waur-json) Closes the editing loop on the spell-aura-type catalog: dump a .waur to JSON, hand-edit auraKind / targetingHint / tick interval / stack rules (e.g. retune PeriodicDamage from 3000ms to 2500ms ticks for a faster server, mark a custom aura as HostileOnly+stackable up to 10, switch a server-custom DoT from StatMod to Periodic kind), re-import to a byte-identical binary. Three dual-encoded fields: - auraKind: int 0..8 OR "periodic" / "stat-mod" / "damage-mod" / "movement" / "visual" / "trigger" / "resource" / "control" / "misc" - targetingHint: int 0..3 OR "any" / "self" / "hostile" / "beneficial" - isStackable: bool OR int (machine-generated sidecars work too) Verified byte-identical round-trip on all three presets (periodic / stats / movement). CLI flag count 1001 -> 1003.
2026-05-09 22:56:20 -07:00
"--export-waur-json", "--import-waur-json",
feat(editor): add WIQR (Item Quality) open catalog format Open replacement for the hardcoded item quality tiers in the WoW client (Poor / Common / Uncommon / Rare / Epic / Legendary / Artifact / Heirloom). Defines each tier's tooltip text color, inventory slot border color, vendor price multiplier, drop-level gating, and disenchant eligibility. The hardcoded client uses a fixed color table (gray/white/green/ blue/purple/orange/red/gold). This catalog lets server admins: - retune the colors (rename "Epic" to "Tier 1" with custom hex) - add server-custom tiers above Heirloom - change vendor markup per tier (legendary 50x base price) - gate quality drops by character level (Heirlooms unlock 80) The standard preset reproduces the canonical 8-tier scale with exact hex values from the live client (#9d9d9d through #00ccff) and standard disenchant rules (Common+ disenchantable, Legendary and Artifact aren't). The server-custom preset shows 4 tiers above the standard range with non-standard pricing (Junk 0.1x, QuestLocked 0.0x unsellable). The raid preset gates 4 progression tiers behind minLevelToDrop=60 with escalating vendor multipliers up to 50x for Legendary. Cross-references back to WIT — item entries reference qualityId here for tooltip color and sort order. canDropAtLevel(id, lvl) is the engine helper used by loot generation. Validation enforces name presence, no duplicate ids, vendorPriceMultiplier >= 0, minLevelToDrop <= maxLevelToDrop; warns on: - minLevelToDrop > 80 (unreachable at WotLK cap) - vendorPriceMultiplier > 100x (sanity check the economy) - nameColorRGBA with alpha=0 (text would be invisible in tooltips — common bug when copy-pasting RGB hex without alpha byte) Wired through the cross-format table; WIQR appears automatically in all 15 cross-format utilities. Format count 83 -> 84; CLI flag count 1003 -> 1008.
2026-05-09 22:59:27 -07:00
"--gen-iqr", "--gen-iqr-server", "--gen-iqr-raid",
"--info-wiqr", "--validate-wiqr",
feat(editor): add WIQR JSON round-trip (--export/--import-wiqr-json) Closes the editing loop on the item-quality catalog: dump a .wiqr to JSON, hand-edit color hex / vendor multiplier / level gates / disenchant flag / border texture path (e.g. retune Epic purple from #a335ee to #c33fff for a brighter look, raise Heirloom unlock from lvl 80 to 85, mark Legendary as disenchantable, swap a server-custom tier's border texture), re-import to a byte-identical binary. The colors export as raw RGBA uint32 — direct pasting of 0xAARRGGBB hex values without conversion. canBeDisenchanted round-trips as a JSON bool but accepts int as well so machine- generated sidecars work too. Verified byte-identical round-trip on all three presets (std / srv / raid). CLI flag count 1008 -> 1010.
2026-05-09 23:00:32 -07:00
"--export-wiqr-json", "--import-wiqr-json",
feat(editor): add WSCS (Skill Cost) open catalog format Open replacement for Blizzard's SkillCostsData.dbc plus the per-rank training cost tables. Defines the tiered progression of trainable skills: each rank unlocks a skill range, requires a minimum character level, and costs a fixed amount of gold to learn. The canonical 6-tier profession progression captured by the default preset: Apprentice skill 0-75 lvl 5 1s Journeyman skill 50-150 lvl 10 5s Expert skill 125-225 lvl 20 1g Artisan skill 200-300 lvl 35 5g Master skill 275-375 lvl 50 10g Grand Master skill 350-450 lvl 65 25g Same shape applies to weapon skills (free, level-gated, capped at 5x char level) and riding skills (canonical Vanilla / TBC / WotLK gold costs from 90g Apprentice through 5000g Artisan flying down to 1000g Cold Weather Flying). Five costKind values cover the full training-skill space (Profession / WeaponSkill / RidingSkill / ClassSkill / Misc). Each entry's copperCost stores the cost in copper (1g = 10000c) which the info renderer pretty-prints as "25g 0s 0c". Cross-references back to WSKL — skill entries reference costId here for the tiered training schedule. nextTrainable(currentSkill, characterLevel) is the engine helper that returns the lowest-rank tier a character qualifies for and hasn't capped yet — used by trainer NPCs to populate their offered-skill list. Three preset emitters: --gen-scs (6 profession tiers), --gen-scs- weapon (5 weapon skill tiers), --gen-scs-riding (5 riding tiers with canonical gold costs). Validation enforces id+name presence, costKind 0..4, no duplicate ids, min<max range; warns on: - requiredLevel > 80 (unreachable at WotLK cap) - RidingSkill with requiredLevel < 20 (Apprentice canonically unlocks at 20) - Profession kind with copperCost=0 (every standard tier costs at least a copper — usually a config bug) Wired through the cross-format table; WSCS appears automatically in all 15 cross-format utilities. Format count 84 -> 85; CLI flag count 1010 -> 1015.
2026-05-09 23:04:02 -07:00
"--gen-scs", "--gen-scs-weapon", "--gen-scs-riding",
"--info-wscs", "--validate-wscs",
feat(editor): add WSCS JSON round-trip (--export/--import-wscs-json) Closes the editing loop on the skill-cost catalog: dump a .wscs to JSON, hand-edit costKind / skill ranges / requiredLevel / copperCost (e.g. retune Apprentice profession from 1s to 5s for a faster server, raise Cold Weather Flying from lvl 77 to 75, add a custom WeaponSkill tier above Master), re-import to a byte-identical binary. The exporter emits both costKind (int 0..4) and the human- readable costKindName ("profession" / "weapon" / "riding" / "class-skill" / "misc"); the importer accepts either form. Verified byte-identical round-trip on all three presets (prof / weapon / riding). CLI flag count 1015 -> 1017.
2026-05-09 23:05:23 -07:00
"--export-wscs-json", "--import-wscs-json",
feat(editor): add WIFS (Item Flag Set) open catalog format Open replacement for the bit-flag meanings used in Item.dbc / item_template.Flags. Documents every individual bit of the 32-bit item flags field with a human-readable name, description, kind classification, and is-positive hint. WoW's Item.dbc Flags field packs ~25 bits of metadata like Heroic, Lootable, NoLoot, Conjured, BindOnPickup, BindOnEquip — each controlling a specific gameplay behavior. The hardcoded client knows what each bit means via a switch statement; this catalog exposes that table to data-driven editors so: - server admins can document custom flag bits - tooltip generators can decode "why is this item soulbound?" via flag-name lookup (decode(0x40240000) returns ["Heroic", "BindOnPickup", "Unique"]) - validators can warn about contradictory flag combinations Seven flagKind values classify the bit families (Quality / Drop / Trade / Magic / Account / Server / Misc), and an isPositive hint tells UIs whether the flag enhances the item (green) or restricts it (red). Cross-references back to WIT (decodes WIT.flags into the matching named flag list) and WIQR (validators can pair Heroic flag with WIQR Epic+ quality requirement). Three preset emitters: --gen-ifs (8 canonical Item.dbc bits matching the standard 3.3.5a constants), --gen-ifs-binding (5 binding-related flags BindOnPickup / BindOnEquip / etc — all restrictive so isPositive=0), --gen-ifs-server (5 server-custom bits in the upper range demonstrating how to overlay extra metadata without colliding with Blizzard's bits). Validation enforces id+name+bitMask presence, flagKind 0..6, no duplicate ids, no duplicate bitMasks (collision means engine would only honor first matching name when decoding); warns on multi-bit masks (unusual — usually want individual bits). decode(flagsValue) is the engine helper that expands a raw flags integer into its named flag list — used directly by the tooltip generator and item info renderers. Wired through the cross-format table; WIFS appears automatically in all 16 cross-format utilities. Format count 85 -> 86; CLI flag count 1018 -> 1023.
2026-05-09 23:10:35 -07:00
"--gen-ifs", "--gen-ifs-binding", "--gen-ifs-server",
"--info-wifs", "--validate-wifs",
feat(editor): add WIFS JSON round-trip (--export/--import-wifs-json) Closes the editing loop on the item-flag bit catalog: dump a .wifs to JSON, hand-edit bitMask hex / flagKind / isPositive (e.g. add a server-custom Heroic25man flag at bit 0x10000000, re-tag NoLoot from Drop kind to Quality kind, mark BindToAccount as positive for an account-wide-loot server), re-import to a byte-identical binary. Two dual-encoded fields: - flagKind: int 0..6 OR "quality" / "drop" / "trade" / "magic" / "account" / "server" / "misc" - isPositive: bool OR int (machine-generated sidecars work too) Hex bitMasks export as raw uint32 — pasting "0x40000000" hex values into JSON works directly. Verified byte-identical round-trip on all three presets (std / bind / srv). CLI flag count 1023 -> 1025.
2026-05-09 23:12:01 -07:00
"--export-wifs-json", "--import-wifs-json",
feat(editor): add WBKD (NPC Service Definition) open catalog format Open replacement for AzerothCore's npc_vendor / npc_trainer / npc_gossip / npc_options SQL tables plus the engine's hard-coded service-type dispatch. Defines the kinds of services NPCs can offer (Banker / Mailbox / Auctioneer / StableMaster / FlightMaster / Trainer / Innkeeper / Battlemaster / GuildBanker / ReagentVendor / TabardVendor / Misc) and the per-service metadata (gold cost, faction gating, gossip text id). When a player right-clicks an NPC, the engine looks at the NPC's serviceId list (from WCRT.npcFlags or equivalent) and dispatches to the appropriate service-frame handler — Banker opens the inventory expansion frame, Auctioneer opens the auction house, StableMaster opens the pet stable. This catalog defines what each service actually does and what preconditions it requires. Cross-references back to WCRT (creature.npcFlags decodes into a list of service ids defined here), WFAC (factionRequiredId references factionId for rep-gated services like Argent Tournament), and WGSP (gossipTextId references menuId for the "How can I help you?" dialogue line). Three preset emitters: --gen-bkd (5 city services typical of a capital city), --gen-bkd-battle (3 battlemaster services for each Vanilla BG queue), --gen-bkd-profession (4 profession services). findByKind(kind) is the engine helper used by NPC spawning to find e.g. all FlightMaster services configured for a server. Validation enforces id+name presence, serviceKind 0..11, no duplicate ids; warns on: - Mailbox kind with non-zero gossipTextId (mailboxes are gameobject services with no NPC dialogue; gossip won't show) - Innkeeper kind with gossipTextId=0 (no welcome/bind dialog; will silently bind the hearthstone) - Battlemaster kind with non-zero requiresGold (battle queue services are typically free) Wired through the cross-format table; WBKD appears automatically in all 16 cross-format utilities. Format count 86 -> 87; CLI flag count 1025 -> 1030.
2026-05-09 23:15:20 -07:00
"--gen-bkd", "--gen-bkd-battle", "--gen-bkd-profession",
"--info-wbkd", "--validate-wbkd",
feat(editor): add WBKD JSON round-trip (--export/--import-wbkd-json) Closes the editing loop on the NPC service catalog: dump a .wbkd to JSON, hand-edit serviceKind / requiresGold / factionRequiredId / gossipTextId (e.g. retag a city-mail NPC from Mailbox kind to GuildBanker, raise stable master cost from 1s to 5s, gate an auctioneer behind faction rep), re-import to a byte-identical binary. The exporter emits both serviceKind (int 0..11) and the human- readable serviceKindName ("banker" / "mailbox" / "auctioneer" / "stable-master" / "flight-master" / "trainer" / "innkeeper" / "battlemaster" / "guild-banker" / "reagent-vendor" / "tabard-vendor" / "misc"); the importer accepts either form. Verified byte-identical round-trip on all three presets (city / battle / prof). CLI flag count 1030 -> 1032.
2026-05-09 23:16:32 -07:00
"--export-wbkd-json", "--import-wbkd-json",
feat(editor): add WTBR (Token Reward) open catalog format Open replacement for AzerothCore's currency_token_reward SQL table plus the per-vendor token redemption rows in npc_vendor. Each entry says "spend N copies of token X to receive reward Y", with reward type polymorphism: Y can be an item, a spell (taught to the character), a title, a mount, a companion pet, a currency conversion, an heirloom unlock, or a cosmetic (tabard / pennant / fluff). The rewardId field's interpretation depends on the rewardKind enum. Distinct from WTKN (Token catalog) which defines the token currency items themselves. WTKN says "the Champion's Seal exists as item 44990"; WTBR says "spend 25 Champion's Seals at Argent Tournament for the Squire's Belt (item 45517)". Eight rewardKind values cover the full reward space (Item / Spell / Title / Mount / Pet / Currency / Heirloom / Cosmetic), and an 8-tier requiredFactionStanding gates by reputation (Hated / Hostile / Unfriendly / Neutral / Friendly / Honored / Revered / Exalted) when paired with a non-zero requiredFactionId. Cross-references back to WTKN (spentTokenItemId), WIT (Item rewards), WSPL (Spell rewards), WTIT (Title rewards), WMOU (Mount rewards), WCMP (Pet rewards), WCTR (Currency conversion rewards), and WFAC (faction-rep gating). findByToken(itemId) is the engine helper used by vendor frames to populate the "what can I buy with these?" list. Three preset emitters: --gen-tbr (5 raid tier-token redemptions consuming Trophy of the Crusade and Emblem of Frost), --gen-tbr-pvp (5 PvP rewards spanning honor / arena / conquest plus title and tabard kinds), --gen-tbr-faction (5 faction- gated rewards demonstrating each standing tier from Honored through Exalted). Validation enforces id+name+spentTokenItemId+spentTokenCount presence, rewardKind 0..7, requiredFactionStanding 0..7, no duplicate ids; warns on: - rewardId=0 (no actual reward, vendor offers entry but grants nothing) - requiredFactionStanding > Neutral with requiredFactionId=0 (rep gate has no faction to check) - Currency conversion item -> itself (typo / config bug) Wired through the cross-format table; WTBR appears automatically in all 18 cross-format utilities. Format count 87 -> 88; CLI flag count 1034 -> 1039.
2026-05-09 23:26:13 -07:00
"--gen-tbr", "--gen-tbr-pvp", "--gen-tbr-faction",
"--info-wtbr", "--validate-wtbr",
feat(editor): add --validate-wow weather schedule audit Mirrors --validate-wol but for the .wow weather format. Walks every entry and reports structural problems: • unknown weather typeId (above the Blizzard sentinel) • intensity bounds outside [0, 1] or min > max • non-positive weight (would zero a row in weighted-random selection and warp probabilities) • zero or inverted duration bounds • non-finite floats Returns exit code 0 on PASS / 1 on FAIL — CI-friendly. JSON output via --json for tooling. All four built-in presets (--gen-weather-temperate / arctic / desert / stormy) validate clean. The WOW format now has parity with WOL on the inspect/validate front: WOL: --info-wol / --info-wol-at / --validate-wol WOW: --info-wow / --validate-wow Milestone: kArgRequired now at 440 documented flags.
2026-05-09 14:13:30 -07:00
"--gen-weather-temperate", "--gen-weather-arctic",
feat(pipeline): add Wowee Open Weather (.wow) zone schedule 8th open-format addition to the Wowee pipeline. Replaces WoW's WeatherTypes.dbc / WeatherEffect logic with a single binary file holding a list of weather states for one zone, each tagged with intensity bounds, a probability weight, and duration bounds. The renderer / runtime samples one entry at a time using weighted-random selection, drives it for a uniform-random duration in [min, max] sec, then re-rolls. • Types: Clear / Rain / Snow / Storm / Sandstorm / Fog / Blizzard (extensible enum). • Binary format: magic "WOWA", version 1, name, N entries each storing (typeId, minIntensity, maxIntensity, weight, minDurationSec, maxDurationSec). CLI: • --info-wow <wow-base> [--json] — inspect a WOW • --gen-weather-temperate — clear + rain + fog (forest) • --gen-weather-arctic — snow + blizzard + fog (tundra) • --gen-weather-desert — clear + sandstorm (dunes) • --gen-weather-stormy — rain + storm + occasional clear The 8th open format complementing the rest: M2 → WOM | WMO → WOB | WMO collision → WOC | ADT → WOT DBC → JsonDBC | BLP → PNG | Light.dbc → WOL | WeatherTypes.dbc → WOW Smoke-tested all 4 presets + JSON output. Each preset reads back identically with the expected entry count and weight distribution.
2026-05-09 14:10:13 -07:00
"--gen-weather-desert", "--gen-weather-stormy",
feat(editor): add --gen-zone-atmosphere paired light+weather composite Convenience composite that drops both atmosphere.wol AND atmosphere.wow into <zoneDir> in a single invocation, using a paired light/weather preset: --preset default → makeDefaultDayNight + makeTemperate --preset arctic → makeNight + makeArctic --preset desert → makeDefaultDayNight + makeDesert --preset stormy → makeDefaultDayNight + makeStormy --preset cave → makeCave + makeTemperate The preset pairs are curated so the lighting and weather match the zone climate (arctic uses always-night WOL + arctic WOW; cave uses dim cave WOL + temperate WOW since cave weather is rarely visible). Useful as the canonical "give me a working atmosphere setup for a fresh zone in one command" entrypoint. Both files land at <zoneDir>/atmosphere.{wol,wow} where the runtime loader can find them by convention. Smoke-tested both default and arctic presets — both produce files that pass --validate-wol and --validate-wow cleanly.
2026-05-09 14:21:55 -07:00
"--gen-zone-atmosphere",
refactor(editor): extract kArgRequired + meta handlers into cli modules Splits the 138-line static-local kArgRequired array (the list of flags requiring positional args) into a new cli_arg_required.{hpp,cpp} module with extern linkage. Then moves the three meta handlers that depended on it out of main.cpp into cli_introspect.cpp: - --validate-cli-help (uses the array for self-check) - --version / -v (3-line printf) - --help / -h (1-line passthrough) main.cpp shrinks by 191 lines (677 to 486). Both the early missing-argument detector in main() and --validate-cli-help in cli_introspect.cpp now share one source of truth for the arg-required list.
2026-05-09 10:08:14 -07:00
"--info-creatures", "--info-objects", "--info-quests",
"--info-extract", "--info-extract-tree", "--info-extract-budget",
"--list-missing-sidecars",
"--info-png", "--info-jsondbc", "--info-blp", "--info-pack-budget",
"--info-pack-tree",
"--info-m2", "--info-wmo", "--info-adt",
"--info-zone", "--info-zone-overview", "--info-project-overview",
"--copy-project", "--info-wcp", "--list-wcp",
"--list-creatures", "--list-objects", "--list-quests",
"--list-quest-objectives", "--list-quest-rewards",
"--info-creature", "--info-quest", "--info-object",
"--info-quest-graph-stats",
"--info-creatures-by-faction", "--info-creatures-by-level",
"--info-objects-by-path", "--info-objects-by-type",
"--info-quests-by-level", "--info-quests-by-xp",
"--unpack-wcp", "--pack-wcp",
"--validate", "--validate-wom", "--validate-wob", "--validate-woc",
"--validate-whm", "--validate-all", "--validate-project",
"--validate-project-open-only", "--audit-project", "--bench-audit-project",
"--bench-validate-project", "--bench-bake-project",
"--bench-migrate-data-tree", "--list-data-tree-largest",
"--export-data-tree-md", "--gen-texture", "--gen-mesh", "--gen-mesh-textured",
"--add-texture-to-mesh", "--add-texture-to-zone",
"--gen-mesh-stairs", "--gen-mesh-grid", "--gen-mesh-disc",
"--gen-mesh-tube", "--gen-mesh-capsule", "--gen-mesh-arch",
"--gen-mesh-pyramid", "--gen-mesh-fence", "--gen-mesh-tree",
"--gen-mesh-rock", "--gen-mesh-pillar", "--gen-mesh-bridge",
"--gen-mesh-tower", "--gen-mesh-house", "--gen-mesh-fountain",
"--gen-mesh-statue", "--gen-mesh-altar", "--gen-mesh-portal",
"--gen-mesh-archway", "--gen-mesh-barrel", "--gen-mesh-chest",
"--gen-mesh-anvil", "--gen-mesh-mushroom", "--gen-mesh-cart",
"--gen-mesh-banner", "--gen-mesh-grave", "--gen-mesh-bench",
"--gen-mesh-shrine", "--gen-mesh-totem", "--gen-mesh-cage",
"--gen-mesh-throne", "--gen-mesh-coffin", "--gen-mesh-bookshelf",
feat(editor): add --gen-mesh-woodpile firewood-stack primitive 55th procedural mesh primitive. Builds the classic 3-2-1 firewood pyramid: • 3 cylindrical logs along the bottom row, sitting on the ground at radii apart • 2 logs nestled in the gaps of the bottom row • 1 log crowning the pile Vertical step uses cos(30°) = sqrt(3)/2 so adjacent logs touch tangentially, giving the close-packed look of a real chopped-wood stack. Logs lie horizontally along the Z axis with closed end caps; sides parameter controls cross- section smoothness (default 12, range 6..64). Pairs naturally with --gen-mesh-firepit and --gen-mesh-tent for outdoor camp / homestead / lumberyard set dressing.
2026-05-09 10:47:21 -07:00
"--gen-mesh-tent", "--gen-mesh-firepit", "--gen-mesh-woodpile",
feat(editor): add --gen-mesh-dock pier-on-stilts primitive 58th procedural mesh primitive. Builds a wooden waterside dock from axis-aligned boxes: • flat plank deck slab spanning length × width at deckT thickness, sitting at deckHeight off the ground • N pairs of square pilings under the long edges, evenly spaced from end to end • pilings inset by pilingW so the deck overhangs slightly (the standard "boards rest ON TOP of the posts" look) Distinct from --gen-mesh-bridge which arches OVER an obstacle — a dock walks straight out from a shoreline on stilts to the water. Useful for fishing villages, port warehouses, lake settlements, ferry stations, smuggler hideouts. Watertight under weld (--audit-watertight passes): pilings sit below the deck overhang and don't share corners with it.
2026-05-09 11:17:28 -07:00
"--gen-mesh-canopy", "--gen-mesh-haystack", "--gen-mesh-dock",
feat(editor): add --gen-mesh-bedroll camp sleeping prop 61st procedural mesh primitive. Builds a bedroll prop: • horizontal closed cylinder along the Z axis sitting at y = R so it rests on the ground (radius defaults to 0.16 m, length 1.4 m — adult-human-shaped) • optional pillow box at the +Z end (squashed cube, pillowSize controls extent) • per-segment N-sided cylinder uses the new addVertex helper; pillow uses addFlatBox Set pillowSize=0 for a bare rolled mat. Watertight under weld (verified via --info-mesh-stats: 90 manifold edges, 0 boundary, 0 non-manifold). Pairs naturally with --gen-mesh-tent / --gen-mesh-firepit / --gen-mesh-canopy for outdoor camp scenes — completes the tent-side camping kit.
2026-05-09 11:39:33 -07:00
"--gen-mesh-pergola", "--gen-mesh-chimney", "--gen-mesh-bedroll",
feat(editor): add --gen-mesh-crate-stack scene primitive 63rd procedural mesh primitive. The first to explicitly compose a *scene* of multiple objects rather than a single structure: an N×M×K arrangement of cube crates with a small gap between each so they read as discrete shipping boxes rather than one merged solid. Default 2×2×2 = 8 crates with 0.40 m sides on a 0.02 m gap gives a tight pyramidal pile. Larger configurations (e.g. 4×3×2 = 24 crates) read as warehouse pallets. Uses every shared helper added this batch — addFlatBox for each crate, finalizeAsSingleBatch for the trailing batch, stripExt for the .wom suffix, parseOptInt/Float for the optional dimension args. Each crate emits the standard 24-vert / 12-tri box, so an N×M×K stack is a clean N*M*K-multiple in vertices and triangles. Useful for warehouses, cargo holds, dock loading bays, market stalls, dwarven mining caches, pirate stash piles. Watertight under weld — the gap keeps adjacent crates from sharing corner positions.
2026-05-09 11:52:20 -07:00
"--gen-mesh-workbench", "--gen-mesh-crate-stack",
feat(editor): add --gen-mesh-water-trough basin primitive 65th procedural mesh primitive. Open-top rectangular basin built from 5 axis-aligned boxes (uses every shared helper from cli_box_emitter): • bottom slab spanning full footprint at wallT thickness • +X / -X side walls spanning full length • +Z / -Z front/back walls spanning the inner length so they tuck inside the side walls without overlap Inner cavity (length-2*wallT × height-wallT × width-2*wallT) is the open water/feed volume. Useful for stables, farmsteads, taverns, stockyards, alchemist mixing basins. Default 1.4 × 0.5 × 0.5 m is a reasonable horse-trough size; configurable for smaller hand-basins or larger livestock troughs.
2026-05-09 12:02:35 -07:00
"--gen-mesh-watchpost", "--gen-mesh-water-trough",
feat(editor): add --gen-mesh-hitching-post stable fixture 67th procedural mesh primitive. Standard town/stable hitching post: • two vertical posts separated by `span` • horizontal cross-bar at upper-post height (length = span - postW so it tucks INSIDE the post inner faces, matching real fence joinery) • optional decorative caps on each post — set capH=0 for a bare working-yard post All axis-aligned boxes, exercises every shared helper (stripExt, initWomDefaults, addFlatBox, finalizeAsSingleBatch, saveWomOrError). Watertight under weld (verified 90 manifold edges, 0 boundary, 0 non-manifold). Useful for stables, taverns with mount parking, town squares, frontier outposts, ranger camps, post-and-rail fence segments.
2026-05-09 12:15:41 -07:00
"--gen-mesh-training-dummy", "--gen-mesh-hitching-post",
feat(editor): add --gen-mesh-forge blacksmith hearth 69th procedural mesh primitive. Built from up to 3 axis- aligned boxes: • stone hearth: rectangular base spanning width × depth × baseH, where the smith's fire would sit • hood: smaller smoke-collector box on top of the hearth, inset by hoodInset on each side so it reads as the chimney's flared base • optional thin chimney rising from the hood — set chimneyH=0 for an open-vented forge Pairs naturally with --gen-mesh-anvil and --gen-mesh-workbench for blacksmith/armorer/farrier scenes, and with --gen-mesh-bench / --gen-mesh-crate-stack for the storage corner of a smithy. Watertight under weld (verified 54 manifold edges, 0 boundary, 0 non-manifold). Default 1.4×1.0×0.9 m hearth + 0.5 m hood + 1.2 m chimney reads as a normal village smithy.
2026-05-09 12:29:09 -07:00
"--gen-mesh-outhouse", "--gen-mesh-forge",
feat(editor): add --gen-mesh-gravel-pile rubble heap 71st procedural mesh primitive. Hash-distributed pile of stone cubes in a roughly conical heap. Each stone gets: • polar position (radial, theta) with sqrt(rand) on radial so stones aren't bunched at center • height limited by yMax = pileH * (1 - radial/baseR), so larger / more numerous stones land near the base and smaller ones perch on top — natural gravel-pile profile • size in the 40-100% range of maxStoneSize The second multi-box "scene" composite primitive (after --gen-mesh-crate-stack), but using irregular hashed placement instead of a regular N×M×K grid. Deterministic from seed: re-running with same args reproduces the identical pile. Useful for mine entrances, construction sites, quarries, ruined walls, abandoned-fort rubble, pirate-cove stash mounds. Default 24 stones at 0.6 m base radius gives a reasonable medium-pile. Uses every shared helper introduced this batch (printWomWrote, printWomMeshStats, setCenteredBoundsXZ, addFlatBox, saveWomOrError, parseOpt*, stripExt).
2026-05-09 12:43:03 -07:00
"--gen-mesh-archery-target", "--gen-mesh-gravel-pile",
feat(editor): add --gen-mesh-mine-cart underground transport 73rd procedural mesh primitive. Open-top mining cart on 4 wheel boxes: • bin: 5-piece basin construction (bottom slab + 4 perimeter walls), same arrangement as --gen-mesh-water-trough • wheels: 4 cube boxes at the corners, inset by wheelInset and sitting on the ground (y from 0 to 2*wheelR) • bin sits on top of the wheels at y = 2*wheelR All axis-aligned — exercises every shared helper. Useful for mines, dwarven forges, gnomish junk-yards, abandoned- tunnel set dressing, salvage scenes. Default 0.9 × 0.5 m bin with 0.08-radius wheels gives the classic narrow-gauge ore-cart silhouette. The 4-wall basin construction (verified via --info-mesh-stats: 6 non-manifold edges at the wall corners — same as --gen-mesh-water-trough's expected branchy edges) means the cart can hold collision- visible ore inside if a content author drops in another primitive.
2026-05-09 12:54:17 -07:00
"--gen-mesh-stone-bench", "--gen-mesh-mine-cart",
feat(editor): add --gen-mesh-pillar-row colonnade primitive 75th procedural mesh primitive. Row of N stone pillars evenly spaced along the X axis. Each pillar is a single tall rectangular box optionally crowned by a slightly-wider square cap (capExtra wider per side). End pillars inset by pillarW so they sit at exactly the ±span/2 ends. Set capH=0 for bare un-crowned columns. Useful for ruined temples, palace colonnades, dungeon hallways, dwarven mead-hall arcades, ceremonial entry walks. Distinct from --gen-mesh-pillar (single column) — this is the regular-multi-column composite, the third "scene" primitive after --gen-mesh-crate-stack and --gen-mesh-gravel-pile. Watertight under weld (verified 144 manifold edges, 0 boundary, 0 non-manifold). Default 4-pillar / 4 m / 2.5 m spacing reads as a small temple front porch.
2026-05-09 13:04:55 -07:00
"--gen-mesh-hitching-rail", "--gen-mesh-pillar-row",
feat(editor): add --gen-mesh-bird-bath garden water-feature 77th procedural mesh primitive. Garden bird-bath: • stem: thin Y-axis closed cylinder (the column) • basin: wider shallow Y-axis closed cylinder on top Both are full closed cylinders (side wall + ±Y cap fans) so the model is a watertight solid. Local addYCylinder lambda emits each tier — keeps the per-handler code self-contained without forcing yet another module-level helper. Distinct from --gen-mesh-fountain (basin + spout column, larger water feature) — bird-bath is the small ornamental garden version. Useful for monastery courtyards, druid sanctuaries, noble-house pleasure gardens, sanctuary clearings, ranger huts. Watertight under weld (verified 192 manifold edges, 0 boundary, 0 non-manifold).
2026-05-09 13:16:06 -07:00
"--gen-mesh-statue-base", "--gen-mesh-bird-bath",
feat(editor): add --gen-mesh-candle wax-pillar primitive 80th procedural mesh primitive. Wax pillar candle: • saucer (optional) — wider shallow disc base, the drip catcher that sits on the table • wax — thin tall pillar standing on the saucer (or directly on the ground if saucerR=0) Uses the addClosedCylinderY helper for both pieces — same two-cylinder pattern as --gen-mesh-bird-bath but with a much skinnier upper cylinder. The 81-line handler is mostly arg parsing + validation; geometry is just two helper calls. Useful for chapels / shrines, vigil scenes, witch-hut ritual surfaces, alchemist labs, séance tables, festival- of-lights ground decoration. Set saucerR=0 for a plain candle without the saucer (e.g. for stack-them-on-a-cake contexts). Watertight under weld (verified — wax + saucer are two independent closed cylinders). Milestone: now at 80 procedural mesh primitives.
2026-05-09 13:32:43 -07:00
"--gen-mesh-planter-box", "--gen-mesh-urn", "--gen-mesh-candle",
feat(editor): add --gen-mesh-chalice ceremonial goblet 82nd procedural mesh primitive. 3-tier ceremonial chalice: • foot — wide flat base disc (the goblet's footprint on the table) • stem — thin tall connecting column (the holding-grip) • bowl — wider shallow cup at the top Validates that stemR < both footR and bowlR so the silhouette always reads as the classic wide-narrow-wide goblet shape rather than a degenerate cylinder stack. Three more primitives that consume the addClosedCylinderY helper this batch (lantern + chalice from the previous two commits + this), pattern is now well-established. Useful for chapel altars, treasure rooms, royal-court banquet tables, ritual / cult scenes, dwarven mead halls, fairy-tale storybook props. Watertight under weld (verified 252 manifold edges, 0 boundary, 0 non-manifold). Milestone: kArgRequired now reaches 420 documented flags.
2026-05-09 13:42:58 -07:00
"--gen-mesh-lantern", "--gen-mesh-chalice",
feat(editor): add --gen-mesh-scroll-case library prop 84th procedural mesh primitive. Cylindrical scroll case / map tube: • body — thin tall Y-axis cylinder (the case proper) • cap (optional) — shorter wider cylinder on top, set capR=0 to skip for a bare stick / rolled-document spine Distinct from --gen-mesh-chalice (foot + stem + bowl silhouette) and --gen-mesh-lantern (4-tier base + globe + neck + cap) — scroll case is the simplest 1-or-2-tier "tube with lid" prop. Useful for wizard-tower libraries, archive shelves, mage- hut detail trim, scribe-table props, scout-courier waist gear. Validates that capR >= bodyR so the lid always reads as a proper top closure rather than a degenerate band. Watertight under weld (verified 168 manifold edges, 0 boundary, 0 non-manifold). Two more clean uses of the addClosedCylinderY helper.
2026-05-09 13:58:22 -07:00
"--gen-mesh-standing-torch", "--gen-mesh-scroll-case",
feat(editor): add --gen-mesh-well-pail wooden bucket primitive 86th procedural mesh primitive. Wooden well-pail / mop- bucket: • body — closed cylindrical Y-axis cylinder via addClosedCylinderY (collision-watertight) • handle — thin horizontal box floating handleArc above the rim, spanning at least bodyR×2 wide so its ends align with the rim's outside edge Without rotation the handle is a straight bar rather than a true semicircle, but the bucket-with-handle silhouette still reads correctly. handleArc parameter controls the gap between rim and handle (small = handle touches rim; larger = bucket-being-carried look). Useful for well scenes (pairs with --gen-mesh-well), servant-corridor mop scenes, kitchen prep stations, homestead exteriors, dwarven mine shafts, ocean-ship swabbing decks. Watertight under weld (verified 102 manifold edges, 0 boundary, 0 non-manifold).
2026-05-09 14:23:23 -07:00
"--gen-mesh-stove", "--gen-mesh-well-pail",
feat(editor): add --gen-mesh-mortar-pestle alchemy primitive 90th procedural mesh: a wider-than-tall closed cylinder (the mortar bowl) with a thin tall closed cylinder (the pestle) rising from its center. Bowl reads as carved stone or wood; pestle reads as a small grinding rod centered in the rim. Distinct from existing kitchenware primitives: • --gen-mesh-cauldron — large + has supporting legs • --gen-mesh-chalice — 3-tier goblet, no separate utensil • --gen-mesh-mug — handled drinking cup • --gen-mesh-bowl — does not exist; this primitive covers the small-bowl + tool case Useful for: alchemy lab counters, kitchen / cooking-stove dressing, herbalist shop interiors, witchcraft NPCs, quest-giver desks for "grind these herbs" objectives. 124 verts / 112 tris at default 14 sides — two simple closed cylinders sharing a single batch with shared texture coords.
2026-05-09 14:43:21 -07:00
"--gen-mesh-mug", "--gen-mesh-mortar-pestle",
feat(editor): add --gen-mesh-rune-stone standing monolith 91st procedural mesh: a wide flat base block with a tall narrow monolith standing on top. Reads as a small carved standing-stone marker. Distinct from existing ritual-prop primitives: • --gen-mesh-altar — table-shaped, has flat top • --gen-mesh-shrine — multi-tier with cap • --gen-mesh-tombstone — narrower, curved-top silhouette • --gen-mesh-pillar — round column, no base block • --gen-mesh-statue — has figure on top Useful for: druid groves (boundary markers), witch shrines, ancient ruins (pre-civilization monuments), graveyard boundary stones, faction territory markers, Stonehenge-style ring formations (use 4-8 instances around a center point). 48 verts / 24 tris from two simple boxes — minimal vertex budget, suitable for placing in dense clusters.
2026-05-09 16:21:35 -07:00
"--gen-mesh-rune-stone",
feat(editor): add --gen-village-pack composite Third composite pack (after --gen-camp-pack and --gen-blacksmith-pack), emitting a 7-primitive village-square scene into <outDir>: • house — main dwelling • outhouse — privy beside it • chimney — for the house roof piece • hitching-post — at the hitching rail • well — village square centerpiece • signpost — pointing the way out of town • haystack — from the nearby farm Together these form a recognizable rural-village hub when arranged in a zone. Uses the existing emitMeshPack helper — the new pack is just an 8-line declarative table. All 7 outputs validate clean (--validate-wom PASSED across the board). Composite-pack catalogue now: camp + blacksmith + village.
2026-05-09 12:45:25 -07:00
"--gen-camp-pack", "--gen-blacksmith-pack", "--gen-village-pack",
feat(editor): add --gen-graveyard-pack composite Fifth themed mesh pack after camp / blacksmith / village / temple. Cemetery scene emitting a 7-primitive burial yard: • grave — filled plot mound • tombstone — marker stone • coffin — above-ground or open • statue — mourning angel / patron deity • stone-bench — for visitors and mourners • gravel-pile — loose earth from a fresh dig • cage — fence section / mausoleum gate Together these form the standard town-edge burial yard when arranged in a zone. Composite-pack catalogue now: camp + blacksmith + village + temple + graveyard. All 7 outputs validate clean. --list-packs surfaces 10 composite flags total (5 mesh packs + the pre-existing zone/project starter packs).
2026-05-09 12:55:50 -07:00
"--gen-temple-pack", "--gen-graveyard-pack",
feat(editor): add --gen-tavern-pack composite Eighth themed mesh pack after camp / blacksmith / village / temple / graveyard / garden / dock. Inn/tavern scene emitting a 7-primitive watering-hole layout: • house — the inn building • chimney — above the kitchen hearth • table — the common-room centerpiece • bench — seating • barrel — ale / cider stock • bookshelf — back-wall record / register / library • signpost — the inn-sign post out front Together these form a minimum-viable tavern setup for any roadside inn, town watering-hole, road-house mid-route stop. Composite-pack catalogue: camp + blacksmith + village + temple + graveyard + garden + dock + tavern = 8 themed mesh packs. --list-packs surfaces 13 composites total (including pre-existing zone/project starter packs).
2026-05-09 13:17:49 -07:00
"--gen-garden-pack", "--gen-dock-pack", "--gen-tavern-pack",
feat(editor): add --gen-arena-pack composite Tenth themed mesh pack after camp / blacksmith / village / temple / graveyard / garden / dock / tavern / mining. Combat-training / gladiator-pit / militia-drill-yard scene emitting a 7-primitive arena layout: • training-dummy — practice target • archery-target — range station • workbench — weapons-rack stand • crate-stack — gear storage • bench — audience seating • water-trough — between-bout refresh • hitching-rail — mount parking Composite-pack catalogue: camp + blacksmith + village + temple + graveyard + garden + dock + tavern + mining + arena = 10 themed mesh packs. --list-packs surfaces 15 total composites including the pre-existing zone/project starter packs. Milestone: ten themed mesh packs covering the full life cycle of a typical role-playing-game town from outdoor camp to blacksmith forge to gladiator arena.
2026-05-09 13:44:48 -07:00
"--gen-mining-pack", "--gen-arena-pack",
feat(editor): add --gen-kitchen-pack composite (11th themed pack) Tavern back-of-house / cookhouse scene composite. Pairs naturally with --gen-tavern-pack (front-of-house common room) for a complete inn setup. Emits 7 .wom files into outDir: • stove — pot-bellied cookfire stove • cauldron — large hanging pot • prep-table — flat work surface • stool — cook's seat • barrel — water / ale / flour storage • mug — drink ready for the inn customer • mortar — herb / spice grinding tool This is the 11th themed pack (camp, blacksmith, village, temple, graveyard, garden, dock, tavern, mining, arena, kitchen). Notable for being the first pack that uses the two recently-added drinking-vessel + alchemy primitives (mug from batch 111, mortar-pestle from batch 113), proving out the "build small primitives, then compose into themed packs" workflow. All 7 emitted primitives pass --validate-wom on first generation. 468 kArgRequired entries total.
2026-05-09 14:53:01 -07:00
"--gen-kitchen-pack",
refactor(editor): extract kArgRequired + meta handlers into cli modules Splits the 138-line static-local kArgRequired array (the list of flags requiring positional args) into a new cli_arg_required.{hpp,cpp} module with extern linkage. Then moves the three meta handlers that depended on it out of main.cpp into cli_introspect.cpp: - --validate-cli-help (uses the array for self-check) - --version / -v (3-line printf) - --help / -h (1-line passthrough) main.cpp shrinks by 191 lines (677 to 486). Both the early missing-argument detector in main() and --validate-cli-help in cli_introspect.cpp now share one source of truth for the arg-required list.
2026-05-09 10:08:14 -07:00
"--gen-mesh-table", "--gen-mesh-lamppost", "--gen-mesh-bed",
"--gen-mesh-ladder", "--gen-mesh-well", "--gen-mesh-signpost",
"--gen-mesh-mailbox", "--gen-mesh-tombstone", "--gen-mesh-crate",
"--gen-mesh-stool", "--gen-mesh-cauldron", "--gen-mesh-gate",
"--gen-mesh-beehive", "--gen-mesh-weathervane",
"--gen-mesh-scarecrow", "--gen-mesh-sundial",
feat(editor): add --gen-mesh-archway-double twin-passage primitive 58th procedural mesh: 5-box double archway — 3 vertical posts (left / shared center / right) plus 2 horizontal lintels each spanning one opening. Pairs with the existing single --gen-mesh-archway for plaza approaches, double-door tomb fronts, formal garden entrances, paired temple entries. Defaults to 1.40m × 2 openings with 2.40m opening height (~3.16m total width × 2.60m height including lintels).
2026-05-09 10:11:24 -07:00
"--gen-mesh-podium", "--gen-mesh-brazier", "--gen-mesh-archway-double",
refactor(editor): extract kArgRequired + meta handlers into cli modules Splits the 138-line static-local kArgRequired array (the list of flags requiring positional args) into a new cli_arg_required.{hpp,cpp} module with extern linkage. Then moves the three meta handlers that depended on it out of main.cpp into cli_introspect.cpp: - --validate-cli-help (uses the array for self-check) - --version / -v (3-line printf) - --help / -h (1-line passthrough) main.cpp shrinks by 191 lines (677 to 486). Both the early missing-argument detector in main() and --validate-cli-help in cli_introspect.cpp now share one source of truth for the arg-required list.
2026-05-09 10:08:14 -07:00
"--gen-texture-gradient",
"--gen-mesh-from-heightmap", "--export-mesh-heightmap",
"--displace-mesh",
"--scale-mesh", "--translate-mesh", "--strip-mesh",
"--gen-texture-noise", "--gen-texture-noise-color", "--rotate-mesh",
"--center-mesh", "--flip-mesh-normals", "--mirror-mesh",
"--smooth-mesh-normals",
"--merge-meshes",
"--gen-texture-radial", "--gen-texture-stripes", "--gen-texture-dots",
"--gen-texture-rings", "--gen-texture-checker", "--gen-texture-brick",
"--gen-texture-wood", "--gen-texture-grass", "--gen-texture-fabric",
"--gen-texture-cobble", "--gen-texture-marble", "--gen-texture-metal",
"--gen-texture-leather", "--gen-texture-sand", "--gen-texture-snow",
"--gen-texture-lava", "--gen-texture-tile", "--gen-texture-bark",
"--gen-texture-clouds", "--gen-texture-stars", "--gen-texture-vines",
"--gen-texture-mosaic", "--gen-texture-rust", "--gen-texture-circuit",
"--gen-texture-coral", "--gen-texture-flame", "--gen-texture-tartan",
"--gen-texture-argyle", "--gen-texture-herringbone",
"--gen-texture-scales", "--gen-texture-stained-glass",
"--gen-texture-shingles", "--gen-texture-frost",
"--gen-texture-parquet", "--gen-texture-bubbles",
"--gen-texture-spider-web", "--gen-texture-gingham",
"--gen-texture-lattice", "--gen-texture-honeycomb",
"--gen-texture-cracked", "--gen-texture-runes",
"--gen-texture-leopard", "--gen-texture-zebra",
feat(editor): add --gen-texture-chainmail interlinked rings 48th procedural texture: brick-offset ring outlines. Even and odd rows are shifted by half a cell width so each ring interlocks visually with its neighbors above and below — the classic chainmail-armor pattern. Each pixel is tested against the nearest ring center; if its distance lies inside [ringR - strokeW/2, ringR + strokeW/2] it's painted as the ring color, otherwise background. Useful for armor textures (mail tunics, helms, gauntlets), metallic fabric set dressing on guard NPCs, and dungeon gate/grate textures. Default ring radius 5 on a 14x10 brick spacing reads cleanly at 256x256 without aliasing.
2026-05-09 10:34:02 -07:00
"--gen-texture-knit", "--gen-texture-chainmail",
feat(editor): add --gen-texture-corrugated metal-sheet ridges 50th procedural texture: smooth cosine ridges that lerp between bgHex (trough) and hiHex (crest) over a configurable period. Direction defaults to vertical ridges (wave varies along X) — the standard corrugated-sheet-metal-roof look — with optional horizontal mode for siding panels and pipe texturing. Useful for sheet-metal roofing, corrugated-iron walls, sci-fi paneling, and any "ridged plate" surface where the existing flat --gen-texture-metal would read as too uniform. Default 16px period at 256x256 reads cleanly with about 16 ridges across the tile.
2026-05-09 10:50:46 -07:00
"--gen-texture-planks", "--gen-texture-corrugated",
feat(editor): add --gen-texture-caustics water-shimmer pattern 52nd procedural texture: water-surface caustics via four superimposed sine waves running along x, y, x+y, and x-y. Each wave is taken in absolute value before multiplication so peaks shine on either side of the wave centerline, giving the bright-line interference network you see on a pool floor or sunlit shallow streambed. Two-color lerp from bgHex (depth) to hiHex (highlight). Default 24-pixel period reads at the right scale for water- plane underlay; pass a smaller period for tighter ripple. Useful as the floor texture under transparent water volumes, magic-fountain pools, fish-tank ground plates, ritual scrying basins, and any "submerged surface seen through clear water" effect.
2026-05-09 11:12:28 -07:00
"--gen-texture-rope", "--gen-texture-caustics",
feat(editor): add --gen-texture-studs riveted-armor pattern 54th procedural texture: grid of round rivet caps with an inner highlight. Each stud has: • outer ring (40%-100% of studR) at the studHex base color • inner core (0-40% of studR) at studHex × 1.4 brightness • bg color outside studR The 40% bright core sells the 3D rivet appearance — a flat solid circle (which --gen-texture-dots already produces) reads as a polka dot, while the bright/dim concentric pair reads as a metal stud catching light. Useful for studded leather armor, riveted plate, banded mail trim, dwarven hauberks, prison-cell door reinforcement, ship hull plating. Default 24-stride grid with R=7 reads cleanly at typical body-armor scale.
2026-05-09 11:31:27 -07:00
"--gen-texture-starburst", "--gen-texture-studs",
feat(editor): add --gen-texture-woodgrain end-cut tree-rings 56th procedural texture: concentric annual growth rings centered slightly off-image (at -W*0.2, H/2) so the texture shows sweeping arcs across most of its area rather than the bullseye --gen-texture-rings produces. Per-ring jitter shifts the dark-band center within each ring's annular cell, so adjacent rings don't read as a perfect modulus pattern — mimics real annual-growth variation. Brightness lerps from lightHex (early-wood) to darkHex (late-wood / heartwood) with a smooth triangular falloff at the dark-band peak. First procedural texture to use the new cli_arg_parse helpers for the optional spacing/seed/W/H args. Useful for tabletops, log-end caps (chopped firewood stumps), barrel lids, beam cross-sections, plank ends — distinct from --gen-texture-wood which renders vertical grain streaks for plank surfaces.
2026-05-09 11:44:33 -07:00
"--gen-texture-moss", "--gen-texture-woodgrain",
feat(editor): add --gen-texture-pinstripe formal-fabric pattern 58th procedural texture: thin vertical lines at every `stride` x position, with optional thicker "feature" line every Nth stripe. The periodic doubled-thickness emphasis is what distinguishes this from --gen-texture-stripes (which renders wide alternating bands of each color). Each stripe is centered within its column and has configurable lineW; feature stripes are 2× the regular width. Set featureEvery=0 to disable feature emphasis for a uniform pinstripe pattern. Useful for noble-house tabards, formal-attire fabric, banker's counter cloth, sci-fi panel detailing, royal- guard uniform trim, library / archive carpet runners. Default 12-pixel stride, 1-pixel line, feature every 6th stripe gives the classic suit-pinstripe look at 256x256.
2026-05-09 11:56:01 -07:00
"--gen-texture-carbon", "--gen-texture-pinstripe",
feat(editor): add --gen-texture-snake-skin diamond-scale pattern 60th procedural texture: brick-offset grid of diamond-shaped scales using L1 (taxicab) metric so |dx|/halfW + |dy|/halfH < 1 inside each diamond. Even rows are aligned with the cell grid; odd rows shift by halfW so adjacent scales touch tangentially along their points — the classic snake/dragon hide pattern. A thin dark outline at d ∈ [outlineFrac, 1] gives definition; outline color is automatically derived as scaleHex × 0.4 (2/5 brightness). Set outlineW=0 to skip the outline for a smoother painted-scale look. Distinct from --gen-texture-scales (overlapping circles for fish/dragon scales) and --gen-texture-chainmail (rings for metal mail). Useful for snake-cult robe trim, naga skin, dragon-scale armor inserts, lizardman set dressing, basilisk-themed dungeon decor.
2026-05-09 12:08:11 -07:00
"--gen-texture-camo", "--gen-texture-snake-skin",
feat(editor): add --gen-texture-bamboo jungle-stalk pattern 62nd procedural texture: vertical bamboo stalks with cylindrical sin² brightness shading + horizontal darker node bands at regular Y intervals. Each stalk gets a small hash-derived hue jitter (±15) so adjacent stalks don't read as a perfect repeat. Per-pixel logic: • 10% horizontal gap between stalks (gapFrac=0.10) → visible bg seam between bamboo stalks • Inside the stalk, brightness = sin²(insetFraction * π) rising from 0 at the stalk edge to 1 at the centerline • Every nodeY pixels, a `nodeBand`-tall horizontal strip has its brightness knocked down to 2/3 — the segmented bamboo joint look Useful for jungle huts, pandaren / asian-themed architecture, swamp boardwalks, tropical-tribe weapon trim, brewmaster zone trim. Default 24-pitch / 64-spacing / 4-band reads as adult-bamboo at typical 256x256 wall-tile scale.
2026-05-09 12:20:11 -07:00
"--gen-texture-mesh-screen", "--gen-texture-bamboo",
feat(editor): add --gen-texture-rust-streaks vertical-drip pattern 64th procedural texture: vertical rust drips on a metal base. Each streak is a hash-derived (x position, width 1..4 px, top y, length H/3..H) band that fades from full rust at the top to bg at the bottom — the "streak" effect of years of rain washing rust down from rivets and seams. Distinct from --gen-texture-rust (generic surface noise) — this is the directional-drip variant for: • weathered metal walls (especially under high windows) • sewer-grate backings under standing puddles • ship-hull stains below scupper ports • abandoned-machinery panels under leaking pipes Deterministic from seed: re-running with same args produces the byte-identical image. Default 40 streaks at 256x256 gives a reasonable "lightly aged" intensity; bump streakCount for heavier corrosion.
2026-05-09 12:33:25 -07:00
"--gen-texture-blueprint", "--gen-texture-rust-streaks",
feat(editor): add --gen-texture-diamond-grid solid-shape tile 66th procedural texture: axis-aligned grid of solid diamond shapes (no row offset) separated by visible bg gaps. Each cell hosts one diamond computed via L1 (taxicab) metric: |dx|/halfW + |dy|/halfH < fillFrac. Distinct from --gen-texture-snake-skin (brick-offset diamonds that touch tangentially with a derived dark outline) — this variant uses uniform spacing and a configurable fill fraction so diamonds float in clean grid rows. fillFrac = 0.80 default gives a 20% bg-gap moat between diamonds; bump near 1.0 for nearly-touching chevron-floor look, drop to 0.5 for sparse polka-diamond. Useful for clean tile floors, mosaic inlay panels, banner seamless backgrounds, formal heraldry trim, jeweled-cloak tabards.
2026-05-09 12:47:28 -07:00
"--gen-texture-plaid", "--gen-texture-diamond-grid",
feat(editor): add --gen-texture-chevron V-stripe pattern 68th procedural texture: stack of V-shape stripes with sharp seams. Within each vertical period the upper half slopes one way and the lower half slopes the other; the distance from the apex is added as an x-shift to the stripe-column test, so stripes follow the V profile and form clean chevrons. Distinct from --gen-texture-herringbone (which alternates slab orientation between cells) and --gen-texture-zebra (sinusoidal stripes with no seam) — chevron has the characteristic sharp V transition. Useful for military insignia, sportswear, heraldic banners, roadwork signage, paladin tabards, ranger cloaks. Default 24-period / 24-stride / 6-wide gives a chunky chevron at 256x256; tighter values read as fine ribbon trim.
2026-05-09 12:57:47 -07:00
"--gen-texture-houndstooth", "--gen-texture-chevron",
feat(editor): add --gen-texture-swirl logarithmic-spiral 70th procedural texture: N-arm logarithmic spiral. Each pixel computes its polar angle minus log(r)*spiralFactor and tests whether that "spiral phase" falls inside any arm's angular band (mod 2π/N). Distinct from --gen-texture-starburst (straight rays from center) — this is the curved-arm vortex variant. Small spiralFactor gives loose pinwheel arms; large factor gives tight whirlpool spirals. Useful for magic sigils, summoning circles, ritual floor markings, mystical-pool surfaces, mage-tower mosaic floors, shaman-totem ground inlays. Center-based pattern (doesn't tile seamlessly), so best used as standalone decals rather than wall textures.
2026-05-09 13:08:07 -07:00
"--gen-texture-dunes", "--gen-texture-swirl",
feat(editor): add --gen-texture-mold Worley-noise patches 72nd procedural texture: Worley (cellular) noise thresholded into mold patches. Each grid cell hosts a hash-jittered center; each pixel computes its distance to the nearest center across 9 surrounding cells (current + 8 neighbors) and is painted as mold if that distance is below thresholdFrac × stride. Distinct from --gen-texture-moss (single-spot per cell with hash-derived presence/jitter/radius) — mold has irregular field-shaped patches following the Voronoi cell boundaries rather than discrete circles, mimicking real fungal growth along surfaces. Useful for cellars, dungeon walls, plague zones, sewer overflow, food-warehouse spoilage, witch-hut detail trim. Default 18-stride / 0.55-threshold gives a moderate infestation; bump threshold near 0.9 for full coverage.
2026-05-09 13:19:30 -07:00
"--gen-texture-ironbark", "--gen-texture-mold",
feat(editor): add --gen-texture-lightbeam vertical-ray gradient 74th procedural texture: vertical light-beam / sun-ray gradient. Each pixel's brightness is the product of two fade factors: • vertical: 1.0 at the bright end, vFadeFrac at the dim end (direction flag selects bright-top 'd' or bright- bottom 'u') • radial: 1.0 inside the bright core (within beamHalfW of centerline), then linearly to 0.0 at the texture edge Two-color blend from bgHex to beamHex by combined brightness. Useful for dust-mote sunbeams through cathedral windows, holy radiance auras, crystal glow halos, lighthouse beams, projector / stage-light columns, ritual-summoning effects. First procedural texture with a directional flag (u / d) — flexible orientation for ceiling-down vs floor-up beams.
2026-05-09 13:30:57 -07:00
"--gen-texture-embroidery", "--gen-texture-lightbeam",
feat(editor): add --gen-texture-pinwheel sector mandala 76th procedural texture: N alternating colored triangular wedges radiating from the texture center, each subtending 2π/N radians. Each pixel computes its angle via atan2 and maps to a sector index; even sectors get color A, odd get color B. Distinct from --gen-texture-starburst (thin rays with bg between them) and --gen-texture-swirl (curved spiral arms) — pinwheel uses solid-fill alternating wedges with no bg. Useful for ceiling-decoration medallions, sun-mandala designs, magical-wheel symbols, wind-rose floor inlays, heraldic radial backgrounds, druid-circle ground markings. Default 8 sectors gives the classic pinwheel look; bump to 12-16 for finer subdivisions, or drop to 2-4 for bold quadrant patterns.
2026-05-09 13:41:40 -07:00
"--gen-texture-dewdrops", "--gen-texture-pinwheel",
feat(editor): add --gen-texture-crackle Voronoi cell-boundary 78th procedural texture: fine cracks following Voronoi cell boundaries. For each pixel, the algorithm finds the two nearest jittered cell centers (across 9 surrounding cells); the difference between (distance to second-nearest) and (distance to nearest) approximates distance to the cell boundary line. Pixels under crackW from the boundary get the crack color; inside cells get the base. Distinct from --gen-texture-cracked (wide stone cracks at large scale via random walk) and --gen-texture-frost (6-spike crystal rosettes from seeded points) — crackle is the fine-mud / dry-leather / parched-earth variant for desert ground / aged-document / drought-cracked-mud zones. Useful for desert-floor zones, aged-leather armor sections, parched-earth dungeon floors, dragon-burned ground, mummified-flesh trim, ancient-document parchment.
2026-05-09 13:56:41 -07:00
"--gen-texture-scratched-metal", "--gen-texture-crackle",
feat(editor): add --gen-texture-halftone gradient-modulated dots 80th procedural texture: regular grid of dots whose radii grow with a configurable gradient direction. Three modes: • v (vertical) — radii grow top-to-bottom • h (horizontal) — radii grow left-to-right • r (radial) — radii grow from texture center outward Mimics the comic-print / newspaper image-reproduction trick of varying dot size to encode grayscale. Distinct from --gen-texture-dots (uniform radius across the grid) and --gen-texture-studs (uniform with derived inner highlight) — halftone is the gradient-modulated variant. Useful for retro-comic / newspaper-aesthetic surfaces, vintage- poster overlays, sci-fi monitor screens (radial mode reads as CRT vignette), banner gradient detail, dawn/dusk sky overlays. Default 16-stride / maxR=7 / vertical reads as classic comic shading at 256x256.
2026-05-09 14:12:04 -07:00
"--gen-texture-star", "--gen-texture-halftone",
feat(editor): add --gen-texture-moon disc with phase shadow 82nd procedural texture: solid filled circle of moonHex on bg, with an optional crescent shadow created by subtracting a second bg-colored disc offset by `phase` pixels along +X. Phase reads as the lunar-cycle moment: • phase = 0 — full moon • 0 < phase < moonR — gibbous (waning right) • phase = moonR — half moon • phase > moonR — crescent (thinner as phase grows) Useful for night-sky overlays, banner moons (heraldry of night-themed orders), shrine medallion centers, druid / priest emblem inserts, lunar-festival decoration, vampire- zone backdrops. The simplest centered-disc texture in the catalogue — pairs naturally with --gen-texture-stars for a complete night-sky composite.
2026-05-09 14:26:57 -07:00
"--gen-texture-bayer", "--gen-texture-moon",
feat(editor): add --gen-texture-snowflake 6-fold ice crystal 84th procedural texture: 6-fold symmetric snowflake stamp tiled per cell. Built by computing polar (r, theta) from the cell center and folding theta into a [0, pi/6] wedge, so a single arm-shape definition replicates 12 times via mirror + 60-degree rotation. Each arm is a thin sliver (sin-based perpendicular distance test) thickened at two perpendicular knobs at r = 0.40 and 0.70 of the cell-half radius — the knobs provide the classic "branched ice crystal" silhouette without needing a separate per-arm subdivision pass. A small filled center dot anchors the motif at small cell sizes where the knobs vanish. Useful for: arctic / winter zones, frost spell effects, frost-mage themed gear icons, holiday-event decoration, crystal-shrine backdrops, snowstorm overlays. Distinct from --gen-texture-snow (random tiny dots, not a patterned crystal) and --gen-texture-frost (spider-web crackle, not radial). The first 6-fold-symmetric texture in the catalogue.
2026-05-09 15:06:32 -07:00
"--gen-texture-damask", "--gen-texture-snowflake",
feat(editor): add --gen-texture-gear-cog mechanical wheel 85th procedural texture: gear-cog wheel pattern tiled per cell. Three concentric radii define the gear: • hub (rNorm < 0.20) — center axle hole, kept as bg • inner (rNorm < 0.65) — gap floor between teeth • outer (rNorm < 0.92) — tooth tip Teeth alternate around the gear via a per-tooth phase calculation: theta is mapped into a tooth period of 2*pi/teeth, with the first half of each period rendering as a tooth (effective radius = outer) and the second half rendering as a gap (effective radius = inner). Useful for: engineering crafting backdrops, mechanical door textures, gnomish / goblin themed gear icons, factory / forge tile sets, clockwork-themed dungeons, steampunk faction insignia, machinery damage states. Distinct from --gen-texture-rings (concentric circles only, no teeth). The first procedural texture in the catalogue that exercises a per-tooth periodic offset rather than a fixed angular fold.
2026-05-09 17:09:32 -07:00
"--gen-texture-gear-cog",
refactor(editor): extract kArgRequired + meta handlers into cli modules Splits the 138-line static-local kArgRequired array (the list of flags requiring positional args) into a new cli_arg_required.{hpp,cpp} module with extern linkage. Then moves the three meta handlers that depended on it out of main.cpp into cli_introspect.cpp: - --validate-cli-help (uses the array for self-check) - --version / -v (3-line printf) - --help / -h (1-line passthrough) main.cpp shrinks by 191 lines (677 to 486). Both the early missing-argument detector in main() and --validate-cli-help in cli_introspect.cpp now share one source of truth for the arg-required list.
2026-05-09 10:08:14 -07:00
"--validate-glb", "--info-glb", "--info-glb-tree", "--info-glb-bytes",
"--validate-jsondbc", "--check-glb-bounds", "--validate-stl",
"--validate-png", "--validate-blp",
"--zone-summary", "--info-zone-tree", "--info-project-tree",
"--info-zone-bytes", "--info-project-bytes",
"--info-zone-extents", "--info-project-extents",
"--info-zone-water", "--info-project-water",
"--info-zone-density", "--info-project-density",
"--export-zone-summary-md", "--export-quest-graph",
"--export-zone-csv", "--export-zone-html", "--export-project-html",
"--export-project-md", "--export-zone-checksum", "--export-project-checksum",
"--validate-project-checksum",
"--scaffold-zone", "--mvp-zone", "--add-tile", "--remove-tile", "--list-tiles",
"--for-each-zone", "--for-each-tile", "--zone-stats", "--info-tilemap",
"--list-zone-deps", "--list-project-orphans", "--remove-project-orphans",
"--check-zone-refs", "--check-zone-content",
"--check-project-content", "--check-project-refs",
"--export-zone-deps-md", "--export-zone-spawn-png",
"--add-creature", "--add-object", "--add-quest", "--add-item",
"--random-populate-zone", "--random-populate-items",
"--info-zone-audio", "--snap-zone-to-ground", "--audit-zone-spawns",
"--info-project-audio", "--snap-project-to-ground",
"--audit-project-spawns", "--list-zone-spawns", "--list-project-spawns",
"--gen-random-zone", "--gen-random-project", "--gen-zone-texture-pack",
"--gen-zone-mesh-pack", "--gen-zone-starter-pack",
"--gen-project-starter-pack", "--gen-audio-tone",
"--gen-audio-noise", "--gen-audio-sweep", "--gen-zone-audio-pack",
"--info-zone-summary", "--info-project-summary",
"--info-zone-deps", "--info-project-deps",
"--gen-zone-readme", "--gen-project-readme",
"--validate-zone-pack", "--validate-project-packs", "--info-spawn",
"--diff-zone-spawns",
"--list-items", "--info-item", "--set-item", "--export-zone-items-md",
"--export-project-items-md", "--export-project-items-csv",
"--add-quest-objective", "--add-quest-reward-item", "--set-quest-reward",
"--remove-quest-objective", "--clone-quest", "--clone-creature",
"--clone-item", "--validate-items", "--validate-project-items",
"--info-project-items",
"--clone-object",
"--remove-creature", "--remove-object", "--remove-quest", "--remove-item",
"--copy-zone-items",
"--copy-zone", "--rename-zone", "--remove-zone",
"--clear-zone-content", "--strip-zone", "--strip-project",
"--repair-zone", "--repair-project",
"--gen-makefile", "--gen-project-makefile",
"--build-woc", "--regen-collision", "--fix-zone",
"--export-png", "--export-obj", "--import-obj",
"--export-wob-obj", "--import-wob-obj",
"--export-woc-obj", "--export-whm-obj",
"--export-glb", "--export-wob-glb", "--export-whm-glb",
"--export-stl", "--import-stl",
"--bake-zone-glb", "--bake-zone-stl", "--bake-zone-obj",
"--bake-project-obj", "--bake-project-stl", "--bake-project-glb",
feat(editor): add --bake-zone-collision aggregator Walks every .wom and .wob under <zoneDir>, optionally welds each one independently (per-mesh / per-WOB-group), and appends its triangles to a single WoweeCollision. Useful for shipping a zone — one .woc artifact holds all object collision so the server side has just one file to load. Per-file weld preserves between-object boundaries: two distinct WOMs sitting at the same world position keep their topology separate even if their corner positions happen to overlap. Same flag surface as the single-file bakers: optional [out.woc] (defaults to <zoneDir>/zone.woc), --weld <eps>, --steep <deg> for the walkable/steep slope cutoff. Smoke tested over /tmp/migtest: scanned 79 WOM + 1 WOB, produced 9259-triangle WOC (1563 walkable, 1943 steep) with correct world bounds.
2026-05-09 11:36:38 -07:00
"--bake-wom-collision", "--bake-wob-collision", "--bake-zone-collision",
feat(editor): add --audit-watertight-wob building QA tool Sibling of --audit-watertight that walks every .wob under <root> and runs the welded watertight check on every group. A WOB passes only if every group is closed — interior rooms in a real building should each be a closed solid even though the building as a whole has intentional portal openings between them. Per-failure detail lists which groups failed and why (boundary edge count + non-manifold edge count). Exit code is the number of failed buildings (capped at 255) — same CI-friendly contract as the WOM audit. Smoke tested against /tmp/migtest cube.wob: PASS, 12 tris, exit code 0.
2026-05-09 11:33:10 -07:00
"--audit-watertight", "--audit-watertight-wob",
refactor(editor): extract kArgRequired + meta handlers into cli modules Splits the 138-line static-local kArgRequired array (the list of flags requiring positional args) into a new cli_arg_required.{hpp,cpp} module with extern linkage. Then moves the three meta handlers that depended on it out of main.cpp into cli_introspect.cpp: - --validate-cli-help (uses the array for self-check) - --version / -v (3-line printf) - --help / -h (1-line passthrough) main.cpp shrinks by 191 lines (677 to 486). Both the early missing-argument detector in main() and --validate-cli-help in cli_introspect.cpp now share one source of truth for the arg-required list.
2026-05-09 10:08:14 -07:00
"--convert-m2", "--convert-m2-batch",
"--convert-wmo", "--convert-wmo-batch",
"--convert-dbc-json", "--convert-dbc-batch", "--convert-json-dbc",
"--convert-blp-png", "--convert-blp-batch",
"--migrate-wom", "--migrate-zone", "--migrate-project",
"--migrate-data-tree", "--info-data-tree", "--strip-data-tree",
"--audit-data-tree",
"--migrate-jsondbc",
};
const std::size_t kArgRequiredSize =
sizeof(kArgRequired) / sizeof(kArgRequired[0]);
} // namespace cli
} // namespace editor
} // namespace wowee
Reference in a new issue Copy permalink