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

241 lines
12 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 --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-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",
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