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

1557 lines
154 KiB
C++
Raw Normal View History

refactor(editor): extract printUsage into cli_help.cpp Pulls the 597-line block of printf calls that emits the --help text out of main.cpp into its own translation unit. printUsage is the longest single function in main.cpp by far and was pure boilerplate (no logic, just a flat list of help lines). Function moved verbatim to wowee::editor::cli::printUsage; all 6 in-tree callers (--list-commands, --info-cli-stats, --info-cli-categories, --info-cli-help, --validate-cli-help, and the bare --help/-h handler) updated to the namespaced name. The CLI-meta commands continue to capture printUsage's stdout the same way, so behavior is identical (verified by re-running --validate-cli-help, --info-cli-stats, --list-commands). main.cpp drops 26,650 → 26,286 lines (-364 net; -597 from the removal, +233 from the include and namespace-prefixing the six call sites... wait, no, +6). Actually main.cpp net delta matches the body extraction.
2026-05-08 20:12:15 -07:00
#include "cli_help.hpp"
#include <cstdio>
namespace wowee {
namespace editor {
namespace cli {
void printUsage(const char* argv0) {
std::printf("Usage: %s --data <path> [options]\n\n", argv0);
std::printf("Options:\n");
std::printf(" --data <path> Path to extracted WoW data (manifest.json)\n");
std::printf(" --adt <map> <x> <y> Load an ADT tile on startup\n");
std::printf(" --convert-m2 <path> Convert M2 model to WOM open format (no GUI)\n");
std::printf(" --convert-m2-batch <srcDir>\n");
std::printf(" Bulk M2→WOM conversion across every .m2 in <srcDir> (per-file pass/fail summary)\n");
std::printf(" --convert-wmo <path> Convert WMO building to WOB open format (no GUI)\n");
std::printf(" --convert-wmo-batch <srcDir>\n");
std::printf(" Bulk WMO→WOB conversion across every .wmo in <srcDir> (skips _NNN group files)\n");
std::printf(" --convert-dbc-batch <srcDir>\n");
std::printf(" Bulk DBC→JSON conversion across every .dbc in <srcDir> (sidecars next to source)\n");
std::printf(" --migrate-data-tree <srcDir>\n");
std::printf(" Run all four bulk converters (m2/wmo/blp/dbc) end-to-end on an extracted Data tree\n");
std::printf(" --info-data-tree <srcDir> [--json]\n");
std::printf(" Per-format migration-progress report (m2 vs wom, wmo vs wob, blp vs png, dbc vs json)\n");
std::printf(" --strip-data-tree <srcDir> [--dry-run]\n");
std::printf(" Delete proprietary files (.m2/.wmo/.blp/.dbc) that already have an open sidecar\n");
std::printf(" --audit-data-tree <srcDir>\n");
std::printf(" CI gate: exit 1 if any proprietary file lacks an open sidecar (100%% migration check)\n");
std::printf(" --bench-migrate-data-tree <srcDir> [--json]\n");
std::printf(" Time each step of --migrate-data-tree (m2/wmo/blp/dbc) and report wall-clock per step\n");
std::printf(" --list-data-tree-largest <srcDir> [N]\n");
std::printf(" Top-N largest proprietary files (.m2/.wmo/.blp/.dbc) for migration prioritization\n");
std::printf(" --export-data-tree-md <srcDir> [out.md]\n");
std::printf(" Markdown migration-progress report (per-pair table, share %%, recommended next steps)\n");
std::printf(" --gen-texture <out.png> <colorHex|pattern> [W H]\n");
std::printf(" Synthesize a placeholder texture (solid hex color or 'checker'/'grid'); default 256x256\n");
std::printf(" --gen-texture-gradient <out.png> <fromHex> <toHex> [vertical|horizontal] [W H]\n");
std::printf(" Synthesize a linear gradient PNG (default vertical, 256x256)\n");
std::printf(" --gen-texture-noise <out.png> [seed] [W H]\n");
std::printf(" Synthesize a smooth value-noise PNG (deterministic from seed; default 256x256)\n");
std::printf(" --gen-texture-noise-color <out.png> <colorAHex> <colorBHex> [seed] [W H]\n");
std::printf(" Same noise pattern but blended between two colors instead of grayscale\n");
std::printf(" --gen-texture-radial <out.png> <centerHex> <edgeHex> [W H]\n");
std::printf(" Synthesize a radial gradient PNG (center→edge, smooth distance-based blend)\n");
std::printf(" --gen-texture-stripes <out.png> <colorAHex> <colorBHex> [stripePx] [diagonal|horizontal|vertical] [W H]\n");
std::printf(" Synthesize a two-color stripe pattern (default 16px diagonal, 256x256)\n");
std::printf(" --gen-texture-dots <out.png> <bgHex> <dotHex> [dotRadius] [spacing] [W H]\n");
std::printf(" Synthesize a polka-dot pattern (default radius 8, spacing 32, 256x256)\n");
std::printf(" --gen-texture-rings <out.png> <colorAHex> <colorBHex> [ringPx] [W H]\n");
std::printf(" Synthesize concentric ring pattern (target/seal style; default 16px rings, 256x256)\n");
std::printf(" --gen-texture-checker <out.png> <colorAHex> <colorBHex> [cellPx] [W H]\n");
std::printf(" Synthesize checkerboard with custom colors (gen-texture's checker is BW only)\n");
std::printf(" --gen-texture-brick <out.png> <brickHex> <mortarHex> [brickW] [brickH] [mortarPx] [W H]\n");
std::printf(" Brick wall pattern with offset rows + mortar lines (default 64×24, 4px mortar)\n");
std::printf(" --gen-texture-wood <out.png> <lightHex> <darkHex> [grainSpacing] [seed] [W H]\n");
std::printf(" Wood grain pattern with vertical streaks + knots (default spacing 12px, seed 1)\n");
std::printf(" --gen-texture-grass <out.png> <baseHex> <bladeHex> [density] [seed] [W H]\n");
std::printf(" Tiling grass texture with random blade highlights (default density=0.15, seed=1)\n");
std::printf(" --gen-texture-fabric <out.png> <warpHex> <weftHex> [threadPx] [W H]\n");
std::printf(" Woven fabric pattern with alternating warp/weft threads (default thread=4px)\n");
std::printf(" --gen-texture-cobble <out.png> <stoneHex> <mortarHex> [stonePx] [seed] [W H]\n");
std::printf(" Cobblestone street pattern: irregular packed stones (default stone=24px, seed 1)\n");
std::printf(" --gen-texture-marble <out.png> <baseHex> <veinHex> [seed] [veinSharpness] [W H]\n");
std::printf(" Marble pattern with sinusoidal veining (default seed 1, sharpness 8)\n");
std::printf(" --gen-texture-metal <out.png> <baseHex> [seed] [orientation] [W H]\n");
std::printf(" Brushed metal: directional anisotropic noise (orientation: horizontal|vertical)\n");
std::printf(" --gen-texture-leather <out.png> <baseHex> [seed] [grainSize] [W H]\n");
std::printf(" Leather grain: irregular pebbled bumps via cellular noise (default grain=4px)\n");
std::printf(" --gen-texture-sand <out.png> <baseHex> [seed] [rippleSpacing] [W H]\n");
std::printf(" Sand dunes: per-pixel grain noise + sinusoidal ripple bands (default ripple=24px)\n");
std::printf(" --gen-texture-snow <out.png> <baseHex> [seed] [sparkleDensity] [W H]\n");
std::printf(" Snow: soft cool-white base + scattered bright sparkle pixels (default density=0.005)\n");
feat(editor): add --gen-texture-lava molten-rock pattern Worley cellular noise where each cell is a chunk of cooled crust and the inter-cell boundaries glow as bright cracks of exposed magma. Each pixel finds its 2 nearest jittered cell centers; pixels close to the boundary (small gap between distances) become hot, with a soft penumbra falling off into the dark crust interior. Defaults: crackScale=32px, seed=1. Useful for volcanic zones, elemental dungeons, lava lakes. Brings the procedural texture pattern set to 22.
2026-05-08 20:33:45 -07:00
std::printf(" --gen-texture-lava <out.png> <darkHex> <hotHex> [seed] [crackScale] [W H]\n");
std::printf(" Lava: dark cooled crust with bright glowing cracks via Worley cell boundaries\n");
feat(editor): add --gen-texture-tile square stone tile pattern Per-cell pattern: each pixel falls into a tile cell with grout on every grid edge. Tiles get a stable per-tile shade jitter (via integer-cell hash) so adjacent tiles look distinct rather than identical. Grout is the constant separator color. First new texture added directly to cli_gen_texture.cpp instead of main.cpp — proves the modular pattern works for new additions, not just extractions. Defaults: tilePx=32, groutPx=2. Useful for floors, plaza paving, dungeon walls. Brings the procedural texture pattern set to 23.
2026-05-08 22:01:31 -07:00
std::printf(" --gen-texture-tile <out.png> <tileHex> <groutHex> [tilePx] [groutPx] [W H]\n");
std::printf(" Square stone tiles with grout grid (default 32px tiles, 2px grout)\n");
feat(editor): add --gen-texture-bark tree-bark pattern Vertical streaks of varying brightness (per-column hash gives each streak a stable shade in 0.85..1.10) sway-warped per-row via a slow cosine offset, plus dark vertical cracks at random columns where bark splits as the trunk expands. Defaults: density=0.04 (~4% of columns become cracks), seed=1. Useful for tree-trunk textures, wooden palisades, bark-clad buildings. Brings the procedural texture pattern set to 24.
2026-05-08 23:15:03 -07:00
std::printf(" --gen-texture-bark <out.png> <baseHex> <crackHex> [seed] [crackDensity] [W H]\n");
std::printf(" Tree bark: vertical wavy streaks + dark vertical cracks (default density=0.04)\n");
feat(editor): add --gen-texture-clouds sky pattern Multi-octave cosine-product noise (4 octaves at doubling frequency, halving amplitude) thresholded by `coverage` so values above the threshold blend toward cloud color and below fade to sky. A 0.15-wide smoothstep band feathers cloud edges instead of stepping hard. Defaults: coverage=0.5 (mixed clouds), seed=1. Useful for skybox cubemaps, distant sky planes, atmospheric backdrop art. Brings the procedural texture pattern set to 25.
2026-05-09 00:20:14 -07:00
std::printf(" --gen-texture-clouds <out.png> <skyHex> <cloudHex> [seed] [coverage] [W H]\n");
std::printf(" Sky with puffy clouds: multi-octave noise thresholded by coverage (default 0.5)\n");
feat(editor): add --gen-texture-stars night-sky pattern Solid background fill plus randomly placed stars at varied brightness — most stars dim (30-65% blend toward star color), occasional bright stars (85-100% blend) — so the sky reads with depth rather than as uniform noise. Exit log breaks down how many bright vs faint stars actually landed. Defaults: density=0.005 (~0.5% of pixels become stars), seed=1. Useful for skybox top-faces, distant night sky planes, magical constellation set dressing. Brings the procedural texture pattern set to 26.
2026-05-09 01:32:08 -07:00
std::printf(" --gen-texture-stars <out.png> <bgHex> <starHex> [seed] [density] [W H]\n");
std::printf(" Night sky with scattered stars (varied brightness, density 0..1, default 0.005)\n");
feat(editor): add --gen-texture-vines climbing-plant pattern Solid wall background plus N vine paths that walk upward from the bottom edge with a smooth cosine drift + tiny per-step horizontal jitter. Each vine paints 2 pixels wide on every row it visits so the trail reads as a thin band rather than a single-pixel line. Defaults: vineCount=8, seed=1. Useful for ruined castle walls, overgrown ruins, jungle temple textures, ivy-covered facades. Brings the procedural texture pattern set to 27.
2026-05-09 02:37:06 -07:00
std::printf(" --gen-texture-vines <out.png> <wallHex> <vineHex> [seed] [vineCount] [W H]\n");
std::printf(" Wall with climbing vines: meandering vertical paths via random walk (default 8 vines)\n");
feat(editor): add --gen-texture-mosaic 3-color tile pattern Per-cell hash picks one of 3 colors for each square tile, with 1-pixel black grout on the top + left edges of every cell so tiles read as physically separated. Exit log breaks down how many tiles got each color so callers can verify the seed distribution. Defaults: tilePx=16, seed=1. Useful for cathedral floors, stained-glass set dressing, ornate plaza paving. Brings the procedural texture pattern set to 28.
2026-05-09 03:23:01 -07:00
std::printf(" --gen-texture-mosaic <out.png> <colorAHex> <colorBHex> <colorCHex> [tilePx] [seed] [W H]\n");
std::printf(" 3-color mosaic: small square tiles with random color picks + grout (default 16px)\n");
feat(editor): add --gen-texture-rust oxidized-metal pattern 3-octave smooth noise field thresholded by `coverage` to make rust blob regions, blended with the metal base color via a 0.12-wide smoothstep so patches feather into clean metal rather than stepping. Per-pixel grain jitter on top so neither material reads as flat. Defaults: coverage=0.4 (~40% rust), seed=1. Useful for weathered armor, abandoned machinery, ruined castle gates, shipwreck debris. Brings the procedural texture pattern set to 29.
2026-05-09 04:01:49 -07:00
std::printf(" --gen-texture-rust <out.png> <metalHex> <rustHex> [seed] [coverage] [W H]\n");
std::printf(" Metal with rust patches: noise blob threshold + per-pixel grain (default coverage=0.4)\n");
feat(editor): add --gen-texture-circuit sci-fi PCB pattern Solid PCB background plus N traces that walk the surface in orthogonal Manhattan style — each trace alternates random horizontal + vertical segments (3-6 segments per trace, 8-32 px each), with a 3×3 "via" dot at every corner so the routing reads as intentional rather than random scribbles. Defaults: traceCount=24, seed=1. Useful for sci-fi panels, hacker zones, magitek/arcanocore set dressing, robot texture details. Brings the procedural texture pattern set to 30.
2026-05-09 04:42:31 -07:00
std::printf(" --gen-texture-circuit <out.png> <pcbHex> <traceHex> [seed] [traceCount] [W H]\n");
std::printf(" Sci-fi PCB pattern: orthogonal traces with right-angle turns + via dots (default 24 traces)\n");
feat(editor): add --gen-texture-coral branching reef pattern Water-color background with N branching coral structures that grow from the bottom edge upward. Each branch walks a curved path (random angle drift) drawing a thick stroke, splitting into thinner sub-branches at random intervals so the result reads as organic coral rather than straight lines. Iterative stack-based growth (no recursion) with split cap at 256 to bound runtime. Defaults: branchCount=12, seed=1. Useful for underwater zones, ocean floor, mer-people set dressing, swamp coral fungi. Brings the procedural texture pattern set to 31.
2026-05-09 05:11:40 -07:00
std::printf(" --gen-texture-coral <out.png> <waterHex> <coralHex> [seed] [branchCount] [W H]\n");
std::printf(" Coral reef: branching tree shapes via random angle walks (default 12 branches)\n");
feat(editor): add --gen-texture-flame fire pattern Vertical color gradient from dark (bottom) to hot (top), mixed with multi-octave smooth noise so the flame boundary wavers randomly rather than reading as a clean horizontal line. Vertical position curve is squared so the dark stays dark longer and the hot saturates faster — matches real-flame appearance where most of the body is dark with a bright tip. Useful for torches, braziers, magical effects, lava-zone set dressing, fireplace texture details. Brings the procedural texture pattern set to 32.
2026-05-09 05:38:18 -07:00
std::printf(" --gen-texture-flame <out.png> <darkHex> <hotHex> [seed] [W H]\n");
std::printf(" Flame: vertical color gradient from dark base to hot top with noise flicker\n");
feat(editor): add --gen-texture-tartan plaid pattern 3-color crossing-band pattern: 6-band repeat sequence (A A B C C B) per axis, with the pixel color at any position being the average of the horizontal-band and vertical-band colors. That averaging at intersections produces the characteristic diamond grid of Scottish tartans without explicit "weave" math — the band overlap pattern just falls out. Defaults: bandPx=32 (repeat=192px). Useful for clan banners, kilts, blanket textures, fabric set dressing. Brings the procedural texture pattern set to 33.
2026-05-09 06:02:13 -07:00
std::printf(" --gen-texture-tartan <out.png> <colorAHex> <colorBHex> <colorCHex> [bandPx] [W H]\n");
std::printf(" Tartan plaid: 3-color crossing bands forming Scottish-style overlap pattern\n");
feat(editor): add --gen-texture-argyle sweater-knit pattern 31st procedural texture: classic argyle pattern done by working in a 45-rotated coord system (u, v) = (x+y, x-y) so lozenges become axis-aligned squares for the checkerboard step. Diagonal stitch lines fall out of u%cell and v%cell crossing zero. Three-color: A/B for the alternating diamond fill, third color for the diagonal stitch overlay. Defaults to 64-pixel cells with 2-pixel stitches. Useful for sweater fabric, seat cushions, heraldic banner overlays.
2026-05-09 06:29:16 -07:00
std::printf(" --gen-texture-argyle <out.png> <colorAHex> <colorBHex> <stitchHex> [cellPx] [W H]\n");
std::printf(" Argyle: 45-rotated lozenge checkerboard with diagonal stitch lines (sweater knit)\n");
feat(editor): add --gen-texture-herringbone chevron pattern 32nd procedural texture: classic V-shaped herringbone done as horizontal strips of parallel slanted lines whose slant direction flips every strip. Implementation is a per-pixel shear: shifting x by the row's local-y collapses each diagonal into a vertical band in shifted-x space, so a single modulo picks line vs background. Useful for parquet floors, brick patios, fabric weaves, fish scale-style chain mail, anywhere needing a strong directional pattern. Two-color, defaults to 32-px strips with 12-px line spacing and 4-px line width.
2026-05-09 06:49:29 -07:00
std::printf(" --gen-texture-herringbone <out.png> <bgHex> <lineHex> [stripH] [lineSpacing] [lineWidth] [W H]\n");
std::printf(" Herringbone: slanted parallel lines that flip direction every strip (chevron / fish-bone)\n");
feat(editor): add --gen-texture-scales overlapping-circle pattern 33rd procedural texture: fish / dragon / chain mail scales done as a half-row-staggered grid of circles whose centers sit at the bottom-center of each cell. Adjacent rows offset by half a cell width, with circle radius slightly larger than half the cell, so the circles interlock into the classic overlapping-scale look. Three colors: background fills the gaps, scale body fills most of each circle, and a rim color highlights the top arc to give the raised / armored feel. Defaults to 24×16 cells; scaled by cellW × cellH for fine control of scale density. Useful for chain mail, dragonhide, fish skin, roof shingles, anywhere needing tiled curved scales.
2026-05-09 07:06:29 -07:00
std::printf(" --gen-texture-scales <out.png> <bgHex> <scaleHex> <rimHex> [cellW] [cellH] [W H]\n");
std::printf(" Scales: half-row-staggered overlapping circles forming fish/dragon/chain-mail look\n");
feat(editor): add --gen-texture-stained-glass voronoi pattern 34th procedural texture: cathedral / magical-window stained glass done as a Voronoi-cell tessellation. Each pixel snaps to its nearest seed point; pixels near a cell boundary (small relative gap to the second-nearest seed) become the lead color producing the leaded-glass dividers between colored regions. Three stained colors cycle across cells (cellIdx % 3) for a balanced palette without per-cell color authoring. Defaults to 32 cells in 256x256, using ratio-based boundary detection so lead-line thickness scales naturally with cell density. Useful for cathedral windows, mage tower decals, magical portals, ritual circle backdrops.
2026-05-09 07:19:02 -07:00
std::printf(" --gen-texture-stained-glass <out.png> <leadHex> <colorAHex> <colorBHex> <colorCHex> [cells] [W H]\n");
std::printf(" Stained glass: Voronoi cells in 3-color rotation, separated by dark lead lines\n");
feat(editor): add --gen-texture-shingles roof-tile pattern 35th procedural texture: roof shingles done as half-row-staggered rows of rectangular tiles. Three colors: shingle base, a shadow band at the top of each row (where the row above overlaps), and thin vertical seams between adjacent shingles in the same row. The half-row stagger comes from the standard roofing convention of offsetting alternate courses by half a tile width — gives the classic interlocked look that pure brick patterns lack. Useful for roofs, scale armor close-ups, fish bellies, anywhere needing tightly-packed offset rectangles. Defaults to 32x24 shingles with 4-px shadow + 1-px seams.
2026-05-09 07:30:50 -07:00
std::printf(" --gen-texture-shingles <out.png> <baseHex> <shadowHex> <seamHex> [shingleW] [shingleH] [shadowH] [W H]\n");
std::printf(" Roof shingles: half-offset rows of rectangular tiles with shadow band + vertical seams\n");
feat(editor): add --gen-texture-frost crystal-rosette pattern 36th procedural texture: scattered ice nuclei with 6-spike rosettes radiating at 60 deg intervals. Each spike's pixel intensity falls linearly from full at the seed to zero at the end of the ray, so spikes fade naturally into the background. Per-seed angular jitter prevents all rosettes from aligning to the same orientation. Useful for winter zones, ice biomes, frosted-window decals, magical cold-effect overlays. Defaults to 80 seeds with 18-px rays in 256x256.
2026-05-09 07:41:17 -07:00
std::printf(" --gen-texture-frost <out.png> <bgHex> <iceHex> [seeds] [rayLen] [W H]\n");
std::printf(" Frost: scattered crystal nuclei with 6-spike rosettes that fade with distance\n");
feat(editor): add --gen-texture-parquet basket-weave wood floor 37th procedural texture: basket-weave parquet flooring done as a checkerboard of 2N x 2N cells. Half the cells are split into two horizontal planks (wood A); the other half are split into two vertical planks (wood B). Adjacent perpendicular pairs form the classic interlocked basket-weave. A third "gap" color paints thin lines along plank edges and the cell midline, giving the inset / wood-joint appearance. Defaults to 32-px cells with 1-px gaps. Useful for parlour floors, manor halls, magical libraries, dwarven flooring.
2026-05-09 07:52:29 -07:00
std::printf(" --gen-texture-parquet <out.png> <woodAHex> <woodBHex> <gapHex> [cellSize] [gapW] [W H]\n");
std::printf(" Parquet: basket-weave wood floor pattern with checkered horizontal/vertical plank pairs\n");
feat(editor): add --gen-texture-bubbles overlapping-circle pattern 38th procedural texture: scattered bubbles done as randomly- placed circles of varied radii, with bright rim outlines that stay visible even where bubbles overlap (rim color wins on any pixel that lies in any bubble's ring band). Three colors: background, translucent-feeling fill for the bubble interior, and a bright rim. Defaults to 50 bubbles of radius 6-24 px with 2-px rims. Useful for water surfaces, foam patches, soap suds, magical-effect overlays, slime particle effects.
2026-05-09 08:03:54 -07:00
std::printf(" --gen-texture-bubbles <out.png> <bgHex> <fillHex> <rimHex> [count] [minR] [maxR] [rimW] [W H]\n");
std::printf(" Bubbles: scattered overlapping circles with bright rims (foam, water, magic)\n");
feat(editor): add --gen-texture-spider-web radial-ring pattern 39th procedural texture: classic geometric spider web — N radial spokes plus M concentric polygonal rings centered on the image. Spoke pixels are detected by angular distance to the nearest spoke scaled by radius, so spokes stay constant pixel width regardless of how far they reach. Useful for haunted house decals, dungeon corner overlays, witch-hut interiors, magical-trap ground markers. Defaults to 8 spokes (every 45 deg) and 5 evenly-spaced rings.
2026-05-09 08:14:04 -07:00
std::printf(" --gen-texture-spider-web <out.png> <bgHex> <webHex> [spokes] [rings] [W H]\n");
std::printf(" Spider web: N radial spokes + M concentric polygonal rings centered on the image\n");
feat(editor): add --gen-texture-gingham 3-tone fabric pattern 40th procedural texture: classic gingham picnic-blanket / shirt fabric — two perpendicular sets of stripes with a darker color where they cross. The crossing creates the characteristic 3-tone checker pattern that's distinct from plain --gen-texture-checker (solid blocks). Useful for picnic blankets, country tablecloths, NPC shirt textures, fabric set dressing. Defaults to 16-px stripe spacing with 8-px stripe width (50% coverage per axis).
2026-05-09 08:24:12 -07:00
std::printf(" --gen-texture-gingham <out.png> <bgHex> <stripeHex> <crossHex> [spacing] [width] [W H]\n");
std::printf(" Gingham: 3-tone fabric — bg + perpendicular stripes + darker color where they cross\n");
feat(editor): add --gen-texture-lattice diagonal-grid pattern 41st procedural texture: garden trellis / mesh fence done as two perpendicular sets of diagonal lines (+45° and -45°) drawn simultaneously across the whole image so they form diamond-shaped openings between the lines. Distinct from --gen-texture-herringbone (which alternates strip orientation): lattice draws both diagonal sets at every pixel. Useful for trellises, wire mesh fences, dragon-scale chain mail, decorative window grilles. Defaults to 24-px line spacing with 3-px line width.
2026-05-09 08:40:14 -07:00
std::printf(" --gen-texture-lattice <out.png> <bgHex> <lineHex> [spacing] [width] [W H]\n");
std::printf(" Lattice: ±45° diagonal grid forming diamond openings (garden trellis / mesh fence)\n");
feat(editor): add --gen-texture-honeycomb hexagonal-cell pattern 42nd procedural texture: hexagonal cell tiling produced by Voronoi over a triangular seed lattice — alternating-row hex seeds at horizontal step sqrt(3)*s and vertical step 1.5*s naturally produce perfect hexagonal Voronoi cells without needing the full pointy-top hex-tile math. Border pixels are detected by ratio of second-nearest / nearest seed distances (1.04x threshold) so border thickness scales naturally with hex size and stays a couple of pixels across the whole image. Useful for beehives, dragon scales, sci-fi panels, magical wards, mosaic tile floors. Defaults to 16-px hex side.
2026-05-09 08:49:51 -07:00
std::printf(" --gen-texture-honeycomb <out.png> <fillHex> <borderHex> [hexSide] [W H]\n");
std::printf(" Honeycomb: hexagonal cells via Voronoi over a triangular seed lattice\n");
feat(editor): add --gen-texture-cracked branching-walk pattern 43rd procedural texture: organic crack network done via recursive random walks from N seed nuclei. Each seed spawns a crack that walks in a random direction for some length, then with 60% chance branches into one or two more cracks of half-remaining length. Most cracks die out after a step or two, a few branch into longer networks — the bias matches real-world fissure formation. Useful for cracked mud, dry earth, broken glass, weathered stone, dragon skin overlays, ice-shard effects. Defaults to 12 seeds at 40-px max length. Iterative DFS instead of true recursion so deep branching chains never blow the stack.
2026-05-09 09:06:56 -07:00
std::printf(" --gen-texture-cracked <out.png> <bgHex> <crackHex> [seeds] [maxLength] [W H]\n");
std::printf(" Cracked: branching random walks form fissures (mud / glass / dry earth)\n");
feat(editor): add --gen-texture-runes magical-glyph pattern 44th procedural texture: scattered angular runes drawn as 3-5 random stroke segments per glyph. Each stroke uses one of 8 cardinal/diagonal angles (0/45/90/135/...°) so the strokes read as deliberate runic carvings rather than random scribbles. Layout is a sparse grid with per-slot jitter and ~5% empty slots so the result looks hand-carved rather than mechanical. Useful for ancient ruins, magical zones, dwarven walls, necromancer altars, druidic shrines. Defaults to a 64-px grid spacing yielding ~15 runes in a 256×256 image.
2026-05-09 09:42:10 -07:00
std::printf(" --gen-texture-runes <out.png> <bgHex> <runeHex> [gridSpacing] [W H]\n");
std::printf(" Runes: scattered angular glyphs of 3-5 strokes each (8 cardinal/diagonal angles)\n");
feat(editor): add --gen-texture-leopard animal-print pattern 45th procedural texture: leopard print spots done as the union of 4 small overlapping sub-circles per spot. The sub-circle offsets are jittered per-spot so each spot has an irregular non-circular silhouette without authoring per- spot polygons. Two-color (bg + spot) for the classic leopard look. Useful for animal-print fabric, fur tiles, druidic robes, shamanic hide drums, hunter armor textures. Defaults to 60 spots of ~8-px radius across 256×256.
2026-05-09 09:51:58 -07:00
std::printf(" --gen-texture-leopard <out.png> <bgHex> <spotHex> [count] [radius] [W H]\n");
std::printf(" Leopard: irregular spots (4 sub-circles each) for animal-print fabric/fur\n");
feat(editor): add --gen-texture-zebra wavy-stripe pattern 46th procedural texture: zebra-print stripes — base horizontal stripes with a sinusoidal y-shift in x so they undulate organically rather than aligning to the row grid. Two-color (bg + stripe) for the iconic black-on-white animal- print effect. Each pixel computes y + amplitude*sin(2π*x/wavelength) then mods by the stripe period. Useful for animal-print fabric, savanna grass mats, tribal clothing, fur tiles. Defaults to 24-px period with 8-px amplitude on an 80-px wavelength wave.
2026-05-09 10:03:27 -07:00
std::printf(" --gen-texture-zebra <out.png> <bgHex> <stripeHex> [period] [amplitude] [wavelength] [W H]\n");
std::printf(" Zebra: wavy parallel stripes via sinusoidal y-shift (animal-print stripes)\n");
feat(editor): add --gen-texture-knit V-stitch fabric pattern 47th procedural texture: knit fabric V-stitch — each stitch occupies a cellW x cellH cell holding the V-shape made by two diagonal strokes meeting at the apex (cellW/2, 0) and dropping to the cell's bottom corners. Cells tile contiguously in both axes giving the iconic chevron-zigzag appearance of knitted fabric stitches. Useful for sweater fabric, woolly NPC clothing, blanket textures, mitten/scarf set dressing, dwarven knitwork. Defaults to 16x12 cells with 2-px stroke width.
2026-05-09 10:18:22 -07:00
std::printf(" --gen-texture-knit <out.png> <bgHex> <stitchHex> [cellW] [cellH] [strokeW] [W H]\n");
std::printf(" Knit: V-stitch chevron-zigzag pattern reading as knitted fabric stitches\n");
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
std::printf(" --gen-texture-chainmail <out.png> <bgHex> <ringHex> [cellW] [cellH] [ringR] [strokeW] [W H]\n");
std::printf(" Chainmail: brick-offset ring outlines for armor/mail textures (interlocking metal rings)\n");
feat(editor): add --gen-texture-planks floor-board pattern 49th procedural texture: horizontal plank-floor pattern. Each plank gets: • a hash-derived per-plank brightness offset (-24..+24) so adjacent boards read as separate pieces of wood rather than one long stripe • a 1px horizontal seam at its bottom edge • a 1px vertical end-seam at a hash-jittered x position, staggering plank ends across rows • optional darker grain streaks at evenly-spaced columns (jittered per plank so the pattern doesn't grid-align) Useful for inn/tavern floors, ship deck planking, bridge surfaces, market-stall counters, and any wood-floor surface where the existing single-grain --gen-texture-wood would read as one giant board. Default 16px plank height with 5 grain streaks gives a recognizable floor at 256x256 without aliasing.
2026-05-09 10:44:13 -07:00
std::printf(" --gen-texture-planks <out.png> <bgHex> <seamHex> [plankH] [grains/plank] [seed] [W H]\n");
std::printf(" Planks: horizontal floor boards with per-plank tint, grain streaks, and stagger seams\n");
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
std::printf(" --gen-texture-corrugated <out.png> <bgHex> <hiHex> [period] [v|h] [W H]\n");
std::printf(" Corrugated: smooth cosine ridges between bg and hi (sheet-metal roofing / siding)\n");
feat(editor): add --gen-texture-rope twisted-cordage pattern 51st procedural texture: two interleaved sinusoidal strands running along the Y axis. Each strand's X position oscillates as W/4·sin(2π·y/period); the second strand is phase-shifted by π so the two snake around each other forming the classic helical twist of a tightened rope. Within each strand, brightness rises from 0.55 at the edge to 1.0 at the centerline (cos² falloff) — gives the rounded 3D appearance of cylindrical fibers without a separate shadow pass. Useful for hanging ropes, ship rigging, tied-bundle textures, suspension bridges, market-stall awning ties, and any "twisted cord" surface where a flat color would read as ribbon rather than rope. Default 24-pixel period with 8-pixel strands renders cleanly at 256x256 with about 10 visible twists.
2026-05-09 11:03:33 -07:00
std::printf(" --gen-texture-rope <out.png> <bgHex> <ropeHex> [period] [strandW] [W H]\n");
std::printf(" Rope: two interleaved sinusoidal strands with cylindrical highlight (twisted cordage)\n");
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
std::printf(" --gen-texture-caustics <out.png> <bgHex> <hiHex> [period] [W H]\n");
std::printf(" Caustics: 4 superimposed sine waves (x/y/x+y/x-y) producing diamond-mesh water shimmer\n");
feat(editor): add --gen-texture-starburst radial-rays pattern 53rd procedural texture: N rays radiating from the texture center. Each pixel computes its angle via atan2 and finds the angular distance to the nearest ray axis (handling the ±π wrap so rays around the seam are continuous). Pixels inside any ray's angular band get the ray color. Brightness tapers linearly with distance from center: 1.0 at the hub, 0.4 at the texture diagonal — gives sun-rays that fade as they extend outward instead of reading as infinite lines. Useful for sun motifs, holy/divine symbols, paladin insignias, mage-robe trim, mosaic medallion centers, shrine floor inlays, and any "radiant glory" surface.
2026-05-09 11:20:31 -07:00
std::printf(" --gen-texture-starburst <out.png> <bgHex> <rayHex> [rays] [beamWidth] [W H]\n");
std::printf(" Starburst: N rays radiating from center with linear falloff (sun / holy symbol / mosaic hub)\n");
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
std::printf(" --gen-texture-studs <out.png> <bgHex> <studHex> [stride] [studR] [W H]\n");
std::printf(" Studs: rivet grid with derived inner highlight (3D rivet/stud appearance for armor + leather)\n");
feat(editor): add --gen-texture-moss organic-mottling pattern 55th procedural texture: irregular spots scattered on a hash- jittered grid. Each cell tests its 8 neighbors so spots near cell boundaries don't get clipped at the cell wall. Per-cell hashing controls: • presence — density 0-100 chance the cell hosts a spot • position — uniform jitter inside the cell • radius — 25-75 % of stride, so adjacent spots vary in size Result reads as random patches of organic growth rather than a visible lattice. Useful for forest floors, weathered stone walls, dungeon flagstones, swamp ground, ruined-temple overlay, fungal-cavern detail. Default 16-stride / 70-density on a stone-grey base reads cleanly at 256x256 with about half the surface mossed over.
2026-05-09 11:38:03 -07:00
std::printf(" --gen-texture-moss <out.png> <bgHex> <mossHex> [stride] [density 0-100] [seed] [W H]\n");
std::printf(" Moss: irregular spots scattered on a hash-jittered grid (forest floor / weathered stone / swamp)\n");
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
std::printf(" --gen-texture-woodgrain <out.png> <lightHex> <darkHex> [spacing] [seed] [W H]\n");
std::printf(" Woodgrain: concentric annual rings centered off-image with per-ring jitter (end-cut wood)\n");
feat(editor): add --gen-texture-carbon fiber-weave pattern 57th procedural texture: 2x2 cell pattern where alternating cells hold horizontal vs vertical fiber segments. Each segment gets a sin² brightness profile across its perpendicular axis — 0 at the segment edge, peak at center — giving the rounded highlight of a real woven fiber bundle. Cell-pair parity (cx + cy) % 2 determines orientation, so adjacent cells always alternate weave direction in both X and Y. Reads as the unmistakable carbon-fiber checkerboard even at small scales. Useful for sci-fi armor, sleek tech panels, vehicle bodies, ritual obsidian inlays, dwarven runeplate accents — any "machined composite" surface where flat dark grey would read as plain plastic. Default 12-pixel cell at 256x256 reads cleanly with about 21 visible weave segments per side.
2026-05-09 11:49:20 -07:00
std::printf(" --gen-texture-carbon <out.png> <bgHex> <fiberHex> [cellSize] [W H]\n");
std::printf(" Carbon-fiber: 2x2 alternating-orientation weave with sin² fiber highlights (sci-fi/tech panels)\n");
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
std::printf(" --gen-texture-pinstripe <out.png> <bgHex> <lineHex> [stride] [lineW] [featureEvery] [W H]\n");
std::printf(" Pinstripe: thin vertical lines at every stride; every Nth stripe is doubled-thick feature line\n");
feat(editor): add --gen-texture-camo woodland-disruption pattern 59th procedural texture: 2-octave bilinear value noise thresholded into hard bg/fg blobs. Sharp edges read as real military camouflage rather than the smooth gradient --gen-texture-noise-color produces. Two octaves combined at 0.7/0.3 weights: • low frequency at cellSize lattice → large dominant blobs • high frequency at cellSize/4 lattice → finer mottling overlay so blob edges aren't perfectly smooth Threshold parameter shifts the bg/fg balance — lower values expose more accent color (good for leaf-pattern), higher values keep the dominant color dominant (good for rock/sand). Useful for guard cloaks, military uniforms, ghillie suits, druid robes, hunter blinds, scout cloaks. First procedural texture to use the new savePngOrError helper from cli_png_emit.hpp.
2026-05-09 12:01:11 -07:00
std::printf(" --gen-texture-camo <out.png> <aHex> <bHex> [cellSize] [threshold] [seed] [W H]\n");
std::printf(" Camouflage: 2-octave value noise thresholded into hard bg/fg blobs (woodland disruption pattern)\n");
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
std::printf(" --gen-texture-snake-skin <out.png> <bgHex> <scaleHex> [cellW] [cellH] [outlineW] [W H]\n");
std::printf(" Snake skin: brick-offset diamond scales (L1 metric) with derived dark outline (reptile / dragon hide)\n");
feat(editor): add --gen-texture-mesh-screen orthogonal grid 61st procedural texture: thin horizontal + vertical wires forming an axis-aligned grid. Distinct from --gen-texture-lattice (which uses ±45° diagonals to make diamond openings) — this gives the right-angle window- screen / chain-link / sci-fi-grille look. Tested per-axis: a row is "on a wire" if (y % stride) < wireW; a pixel falls on a wire if either its row OR its column tests positive. Result is the unmistakable orthogonal-mesh appearance. Useful for window screens, anti-pest grates, fish nets, sewer grilles, sci-fi vent panels, prison-cell windows, goblin-workshop catwalks. Default 12-stride / 2-wide gives a coarse mesh; finer versions read as bug screen.
2026-05-09 12:14:10 -07:00
std::printf(" --gen-texture-mesh-screen <out.png> <bgHex> <wireHex> [stride] [wireW] [W H]\n");
std::printf(" Mesh-screen: orthogonal H+V wire grid (window screen / chain-link / sci-fi grille)\n");
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
std::printf(" --gen-texture-bamboo <out.png> <bgHex> <bambooHex> [stalkW] [nodeY] [nodeBand] [seed] [W H]\n");
std::printf(" Bamboo: vertical stalks with sin² shading + horizontal node bands (jungle / asian-themed)\n");
feat(editor): add --gen-texture-blueprint drafting-paper grid 63rd procedural texture: minor + major grid lines on a base. Minor lines at every `minorStride` pixels (default 16); every `majorEvery` minor lines a thicker major line is drawn (default every 4). Both axes get the same treatment so the result is a sectioned drafting / engineer's paper look. Distinct from --gen-texture-mesh-screen (uniform line weight) — this is the periodic-emphasis variant. Good for: • drafting-table surfaces • technical-schematic backdrops • architect-shop / cartographer-shop walls • engineer / scholar ritual tables • star-chart room floors Default 16-stride / every-4-major gives the classic blue graph-paper aesthetic at 256x256. First procedural texture that takes 4 numeric layout params plus W/H — exercises the new parseOpt* helpers across more args than usual.
2026-05-09 12:27:15 -07:00
std::printf(" --gen-texture-blueprint <out.png> <bgHex> <lineHex> [minorStride] [majorEvery] [minorW] [majorW] [W H]\n");
std::printf(" Blueprint: minor + major grid lines (technical drawing / drafting paper / engineer's table)\n");
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
std::printf(" --gen-texture-rust-streaks <out.png> <bgHex> <rustHex> [streakCount] [seed] [W H]\n");
std::printf(" Rust streaks: vertical drip bands fading down from hash-jittered tops (weathered metal / hull stains)\n");
feat(editor): add --gen-texture-plaid translucent-bands pattern 65th procedural texture: 2 sets of parallel "translucent" bands — one horizontal, one vertical — overlaid on a base. Each band contributes 0.5 alpha, so where bands cross both half-alphas combine for the darkest color (the unmistakable plaid grid intersection). Distinct from --gen-texture-tartan (3-4 colors with asymmetric stripe pitches) — this is the simple symmetric 2-color variant. Distinct from --gen-texture-checker (hard binary squares) — plaid uses 3-tone alpha-blend gradient. Useful for pub-table cloths, country-tavern napery, dwarven formal-attire trim, picnic blankets, peasant-clothier swatches. Default 24-stride / 8-band reads as classic country-checked at 256x256. First procedural texture to also use the new printPngWrote helper from this batch.
2026-05-09 12:39:38 -07:00
std::printf(" --gen-texture-plaid <out.png> <bgHex> <bandHex> [stride] [bandW] [W H]\n");
std::printf(" Plaid: 2 sets of crossed translucent bands; intersections darken via combined half-alpha\n");
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
std::printf(" --gen-texture-diamond-grid <out.png> <bgHex> <fillHex> [cellW] [cellH] [fillFrac] [W H]\n");
std::printf(" Diamond grid: axis-aligned solid diamonds in cells with bg gaps (clean tile / mosaic / floor inlay)\n");
feat(editor): add --gen-texture-houndstooth classic-textile motif 67th procedural texture: the classic 19th-century Scottish houndstooth broken-check pattern via a hard-coded seamless 8x8 motif: 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 1 1 1 1 0 0 0 1 1 1 1 0 0 0 1 1 1 0 0 0 0 1 1 1 1 0 0 0 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 1 1 1 0 0 Each motif cell scales to `cellSize` pixels (default 4 → 32 px tile), so a 256x256 texture shows 8 motifs in each axis. Tile-seam-perfect: no row offset or fractional pixel issues since lookup is integer mod 8. Useful for noble-house tabard accents, formal-attire trim, upholstery in palace dining rooms, drapes / wall hangings, gentry-quarter banners. Distinct from --gen-texture-tartan (weighted multi-color stripes) and --gen-texture-checker (simple binary squares) — houndstooth has the iconic 4-pointed "tooth" silhouette.
2026-05-09 12:52:31 -07:00
std::printf(" --gen-texture-houndstooth <out.png> <toothHex> <bgHex> [cellSize] [W H]\n");
std::printf(" Houndstooth: classic textile broken-check pattern via seamless 8x8 motif (Scottish weave)\n");
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
std::printf(" --gen-texture-chevron <out.png> <bgHex> <lineHex> [period] [stride] [lineW] [W H]\n");
std::printf(" Chevron: stack of V-shape stripes with sharp seams (military / sportswear / heraldic banners)\n");
feat(editor): add --gen-texture-dunes wave-ripple pattern 69th procedural texture: stack of parallel sinusoidal curves spaced verticalSpacing apart. A pixel falls on a dune line if its Y is within lineW/2 pixels of the nearest curve at y = N*spacing + amp*sin(2π*x/period). Distinct from --gen-texture-corrugated (uniform parallel lines) and --gen-texture-zebra (sin-shifted strip fills) — this is the discrete-curve variant for desert ground textures and shallow-water sand patterns. Useful for desert ground, shallow-water sand bottoms, beach close-ups, mirage scene-setters, sand-storm overlays, zone-specific weathering on stone surfaces.
2026-05-09 13:03:00 -07:00
std::printf(" --gen-texture-dunes <out.png> <bgHex> <lineHex> [verticalSpacing] [period] [amp] [lineW] [W H]\n");
std::printf(" Dunes: stack of parallel sinusoidal curves (desert ground / shallow-water sand / wave ripples)\n");
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
std::printf(" --gen-texture-swirl <out.png> <bgHex> <armHex> [armCount] [spiralFactor] [armWidth] [W H]\n");
std::printf(" Swirl: N-arm logarithmic spiral (magic sigils / summoning circles / ritual floor markings)\n");
feat(editor): add --gen-texture-ironbark hardwood-plate pattern 71st procedural texture: vertical wood-grain streaks (like --gen-texture-bark) overlaid with horizontal "plate" bands at regular Y intervals — the segmented look of mature hardwood / ironwood / sycamore bark. Per-pixel logic: • horizontal crack: top crackW pixels of every plateY cycle gets the dark crack color • vertical streak: per-streak hash determines an offset crack position within each streakSpacing block • elsewhere: base color modulated by per-streak-and-plate brightness jitter (±15) so the surface has natural texture variation Distinct from --gen-texture-bark (vertical-crack only) and --gen-texture-wood (vertical-streak only). Useful for ancient trees, druid grove deadwood, dwarven hardwood beams, fortress door planks, totem-pole carvings.
2026-05-09 13:14:18 -07:00
std::printf(" --gen-texture-ironbark <out.png> <baseHex> <crackHex> [streakSpacing] [plateY] [crackW] [seed] [W H]\n");
std::printf(" Ironbark: vertical wood streaks + horizontal plate bands (mature hardwood / sycamore / ironwood)\n");
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
std::printf(" --gen-texture-mold <out.png> <bgHex> <moldHex> [stride] [thresholdFrac] [seed] [W H]\n");
std::printf(" Mold: Worley-noise field patches (cellars / dungeon walls / sewer overflow / fungal growth)\n");
feat(editor): add --gen-texture-embroidery cross-stitch grid 73rd procedural texture: a grid of X-shape cross stitches. Each cell holds an X formed by two diagonal strokes from opposing cell corners through the center. A pixel falls on a stitch if its in-cell position is within strokeW/2 of either diagonal axis. Distinct from --gen-texture-checker (filled squares), --gen-texture-knit (V-stitch chevron), --gen-texture-lattice (diagonal trellis). Embroidery is the explicit two-direction diagonal stitch mark used by counted-thread textile work. Useful for sampler-cloth detail, folk-art trim, peasant- clothier border bands, witch-hut wall hangings, hearth-rug overlays. Default 12-cell / 2-stroke gives a fine X-stitch look; bump cellSize for chunkier sampler stitches.
2026-05-09 13:25:41 -07:00
std::printf(" --gen-texture-embroidery <out.png> <bgHex> <threadHex> [cellSize] [strokeW] [W H]\n");
std::printf(" Embroidery: grid of cross-stitch X marks (counted-thread textile / sampler / folk-art trim)\n");
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
std::printf(" --gen-texture-lightbeam <out.png> <bgHex> <beamHex> [beamHalfW] [vFadeFrac] [u|d] [W H]\n");
std::printf(" Lightbeam: vertical sun-ray gradient fading horizontally + vertically (sunbeam / holy radiance)\n");
feat(editor): add --gen-texture-dewdrops scattered-droplets 75th procedural texture: N small water droplets at hash- derived (cx, cy, R) positions blended onto bg via radial brightness — bright at the drop center fading to bg at its edge. Where drops overlap they accumulate brighter (max-of-individual-contributions, not additive — so the result stays inside the [bg, drop] color range). Each drop gets a hash-derived radius in the [maxR/4, maxR] range so the surface has a natural mix of small and large droplets. Two-pass (compute brightness map, then write pixels) so overlap accumulation works correctly. Useful for morning-grass blades, wet-glass overlays, leaf surfaces after rain, magic-pool fizz, snake-fountain splash zones, dragon-breath-aftermath ground.
2026-05-09 13:36:39 -07:00
std::printf(" --gen-texture-dewdrops <out.png> <bgHex> <dropHex> [dropCount] [maxR] [seed] [W H]\n");
std::printf(" Dewdrops: scattered translucent water drops with radial brightness (grass / glass / leaf surfaces)\n");
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
std::printf(" --gen-texture-pinwheel <out.png> <aHex> <bHex> [sectors] [W H]\n");
std::printf(" Pinwheel: alternating colored triangular wedges radiating from center (mandala / wind-rose / wheel inlay)\n");
feat(editor): add --gen-texture-scratched-metal worn-surface 77th procedural texture: base metal color overlaid with N short angled line segments brightened against the base. Each scratch is a hash-derived (cx, cy, length, angle) segment drawn via integer-stepped line walking from -len/2 to +len/2 along the angle. Useful for weathered armor, worn weapon blades (especially old swords / axes that have seen real use), well-used metal tools, salvaged hull plating, ancient relic surfaces, dwarven heirloom finishes. Default 100 scratches at maxLen=24 gives a moderately worn look on 256x256; bump scratchCount + maxLen for a heavily battle-scored aesthetic. Deterministic from seed.
2026-05-09 13:46:11 -07:00
std::printf(" --gen-texture-scratched-metal <out.png> <baseHex> <scratchHex> [scratchCount] [maxLen] [seed] [W H]\n");
std::printf(" Scratched metal: base color overlaid with N angled hash-derived line segments (worn armor / blades)\n");
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
std::printf(" --gen-texture-crackle <out.png> <baseHex> <crackHex> [stride] [crackW] [seed] [W H]\n");
std::printf(" Crackle: fine Voronoi cell-boundary cracks (dried mud / parched earth / aged leather)\n");
feat(editor): add --gen-texture-star solid polygon 79th procedural texture: solid N-pointed star polygon centered on the texture. Each pixel computes its polar (r, θ); the star boundary at any θ alternates between outer and inner radii using a 2π/N triangular-wave pattern (0 at sector edges = points, 1 at sector center = valley). Pixels with r < boundary(θ) are filled with the star color. Distinct from --gen-texture-starburst (thin rays with bg between them) and --gen-texture-pinwheel (alternating solid wedges) — star is a single solid polygon shape. innerFrac controls the star's "sharpness": near 0 gives spike-thin star arms; near 1 approximates a circle. Default 0.40 with 5 points gives the classic American-flag star. The first point is rotated to the top (-Y screen direction) for canonical orientation. Useful for medallion centers, shield emblems, religious / order symbols, magic-circle icons, banner emblems, sheriff- badge inserts.
2026-05-09 14:03:07 -07:00
std::printf(" --gen-texture-star <out.png> <bgHex> <starHex> [points] [innerFrac] [W H]\n");
std::printf(" Star: solid N-pointed star polygon centered (medallions / shields / religious symbols)\n");
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
std::printf(" --gen-texture-halftone <out.png> <bgHex> <dotHex> [stride] [maxR] [v|h|r] [W H]\n");
std::printf(" Halftone: grid of dots whose radii grow with a v/h/r gradient (comic / newspaper print look)\n");
feat(editor): add --gen-texture-bayer ordered-dither pattern 81st procedural texture: classic 4x4 Bayer ordered-dither matrix tiled across the image. Each pixel's color comes from interpolating bg → fg by the matrix value at (x mod 4, y mod 4) normalized to [0, 1]: 0 8 2 10 12 4 14 6 3 11 1 9 15 7 13 5 cellSize parameter scales the matrix block (default 4 px, giving a 16-px seamless tile; cellSize=8 gives a 32-px chunky retro look). Useful for 8-bit / monochrome-CRT-style backdrops, ordered- shadow approximations on low-bit palettes, retro arcade splash overlays, paper-spritesheet rendering, and as a deterministic alternative to --gen-texture-noise for binary or near-binary palettes.
2026-05-09 14:20:02 -07:00
std::printf(" --gen-texture-bayer <out.png> <aHex> <bHex> [cellSize] [W H]\n");
std::printf(" Bayer: 4x4 ordered-dither matrix tiled (retro / 8-bit / monochrome-CRT effects)\n");
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
std::printf(" --gen-texture-moon <out.png> <bgHex> <moonHex> [moonR] [phase] [W H]\n");
std::printf(" Moon disc with optional crescent shadow (phase 0=full, =moonR=half, >moonR=crescent)\n");
feat(editor): add --gen-texture-damask 4-petal wallpaper motif 83rd procedural texture: ornate damask wallpaper pattern. Per cell: 4-fold radial petal lobes formed by sin(theta*2)^2, faded out toward the cell edge, plus a small filled center dot to anchor the motif visually. Reads as gilded fabric / palace wallpaper / noble-faction tapestry — the missing classic-ornament category in the catalogue (chevron / herringbone / argyle / houndstooth cover modern geometric patterns; damask covers the older Western-European decorative arts side). Useful for: throne-room walls, cathedral interiors, royal banners, tavern wallpaper, cushion textures, scroll backgrounds, manuscript decoration, alchemy-shop bottle-label backdrops.
2026-05-09 14:42:23 -07:00
std::printf(" --gen-texture-damask <out.png> <bgHex> <fgHex> [cell] [W H]\n");
std::printf(" Damask: 4-petal floral motif tiled per cell (palace wallpaper / noble-faction tapestry)\n");
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
std::printf(" --gen-texture-snowflake <out.png> <bgHex> <fgHex> [cell] [W H]\n");
std::printf(" Snowflake: 6-fold symmetric ice crystal stamped per cell (winter zones / frost spell effects)\n");
feat(editor): add --gen-texture-gear-cog mechanical wheel 85th procedural texture: gear-cog wheel pattern tiled per cell. Three concentric radii define the gear: • hub (rNorm < 0.20) — center axle hole, kept as bg • inner (rNorm < 0.65) — gap floor between teeth • outer (rNorm < 0.92) — tooth tip Teeth alternate around the gear via a per-tooth phase calculation: theta is mapped into a tooth period of 2*pi/teeth, with the first half of each period rendering as a tooth (effective radius = outer) and the second half rendering as a gap (effective radius = inner). Useful for: engineering crafting backdrops, mechanical door textures, gnomish / goblin themed gear icons, factory / forge tile sets, clockwork-themed dungeons, steampunk faction insignia, machinery damage states. Distinct from --gen-texture-rings (concentric circles only, no teeth). The first procedural texture in the catalogue that exercises a per-tooth periodic offset rather than a fixed angular fold.
2026-05-09 17:09:32 -07:00
std::printf(" --gen-texture-gear-cog <out.png> <bgHex> <fgHex> [cell] [teeth] [W H]\n");
std::printf(" Gear cog: mechanical wheel with N alternating teeth + center axle hole (engineering / clockwork themes)\n");
refactor(editor): extract printUsage into cli_help.cpp Pulls the 597-line block of printf calls that emits the --help text out of main.cpp into its own translation unit. printUsage is the longest single function in main.cpp by far and was pure boilerplate (no logic, just a flat list of help lines). Function moved verbatim to wowee::editor::cli::printUsage; all 6 in-tree callers (--list-commands, --info-cli-stats, --info-cli-categories, --info-cli-help, --validate-cli-help, and the bare --help/-h handler) updated to the namespaced name. The CLI-meta commands continue to capture printUsage's stdout the same way, so behavior is identical (verified by re-running --validate-cli-help, --info-cli-stats, --list-commands). main.cpp drops 26,650 → 26,286 lines (-364 net; -597 from the removal, +233 from the include and namespace-prefixing the six call sites... wait, no, +6). Actually main.cpp net delta matches the body extraction.
2026-05-08 20:12:15 -07:00
std::printf(" --add-texture-to-zone <zoneDir> <png-path> [renameTo]\n");
std::printf(" Copy an existing PNG into <zoneDir> (optionally renaming it on the way in)\n");
std::printf(" --gen-mesh <wom-base> <cube|plane|sphere|cylinder|torus|cone|ramp> [size]\n");
std::printf(" Synthesize a procedural WOM primitive with proper normals, UVs, and bounds\n");
std::printf(" --gen-mesh-textured <wom-base> <cube|plane|sphere|cylinder|torus|cone|ramp> <colorHex|pattern> [size]\n");
std::printf(" Compose a procedural mesh + matching PNG texture wired into the WOM's batch\n");
std::printf(" --gen-mesh-stairs <wom-base> <steps> [stepHeight] [stepDepth] [width]\n");
std::printf(" Procedural straight staircase along +X with N steps (default 5 / 0.2 / 0.3 / 1.0)\n");
std::printf(" --gen-mesh-grid <wom-base> <subdivisions> [size]\n");
std::printf(" Subdivided flat plane on XY (NxN cells, 2N² triangles); useful for LOD demos\n");
std::printf(" --gen-mesh-disc <wom-base> [radius] [segments]\n");
std::printf(" Flat circular disc on XY centered at origin (default radius 1.0, 32 segments)\n");
std::printf(" --gen-mesh-tube <wom-base> [outerRadius] [innerRadius] [height] [segments]\n");
std::printf(" Hollow cylinder/pipe along Y axis (default 1.0/0.7/2.0, 24 segments)\n");
std::printf(" --gen-mesh-capsule <wom-base> [radius] [cylHeight] [segments] [stacks]\n");
std::printf(" Capsule along Y axis: cylinder body with hemispherical caps (default 0.5/1.0/16/8)\n");
std::printf(" --gen-mesh-arch <wom-base> [openingWidth] [openingHeight] [thickness] [depth] [segments]\n");
std::printf(" Doorway arch: two columns + semicircular top (default 1.0/1.5/0.2/0.3, 12 segs)\n");
std::printf(" --gen-mesh-pyramid <wom-base> [sides] [baseRadius] [height]\n");
std::printf(" N-sided polygonal pyramid with apex at +Y (default 4 sides, 1.0/1.0)\n");
std::printf(" --gen-mesh-fence <wom-base> [posts] [postSpacing] [postHeight] [railThick]\n");
std::printf(" Repeating fence: N posts along +X with two horizontal rails between\n");
std::printf(" --gen-mesh-tree <wom-base> [trunkRadius] [trunkHeight] [foliageRadius]\n");
std::printf(" --gen-mesh-rock <wom-base> [radius] [roughness] [subdiv] [seed]\n");
std::printf(" Procedural boulder via subdivided octahedron + smooth noise displacement\n");
std::printf(" --gen-mesh-pillar <wom-base> [radius] [height] [flutes] [capScale]\n");
std::printf(" Fluted classical column with concave flutes + flared cap/base (default 12 flutes)\n");
std::printf(" --gen-mesh-bridge <wom-base> [length] [width] [planks] [railHeight]\n");
std::printf(" Plank bridge with two side rails (default 6 planks across, rails on)\n");
std::printf(" --gen-mesh-tower <wom-base> [radius] [height] [battlements] [battlementH]\n");
std::printf(" Round castle tower with crenellated battlements (default 8 teeth, 0.5m tall)\n");
std::printf(" --gen-mesh-house <wom-base> [width] [depth] [height] [roofHeight]\n");
std::printf(" Simple house: cube body + pyramid roof (default 4×4×3 with 2m roof)\n");
std::printf(" --gen-mesh-fountain <wom-base> [basinRadius] [basinHeight] [spoutRadius] [spoutHeight]\n");
std::printf(" Round basin + center spout column (default 1.5/0.5 basin, 0.2/1.5 spout)\n");
std::printf(" --gen-mesh-statue <wom-base> [pedestalSize] [bodyHeight] [headRadius]\n");
std::printf(" Humanoid placeholder: pedestal block + tall body cylinder + head sphere\n");
std::printf(" --gen-mesh-altar <wom-base> [topRadius] [topHeight] [steps] [stepStride]\n");
std::printf(" Round altar: stacked stepped discs descending from a flat top (default 3 steps)\n");
std::printf(" --gen-mesh-portal <wom-base> [width] [height] [postThickness] [lintelHeight]\n");
std::printf(" Doorway frame: two side posts + top lintel (default 2.5w × 4h)\n");
std::printf(" --gen-mesh-archway <wom-base> [width] [pillarHeight] [thickness] [archSegs]\n");
std::printf(" Semicircular arched doorway: two pillars + curved keystone vault (default 12 segs)\n");
std::printf(" --gen-mesh-barrel <wom-base> [topRadius] [midRadius] [height] [hoopThickness]\n");
std::printf(" Tapered barrel: bulges in middle + 2 rim hoops (default 0.4/0.5/1.0/0.06)\n");
feat(editor): add --gen-mesh-chest treasure chest primitive Composite procedural chest: rectangular body box + slightly inset lid box on top + 3 thin iron bands wrapping around the body (15% / 50% / 85% along width) + a small lock plate on the front face. 6 boxes assembled into one batch. Defaults: 1.4 × 0.9 × 0.9 body with 0.25-tall lid. Useful for dungeon loot, room decoration, quest objectives. Brings the procedural mesh primitive set to 27.
2026-05-08 21:19:51 -07:00
std::printf(" --gen-mesh-chest <wom-base> [width] [depth] [bodyHeight] [lidHeight]\n");
std::printf(" Treasure chest: body box + lid box + 3 iron bands + lock plate (default 1.4×0.9×0.9)\n");
feat(editor): add --gen-mesh-anvil blacksmith primitive Composite anvil silhouette: 4-step pedestal (wide base → narrow waist → wide cap → flat work face), each step a single addBox call, plus a 4-vertex tapered prism for the horn extending in +X past the face. The prism's 4 side triangles converge to a single tip vertex (the horn point), with a sealed base square behind it. Defaults: length=1.0, width=0.4, hornLen=0.5, bodyH=0.5. Useful for blacksmith shops, dwarven forges, weapon-crafting set dressing. Brings the procedural mesh primitive set to 28. Added directly to cli_gen_mesh.cpp — proves the modular file accepts new primitives the same way as extracted ones.
2026-05-08 22:37:47 -07:00
std::printf(" --gen-mesh-anvil <wom-base> [length] [width] [hornLength] [bodyHeight]\n");
std::printf(" Blacksmith anvil: stepped pedestal + flat work surface + horn taper (default 1.0×0.4×0.5×0.5)\n");
feat(editor): add --gen-mesh-mushroom forest-prop primitive Composite mushroom: 12-segment cylindrical stalk + 16×8 hemisphere cap on top (top half of a UV sphere). Cap radius is independent of stalk radius so the silhouette can match anything from a slim toadstool to a wide morel. Stalk has a bottom cap and the hemisphere's lower edge is sealed against a flat -Y disc (the "gills") so the mesh is watertight from all viewing angles. Defaults: stalkR=0.1, stalkH=0.6, capR=0.4. Useful for forest decoration, swamp zones, fairy-ring set dressing. Brings the procedural mesh primitive set to 29.
2026-05-08 23:48:03 -07:00
std::printf(" --gen-mesh-mushroom <wom-base> [stalkRadius] [stalkHeight] [capRadius]\n");
std::printf(" Mushroom: cylindrical stalk + hemispherical cap (default 0.1/0.6/0.4)\n");
feat(editor): add --gen-mesh-cart wagon primitive Composite cart: rectangular bed box + 2 axis-along-Z cylindrical wheels mounted on each side at the bottom of the bed. Each wheel has 16 angular segments + front/back caps. Bed sits at y=wheelR so the wheels touch the ground at y=0. Defaults: 1.6×0.8×0.5 bed, wheelR=0.35. Useful for medieval village clutter, market scenes, NPC vendor decoration. Brings the procedural mesh primitive set to 30.
2026-05-09 00:52:13 -07:00
std::printf(" --gen-mesh-cart <wom-base> [bedLength] [bedWidth] [bedHeight] [wheelRadius]\n");
std::printf(" Wooden cart: rectangular bed + 2 cylindrical wheels (default 1.6/0.8/0.5/0.35)\n");
feat(editor): add --gen-mesh-banner pole + flag primitive Composite banner: 12-segment vertical pole cylinder with top and bottom caps + a rectangular flag attached at the top of the pole, draped along -Z. The flag is two-sided (front faces +X, back faces -X) so it reads from both viewing angles without needing backface-culling-disabled materials. Defaults: poleH=3, poleR=0.05, flagW=0.8, flagH=1.2. Useful for guild halls, faction territory markers, military camps, parade dressing. Brings the procedural mesh primitive set to 31.
2026-05-09 02:10:23 -07:00
std::printf(" --gen-mesh-banner <wom-base> [poleHeight] [poleRadius] [flagWidth] [flagHeight]\n");
std::printf(" Banner: vertical pole + rectangular hanging flag (default 3.0/0.05/0.8/1.2)\n");
feat(editor): add --gen-mesh-grave tombstone primitive Two-box composite: a wider low base + a vertical tablet centered on top. Base is deeper than tablet (1.5×) and base height is 20% of tablet height — proportions that read as a stable foundation supporting an upright stone. Defaults: tablet 0.6×1.0×0.15, base width 0.8. Useful for graveyards, undead zones, memorial set dressing, ruined chapel courtyards. Brings the procedural mesh primitive set to 32.
2026-05-09 03:00:19 -07:00
std::printf(" --gen-mesh-grave <wom-base> [tabletWidth] [tabletHeight] [tabletThickness] [baseWidth]\n");
std::printf(" Tombstone: low rectangular base + vertical tablet (default 0.6/1.0/0.15/0.8)\n");
feat(editor): add --gen-mesh-bench wooden bench primitive Three-box composite: long thin seat plank on top + 2 leg slabs at the ends (positioned at 90% along the bench length to leave a small overhang on each side). Legs are vertical Y-aligned slabs spanning the full height from floor to bottom-of-seat, ~5% of bench length thick. Defaults: length=1.5, seatY=0.5, seatT=0.06, seatW=0.4. Useful for taverns, plazas, roadside rest stops, council halls. Brings the procedural mesh primitive set to 33.
2026-05-09 03:43:11 -07:00
std::printf(" --gen-mesh-bench <wom-base> [length] [seatHeight] [seatThickness] [seatWidth]\n");
std::printf(" Wooden bench: seat plank + 2 leg slabs (default 1.5/0.5/0.06/0.4)\n");
feat(editor): add --gen-mesh-shrine canopy primitive 6-component composite: square base slab + 4 cylindrical pillars (12-segment, inset by pillarR so they sit fully on the base) + flat roof slab on top with 5% overhang past the base footprint. Pillars + roof create an open canopy. Defaults: size=1.5, pillarH=2, pillarR=0.1, roofT=0.15. Useful for wayside shrines, gazebos, well covers, market stalls, religious altars in temples. Brings the procedural mesh primitive set to 34. Milestone: kArgRequired entries reaches 300.
2026-05-09 04:25:52 -07:00
std::printf(" --gen-mesh-shrine <wom-base> [size] [pillarHeight] [pillarRadius] [roofThickness]\n");
std::printf(" Small canopy: square base + 4 corner pillars + flat roof slab (default 1.5/2/0.1/0.15)\n");
feat(editor): add --gen-mesh-totem stacked carved totem primitive Stack of N square blocks with alternating widths: even-indexed blocks (0, 2, 4...) get full base width, odd blocks (1, 3, 5...) get 70% — gives the carved-segment look characteristic of totem poles. Defaults: baseW=0.5, 5 segments, segH=0.5. Useful for tribal zones, druid groves, fairgrounds, primitive village markers. Brings the procedural mesh primitive set to 35.
2026-05-09 04:57:33 -07:00
std::printf(" --gen-mesh-totem <wom-base> [width] [segments] [segmentHeight]\n");
std::printf(" Tribal totem: stack of N alternating-width carved blocks (default w=0.5, 5 segs, h=0.5)\n");
feat(editor): add --gen-mesh-cage prison-cell primitive Square cage frame: top + bottom thin slabs + 4 corner posts (thicker than bars) + N evenly-spaced bars per side. Bars on each side span perpendicular to that side's plane so the cage reads as enclosed from any viewing angle. Defaults: width=1.5, height=2.0, barsPerSide=5, barR=0.04. Useful for prison cells, animal pens, dungeon set dressing, caged exhibits. Brings the procedural mesh primitive set to 36.
2026-05-09 05:25:39 -07:00
std::printf(" --gen-mesh-cage <wom-base> [width] [height] [barsPerSide] [barRadius]\n");
std::printf(" Cage: top/bottom frames + 4 corner posts + N bars per side (default 1.5×2.0, 5 bars)\n");
feat(editor): add --gen-mesh-throne regal-seat primitive 5-box composite: low pedestal slab + seat block + tall vertical backrest at -Z + 2 small armrests on the +X/-X sides. Pedestal is wider than the seat for a stable foundation, seat thickness is 30% of total seat height. Defaults: seatW=0.8, seatH=0.5, backH=1.5, pedSize=1.2. Useful for throne rooms, hero seats, judgement halls, royal court set dressing. Brings the procedural mesh primitive set to 37.
2026-05-09 05:50:23 -07:00
std::printf(" --gen-mesh-throne <wom-base> [seatWidth] [seatHeight] [backHeight] [pedestalSize]\n");
std::printf(" Throne: pedestal + seat + backrest + 2 armrests (default 0.8/0.5/1.5/1.2)\n");
feat(editor): add --gen-mesh-coffin hexagonal-prism primitive 38th procedural mesh: classic 6-sided coffin with the narrow-head / wide-shoulder / tapered-foot top-down profile that's instantly recognizable from any angle. Built as 6 side quads + top lid fan + bottom panel fan, all with face-shared normals so it shades cleanly under any lighting. Pairs with --gen-mesh-grave for graveyard set dressing. Defaults to 2.0×0.8×0.6 (length × shoulder-width × height).
2026-05-09 06:18:42 -07:00
std::printf(" --gen-mesh-coffin <wom-base> [length] [width] [height]\n");
std::printf(" Hexagonal coffin: narrow head + wide shoulder + tapered foot prism (default 2.0/0.8/0.6)\n");
feat(editor): add --gen-mesh-bookshelf cabinet primitive 39th procedural mesh: 5-panel cabinet (back / left / right / top / bottom) divided into N bays by N-1 horizontal shelves, with rows of pseudo-random book boxes on each level. Book widths and heights vary per bay (seeded by bay index so re-generating the same shelf gives the same layout) so the result reads as a stocked library instead of a perfect grid. Defaults to 1.5x2.0x0.4 with 4 shelves (~72 books). Useful for studies, libraries, mage towers, anywhere that needs filled-out furniture set dressing.
2026-05-09 06:39:39 -07:00
std::printf(" --gen-mesh-bookshelf <wom-base> [width] [height] [depth] [shelves]\n");
std::printf(" Bookshelf: 5-panel cabinet with N-1 shelves and rows of varied book boxes (default 1.5/2.0/0.4/4)\n");
feat(editor): add --gen-mesh-tent A-frame canvas tent 53rd procedural mesh primitive. Builds a watertight A-frame tent: • two sloped roof panels meeting at a ridge that runs along the X axis • two triangular gables sealing the ends • optional inverted-V door notch carved out of the +X gable (parameterized by doorH and doorW; either set to 0 disables the cutout for a solid gable) • bottom face for collision-bake watertightness Useful set dressing for Horde encampments, troll camps, Defias bandit hideouts, scout/quartermaster overlooks, and generic outdoor quest hubs. Default footprint 1.6 x 1.0 with 0.9 ridge height and a 0.5 x 0.4 door notch — all dimensions overridable on the CLI.
2026-05-09 10:25:38 -07:00
std::printf(" --gen-mesh-tent <wom-base> [length] [width] [height] [doorH] [doorW]\n");
std::printf(" Tent: A-frame canvas tent — ridge along X, two sloped roof panels, two gables, door notch on +X (default 1.6/1.0/0.9/0.5/0.4)\n");
feat(editor): add --gen-mesh-firepit camp firepit primitive 54th procedural mesh primitive. Builds a recognizable campfire setup from axis-aligned boxes only: • ring of N stone cubes evenly placed at radius ringR around the firepit center, sitting on the ground • two crossed log boxes at the center (one along X, one along Z, slightly raised) — the unmistakable visual cue separating a firepit from a generic decorative stone ring Pairs naturally with --gen-mesh-tent for outdoor camp set dressing (Horde encampments, Defias hideouts, scout overlooks). Default 0.5-radius ring with 8 stones reads cleanly at 1:1 player scale.
2026-05-09 10:37:37 -07:00
std::printf(" --gen-mesh-firepit <wom-base> [ringR] [stones] [stoneSize] [logLen] [logThick]\n");
std::printf(" Firepit: ring of N stone cubes around 2 crossed log boxes (default 0.5/8/0.10/0.45/0.05)\n");
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
std::printf(" --gen-mesh-woodpile <wom-base> [logR] [logLen] [sides]\n");
std::printf(" Woodpile: 6 cylindrical logs in a 3-2-1 pyramid stack along Z axis (default 0.10/0.80/12)\n");
feat(editor): add --gen-mesh-canopy market-stall awning 56th procedural mesh primitive. Builds a rectangular awning on 4 corner posts with a flat overhead panel and optional drape lips hanging down from each edge: • 4 corner posts inset by postR so their outer faces line up flush with the panel edges above • flat panel slab spanning the full footprint, sitting on top of the posts • optional drape lips on all four panel edges (set drape=0 for a clean flat-top canopy with no hanging fabric) All axis-aligned boxes; the no-drape variant is fully watertight (verified via --info-mesh-stats --weld). Useful for market-square stalls, vendor stations, alchemist booths, caravan rest stops, and tournament viewing platforms.
2026-05-09 10:59:05 -07:00
std::printf(" --gen-mesh-canopy <wom-base> [width] [depth] [height] [postR] [panelT] [drape]\n");
std::printf(" Canopy: 4-post awning with flat top panel and optional drape lips (default 1.6/1.2/2.0/0.05/0.03/0.15)\n");
feat(editor): add --gen-mesh-haystack terraced farm haystack 57th procedural mesh primitive. Builds a layered haystack: N stacked frustums, each smaller than the one below, with the topmost layer tapering to an apex point. The visible shelves where each layer overhangs the smaller one above read as bound straw shocks rather than the smooth silhouette --gen-mesh-pyramid produces. Per layer: vertical side wall ring (no taper within a single layer) plus a top "shelf" annulus where it meets the next layer up. Final layer is a cone fan to a single apex vertex. Closed bottom disc keeps the model a solid for collision baking — verified watertight under weld. Useful for farms, granaries, stables, harvest-festival clearings, druid groves with bound bundles. Default 3 layers at 12 sides reads cleanly at typical NPC scale.
2026-05-09 11:08:39 -07:00
std::printf(" --gen-mesh-haystack <wom-base> [baseR] [height] [layers] [sides]\n");
std::printf(" Haystack: terraced stack of N frustums tapering to an apex point (default 0.6/0.9/3/12)\n");
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
std::printf(" --gen-mesh-dock <wom-base> [length] [width] [height] [pilings/side] [pilingW] [deckT]\n");
std::printf(" Dock: flat plank deck on N pairs of square pilings (default 3.0/1.0/0.6/3/0.10/0.10)\n");
feat(editor): add --gen-mesh-pergola garden-arbor primitive 59th procedural mesh primitive. Builds an open-top pergola from axis-aligned boxes (uses the new addFlatBox helper): • 4 corner posts sized so their outer faces line up with the footprint perimeter • 2 long perimeter beams resting on top of the posts along the long edges • N cross beams running between the perimeter beams (slightly thinner so the lattice has visible crossings) Distinct from --gen-mesh-canopy because there's no closed overhead panel — the open lattice top reads as a sun-trellis or vine-arbor instead of a market-stall awning. Useful for palace courtyards, druid groves, garden mazes, viewing arbors, harvest-festival entrance pieces. Set crossbeams=0 for a bare 4-post + 2-beam frame; default 5 crossbeams gives a pleasing alternating pattern.
2026-05-09 11:26:15 -07:00
std::printf(" --gen-mesh-pergola <wom-base> [length] [width] [height] [postR] [beamT] [crossbeams]\n");
std::printf(" Pergola: 4 corner posts + 2 perimeter beams + N cross beams (open lattice top, no panel)\n");
feat(editor): add --gen-mesh-chimney brick-stack primitive 60th procedural mesh primitive. Builds a chimney as two axis-aligned boxes (uses the shared addFlatBox helper): • main shaft: rectangular brick stack of width × depth × (height - capH) • protective cap: a slightly wider box on top (capExtra wider than shaft on every side) — the rain-throw crown that sits on real masonry chimneys Set capH=0 for a bare unfinished stack. Default 0.45×0.45× 1.8 m shaft with a 0.10-tall cap reads at human scale for rooftop placement. Useful for cottage rooflines, blacksmith forges, alchemist labs, dwarven longhouses — any structure with a fireplace that needs visible vent. Watertight under weld (verified via --info-mesh-stats: 36 manifold edges, 0 boundary, 0 non-manifold).
2026-05-09 11:34:24 -07:00
std::printf(" --gen-mesh-chimney <wom-base> [width] [depth] [height] [capH] [capExtra]\n");
std::printf(" Chimney: rectangular brick shaft topped by a slightly wider rain-cap (default 0.45/0.45/1.8/0.10/0.05)\n");
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
std::printf(" --gen-mesh-bedroll <wom-base> [length] [radius] [sides] [pillowSize]\n");
std::printf(" Bedroll: horizontal closed cylinder along Z axis with optional pillow box at +Z (camp set dressing)\n");
feat(editor): add --gen-mesh-workbench crafter table 62nd procedural mesh primitive. A blacksmith / crafter workbench built from axis-aligned boxes (uses the new cli_box_emitter helper plus the new cli_arg_parse helpers for all 7 optional dimension args): • flat top slab spanning length × depth at topT thickness • 4 corner legs sized so their outer faces line up with the top edges (post-style, no overhang) • optional vise box at the +X end of the top — set viseSize=0 for a bare bench • optional raised tool tray along the +Z back edge — set trayH=0 to omit Pairs naturally with --gen-mesh-anvil (existing) for blacksmith forge scenes, and --gen-mesh-cauldron for alchemist labs. Default 1.6×0.7×0.85 m bench reads at realistic adult-human working height. Watertight under weld (verified via --info-mesh-stats: 126 manifold edges, 0 boundary, 0 non-manifold).
2026-05-09 11:46:05 -07:00
std::printf(" --gen-mesh-workbench <wom-base> [length] [depth] [height] [legR] [topT] [viseSize] [trayH]\n");
std::printf(" Workbench: 4-legged top slab with optional vise at +X end and back tool tray (blacksmith / crafter)\n");
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
std::printf(" --gen-mesh-crate-stack <wom-base> [crateSize] [columns] [rows] [layers] [gap]\n");
std::printf(" Crate stack: N×M×K cube grid with small gap between crates (warehouses, cargo holds, dockyards)\n");
feat(editor): add --gen-mesh-watchpost sentry tower primitive 64th procedural mesh primitive. A simple scout/sentry watchpost from axis-aligned boxes: • tall central pole rising from ground to postH • square platform slab on top of the pole, wider than the pole so it overhangs as the lookout deck • 4 corner railing posts on the platform — set railingH=0 for a bare deck Distinct from --gen-mesh-tower (round castle tower with crenellated battlements). A watchpost is the rough scout/ forward-outpost variant — just wood and rope, no masonry. Pairs naturally with --gen-mesh-tent / --gen-mesh-firepit for camp + lookout scenes, and --gen-mesh-fence for perimeter setups. Watertight under weld (verified 108 manifold edges, 0 boundary, 0 non-manifold).
2026-05-09 11:57:38 -07:00
std::printf(" --gen-mesh-watchpost <wom-base> [postH] [postW] [platformSize] [platformT] [railingH] [railingW]\n");
std::printf(" Watchpost: tall pole + square platform + 4 corner railing posts (sentry / scout outpost)\n");
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
std::printf(" --gen-mesh-water-trough <wom-base> [length] [width] [height] [wallT]\n");
std::printf(" Water trough: 4-walled rectangular basin with flat floor (stable / farm / tavern set dressing)\n");
feat(editor): add --gen-mesh-training-dummy sparring prop 66th procedural mesh primitive. Combat training dummy from axis-aligned boxes: • vertical post from ground to baseH (the stand) • cubic torso block stacked on top of the post • horizontal cross-bar arms at upper-third torso height spanning armSpan along the X axis • optional head cube above the torso (set headSize=0 for a headless training-block style) Pairs with --gen-mesh-anvil / --gen-mesh-workbench / --gen-mesh-fence for sparring grounds, militia drill squares, training yards, weapon-master compounds. Useful for any "things-to-hit" set dressing where animated NPCs would target a static prop. Watertight under weld (verified 72 manifold edges, 0 boundary, 0 non-manifold). Default 1.0 m post + 0.4 m torso + 0.18 m head reads at adult-human height.
2026-05-09 12:09:36 -07:00
std::printf(" --gen-mesh-training-dummy <wom-base> [baseH] [postW] [torsoSize] [armSpan] [armT] [headSize]\n");
std::printf(" Training dummy: post + cubic torso + cross-bar arms + optional head (sparring / drill yard)\n");
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
std::printf(" --gen-mesh-hitching-post <wom-base> [span] [height] [postW] [barT] [capH]\n");
std::printf(" Hitching post: 2 vertical posts + horizontal cross-bar + optional decorative caps (stable / town square)\n");
feat(editor): add --gen-mesh-outhouse small-shed primitive 68th procedural mesh primitive. Built from 3 axis-aligned boxes: • solid body slab spanning width × depth × (height-roofT) • thin door slab on the +Z face (pushed slightly outward so it visually sits on the wall — gives doorframe-like relief without a real cutout) • roof slab slightly larger than the body footprint and sitting on top, controlled by roofOverhang Distinct from --gen-mesh-house (multi-walled, peaked-roof dwelling). An outhouse is the single-room privy / tool shed variant — useful for villages, frontier outposts, small farms, refuse-shed corners. Watertight under weld (verified 54 manifold edges, 0 boundary, 0 non-manifold). First handler to use the new setCenteredBoundsXZ helper from this batch.
2026-05-09 12:24:00 -07:00
std::printf(" --gen-mesh-outhouse <wom-base> [width] [depth] [height] [doorH] [doorW] [roofOverhang] [roofT]\n");
std::printf(" Outhouse: solid body + inset door slab on +Z + overhanging roof slab (privy / tool shed)\n");
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
std::printf(" --gen-mesh-forge <wom-base> [width] [depth] [baseH] [hoodH] [hoodInset] [chimneyH] [chimneyW]\n");
std::printf(" Blacksmith forge: stone hearth + smaller hood + optional chimney (smithy / armorer set dressing)\n");
feat(editor): add --gen-mesh-archery-target training prop 70th procedural mesh primitive. Round-faced archery target on a 2-post stand: • face: closed cylinder along the Z axis (flat ±Z caps face the archer line, side wall is the rim) of radius faceR centered at height postH • stand: 2 vertical posts at the bottom, sized to reach from ground to the bottom of the face, with a horizontal cross-beam joining them just below the face for rigidity Concentric scoring rings live in texture space, not geometry — the cap discs are the natural canvas for a separate target- ring texture (or use --gen-texture-rings / --gen-texture- starburst on top). Pairs naturally with --gen-mesh-training-dummy / --gen-mesh-fence for sparring grounds, training yards, militia drill squares, mid-summer fair scenes. Watertight under weld (verified 198 manifold edges, 0 boundary, 0 non-manifold).
2026-05-09 12:35:15 -07:00
std::printf(" --gen-mesh-archery-target <wom-base> [faceR] [faceT] [sides] [postH] [postW] [beamT]\n");
std::printf(" Archery target: round face cylinder on a 2-post stand with cross-beam (training yard / fair scene)\n");
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
std::printf(" --gen-mesh-gravel-pile <wom-base> [stoneCount] [baseR] [pileH] [maxStoneSize] [seed]\n");
std::printf(" Gravel pile: hash-distributed stone cubes in a conical heap (mining / construction / rubble)\n");
feat(editor): add --gen-mesh-stone-bench heavy seating 72nd procedural mesh primitive. Long stone bench from 3 axis-aligned boxes: • horizontal seat slab spanning the full length on top • 2 vertical block supports near the ends, inset by supportInset from each end so the seat slab overhangs them slightly (the standard "seat rests on legs" look) Distinct from --gen-mesh-bench (wooden 4-leg construction with thinner pieces) — this is the heavier stone variant for parks, temple courtyards, ruined cities, dwarven mead halls, library-courtyard reading nooks. Watertight under weld (verified 54 manifold edges, 0 boundary, 0 non-manifold). Default 2.0 m × 0.4 m bench at 0.45 m sit height reads at adult-human proportions. Uses every shared helper added in recent batches — new gen-mesh handlers now consistently land at ~50 lines including parse + validate + geometry + finalization.
2026-05-09 12:48:55 -07:00
std::printf(" --gen-mesh-stone-bench <wom-base> [length] [depth] [seatH] [seatT] [supportW] [supportInset]\n");
std::printf(" Stone bench: long seat slab on 2 block supports near the ends (park / temple / ruined city)\n");
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
std::printf(" --gen-mesh-mine-cart <wom-base> [length] [width] [bodyH] [wallT] [wheelR] [wheelInset]\n");
std::printf(" Mine cart: open-top bin (5-piece basin) on 4 wheel boxes (mines / dwarven forges / junk yards)\n");
feat(editor): add --gen-mesh-hitching-rail multi-post variant 74th procedural mesh primitive. Long horizontal hitching bar held up by N evenly-spaced vertical posts. Distinct from --gen-mesh-hitching-post (just 2 posts + bar) — this is the longer multi-post variant for taverns, stockyards, racecourse parking, market days, festival hitching lines. Posts auto-spaced from -L/2 to +L/2, inset by postW so the end posts align with the rail tips. Bar spans the full length on top of the post tier. Watertight under weld (verified 90 manifold edges, 0 boundary, 0 non-manifold). Default 4-post / 4 m rail at 1.2 m mount height fits typical mount silhouettes. Milestone: kArgRequired now reaches 400 documented flags.
2026-05-09 12:59:16 -07:00
std::printf(" --gen-mesh-hitching-rail <wom-base> [length] [height] [posts] [postW] [barT]\n");
std::printf(" Hitching rail: long horizontal bar on N evenly-spaced posts (taverns / stockyards / market days)\n");
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
std::printf(" --gen-mesh-pillar-row <wom-base> [count] [span] [height] [pillarW] [capH] [capExtra]\n");
std::printf(" Pillar row: N evenly-spaced rectangular pillars with optional square caps (colonnade / temple ruin)\n");
feat(editor): add --gen-mesh-statue-base monument pedestal 76th procedural mesh primitive. Classic 3-tier square pedestal for statues / monuments / hero memorials: • plinth — bottom block, plinthExtra wider per side than the body (the foundation that meets the ground) • body — tall central pedestal sitting on the plinth (where the inscription would go) • capital — small wider cap on top of the body (where the statue's feet would rest) Distinct from --gen-mesh-podium (stepped pyramid with lectern at back) and --gen-mesh-altar (stacked round discs) — this is the classic single-statue square pedestal shape. Useful for town-square monuments, hero-of-the-revolution memorials, plaza centerpieces, mausoleum interiors, saint-statue stands. Watertight under weld (verified 54 manifold edges, 0 boundary, 0 non-manifold).
2026-05-09 13:11:08 -07:00
std::printf(" --gen-mesh-statue-base <wom-base> [bodyW] [bodyH] [plinthExtra] [plinthH] [capitalExtra] [capitalH]\n");
std::printf(" Statue base: 3-tier pedestal (plinth + body + capital) for monuments / hero memorials\n");
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
std::printf(" --gen-mesh-bird-bath <wom-base> [stemR] [stemH] [basinR] [basinH] [sides]\n");
std::printf(" Bird bath: thin cylindrical stem topped by a wide shallow basin disc (small garden water feature)\n");
feat(editor): add --gen-mesh-planter-box garden flowerbox 78th procedural mesh primitive. Long open-top wooden planter with a visible soil-fill block: • 5-piece basin construction (bottom slab + 4 perimeter walls), same arrangement as --gen-mesh-water-trough • soil block filling the inner cavity from floor up to soilTopFrac × height (default 85%), slightly inset from walls so it visually sits "inside" the wood Distinct from --gen-mesh-water-trough (square basin without a soil-fill block) — planter-box is the long elongated garden variant. Useful for window sills, kitchen herb gardens, balcony planters, monastery cloister-walk container plants, market-stall produce display trays. The 6 non-manifold edges (--info-mesh-stats) are at the 4-wall corners — same expected pattern as water-trough, where the inner walls share corner positions with each other. Milestone: kArgRequired now reaches 411 documented flags.
2026-05-09 13:21:03 -07:00
std::printf(" --gen-mesh-planter-box <wom-base> [length] [width] [height] [wallT] [soilTopFrac]\n");
std::printf(" Planter box: long open-top wood basin + visible soil-fill block (window sills / kitchen / balcony)\n");
feat(editor): add --gen-mesh-urn 4-tier pottery vessel 79th procedural mesh primitive. Vertical urn built from 4 stacked tiers using the new addClosedCylinderY helper: • foot — wide short cylinder (the ground-meeting base) • body — tall main cylinder (the storage volume) • neck — narrow constriction • lip — slightly wider rim cap Each tier is an independent watertight Y-axis cylinder with its own ±Y end caps; they're stacked vertically with each sitting on the previous tier's top. Useful for temple offerings, mausoleum interiors, kitchen storage, alchemist labs, funerary scenes, witch-hut detail. First handler to consume the new addClosedCylinderY helper — demonstrates the pattern for future cylindrical primitives (candle, lantern, scroll case, well-pail, etc.). Watertight under weld (verified 432 manifold edges, 0 boundary, 0 non-manifold).
2026-05-09 13:27:06 -07:00
std::printf(" --gen-mesh-urn <wom-base> [bodyR] [bodyH] [footR] [footH] [neckR] [neckH] [lipR] [lipH] [sides]\n");
std::printf(" Urn: 4-tier vertical pottery vessel (foot + body + neck + lip) — temple / mausoleum / kitchen storage\n");
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
std::printf(" --gen-mesh-candle <wom-base> [waxR] [waxH] [saucerR] [saucerH] [sides]\n");
std::printf(" Candle: thin wax pillar on optional saucer base (set saucerR=0 to skip) — chapels / vigil scenes\n");
feat(editor): add --gen-mesh-lantern hand-lantern primitive 81st procedural mesh primitive. Hand-held oil lantern via 4 stacked Y-axis cylinders: • base — short narrow disc (the foot the lantern sits on) • globe — wider taller cylinder (the glass enclosure holding the wick) • neck — narrow constriction above the globe (where the cap meets the body) • cap — wider short top (the metal hood that lets vent smoke escape) Distinct from --gen-mesh-candle (just wax + saucer) and --gen-mesh-urn (4-tier pottery shape) — lantern's wide-narrow-wide tier sequence reads as a glass-enclosed wick under a metal hood. Useful for night-watch stations, ranger camps, dwarven mine tunnels, mausoleum interiors, vigil scenes, witch-hut shelves. Watertight under weld (verified 336 manifold edges, 0 boundary, 0 non-manifold).
2026-05-09 13:38:06 -07:00
std::printf(" --gen-mesh-lantern <wom-base> [baseR] [baseH] [globeR] [globeH] [neckR] [neckH] [capR] [capH] [sides]\n");
std::printf(" Lantern: 4-tier base + glass-globe + neck + cap stack (hand lantern / oil lamp silhouette)\n");
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
std::printf(" --gen-mesh-chalice <wom-base> [footR] [footH] [stemR] [stemH] [bowlR] [bowlH] [sides]\n");
std::printf(" Chalice: ceremonial 3-tier foot + stem + bowl goblet (chapel / treasure / ritual scene)\n");
feat(editor): add --gen-mesh-standing-torch hall-lining torch 83rd procedural mesh primitive. Tall standing floor torch: • post — thin Y-axis cylinder rising from the floor • bowl — wider shallow Y-axis cylinder (the fire bowl) sitting on top of the post Distinct from --gen-mesh-brazier (squat fire-bowl on a short stem with a wide-base silhouette) — standing-torch is the tall thin walking-height variant for lining hallways, ceremonial paths, dungeon entries, palace entrance walks, watch-station lighting. Validates that postR < bowlR so the silhouette always reads as the wider-bowl-on-thinner-pole shape. Watertight under weld (verified 168 manifold edges, 0 boundary, 0 non-manifold). Two clean addClosedCylinderY calls — pattern is now well-established for cylindrical prop primitives.
2026-05-09 13:47:37 -07:00
std::printf(" --gen-mesh-standing-torch <wom-base> [postR] [postH] [bowlR] [bowlH] [sides]\n");
std::printf(" Standing torch: tall thin post + wider fire-bowl on top (hall lining / dungeon entry / ceremony path)\n");
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
std::printf(" --gen-mesh-scroll-case <wom-base> [bodyR] [bodyH] [capR] [capH] [sides]\n");
std::printf(" Scroll case: thin tall cylinder + optional wider cap (set capR=0 to skip) — libraries / mage scenes\n");
feat(editor): add --gen-mesh-stove pot-bellied wood stove 85th procedural mesh primitive. Two-cylinder pot-bellied stove silhouette: • body — wide round Y-axis cylinder (the stove body that holds the firebox) • chimney — thin tall Y-axis cylinder rising from the top of the body (the smoke vent) Distinct from --gen-mesh-forge (square stone hearth + hood + chimney) and --gen-mesh-chimney (just the rectangular shaft) — stove is the round-cylinder home / workshop variant for cottages, smithies, alchemist labs, ranger huts, dwarven mead-hall corner heaters. Validates that chimneyR < bodyR so the silhouette always reads as a wider-bottom-with-thinner-stack shape rather than a flat tube. Watertight under weld (verified 192 manifold edges, 0 boundary, 0 non-manifold).
2026-05-09 14:15:14 -07:00
std::printf(" --gen-mesh-stove <wom-base> [bodyR] [bodyH] [chimneyR] [chimneyH] [sides]\n");
std::printf(" Pot-bellied stove: round cylindrical body + thin chimney column on top (cottage / workshop heating)\n");
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
std::printf(" --gen-mesh-well-pail <wom-base> [bodyR] [bodyH] [handleW] [handleT] [handleArc] [sides]\n");
std::printf(" Wooden well-pail: closed cylindrical body + thin horizontal handle bar above (water-haul / mop-bucket prop)\n");
feat(editor): add --gen-mesh-mug tankard primitive 87th procedural mesh: drinking mug / tankard built from a closed cylindrical body plus a thin side handle slab. The handle is positioned on +X with its inner face flush against the body and centered vertically. Without rotation the handle is a solid box rather than a real C-loop, so silhouette reads as a tankard handle rather than a delicate ring — appropriate for the chunky-prop aesthetic favored by the existing primitive set. Distinct from --gen-mesh-chalice (3-tier goblet, no handle) and --gen-mesh-well-pail (top horizontal handle bar). Useful for tavern / banquet hall / kitchen dressing, inn table props, and the eventual --gen-tavern-pack-2 follow-on (once enough drinking-vessel primitives exist to justify a dedicated drinkware composite). 86 verts / 68 tris at default 14 sides — a single batch with shared body + handle texture coords.
2026-05-09 14:30:18 -07:00
std::printf(" --gen-mesh-mug <wom-base> [bodyR] [bodyH] [handleW] [handleH] [handleArm] [sides]\n");
std::printf(" Drinking mug / tankard: closed cylinder body + side handle slab (tavern / banquet / inn dressing)\n");
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
std::printf(" --gen-mesh-mortar-pestle <wom-base> [bowlR] [bowlH] [pestleR] [pestleH] [sides]\n");
std::printf(" Mortar + pestle: wide squat cylinder (bowl) + thin tall cylinder rising from inside (alchemy / kitchen)\n");
feat(editor): add --gen-mesh-rune-stone standing monolith 91st procedural mesh: a wide flat base block with a tall narrow monolith standing on top. Reads as a small carved standing-stone marker. Distinct from existing ritual-prop primitives: • --gen-mesh-altar — table-shaped, has flat top • --gen-mesh-shrine — multi-tier with cap • --gen-mesh-tombstone — narrower, curved-top silhouette • --gen-mesh-pillar — round column, no base block • --gen-mesh-statue — has figure on top Useful for: druid groves (boundary markers), witch shrines, ancient ruins (pre-civilization monuments), graveyard boundary stones, faction territory markers, Stonehenge-style ring formations (use 4-8 instances around a center point). 48 verts / 24 tris from two simple boxes — minimal vertex budget, suitable for placing in dense clusters.
2026-05-09 16:21:35 -07:00
std::printf(" --gen-mesh-rune-stone <wom-base> [baseW] [baseD] [baseH] [stoneW] [stoneD] [stoneH]\n");
std::printf(" Rune stone: wide flat base block + tall narrow monolith (druid grove / witch shrine / ancient ruins)\n");
feat(editor): add --gen-camp-pack convenience composite Convenience composite command: emits a complete outdoor-camp scene (tent + firepit + bedroll + canopy + woodpile + haystack) into <outDir>/ as 6 .wom files in one invocation. Internally builds a synthetic argv array per primitive and calls each existing handler — so the camp pack always matches the per-primitive defaults exactly. Users wanting custom dimensions should call the individual --gen-mesh-* commands. Smoke tested: • Creates outDir if needed • All 6 .wom files validate clean (--validate-wom PASSED) • Vertex / triangle counts match per-primitive defaults (firepit 240/120, woodpile 324/288, etc.) The first composite command in the editor — establishes the pattern for future packs (--gen-village-pack, --gen-dock-pack, etc.) by showing how synthetic argv arrays let one handler delegate to many others without spawning subprocesses.
2026-05-09 12:22:37 -07:00
std::printf(" --gen-camp-pack <outDir>\n");
std::printf(" Convenience: emit tent + firepit + bedroll + canopy + woodpile + haystack into outDir as 6 .wom files\n");
feat(editor): add --gen-blacksmith-pack + extract emitMeshPack Two changes in one commit because they're co-designed: • Extract emitMeshPack(outDir, packName, items) as a shared helper that takes a vector of PackItem {flag, fn, leaf} and runs each handler with a synthetic argv. Keeps the "build a 2-element argv per sub-handler" wiring in one place instead of copy-pasted per pack. • Add --gen-blacksmith-pack on top: a smithy-themed composite emitting forge + anvil + workbench + water-trough + crate-stack + hitching-post into outDir. The classic forge-floor layout in 6 .wom files. Refactors --gen-camp-pack to use emitMeshPack (verified unchanged: 6 .wom files still land in the camp dir). Pattern is now established for future packs (--gen-village- pack, --gen-temple-pack, --gen-dock-pack…) — each is just a list of primitives in 8 lines of code.
2026-05-09 12:31:34 -07:00
std::printf(" --gen-blacksmith-pack <outDir>\n");
std::printf(" Convenience: emit forge + anvil + workbench + water-trough + crate-stack + hitching-post into outDir\n");
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
std::printf(" --gen-village-pack <outDir>\n");
std::printf(" Convenience: emit house + outhouse + chimney + hitching-post + well + signpost + haystack into outDir\n");
feat(editor): add --list-packs introspection + --gen-temple-pack Two related changes: • --list-packs walks kArgRequired and surfaces every flag matching --gen-*-pack (excluding --gen-mesh-* and --gen-texture-* which are individual primitives). Sister command to --list-primitives. Auto-tracks new packs as they're added — no parallel registry. • --gen-temple-pack composite — temple/shrine ritual hall (altar + shrine + brazier + pillar + statue + portal + podium). Fourth themed mesh pack after camp / blacksmith / village. list-packs now surfaces 9 composites including the pre- existing zone-* / project-starter packs that match the naming convention. All 7 temple-pack outputs validate clean.
2026-05-09 12:51:10 -07:00
std::printf(" --gen-temple-pack <outDir>\n");
std::printf(" Convenience: emit altar + shrine + brazier + pillar + statue + portal + podium into outDir\n");
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
std::printf(" --gen-graveyard-pack <outDir>\n");
std::printf(" Convenience: emit grave + tombstone + coffin + statue + stone-bench + gravel-pile + cage into outDir\n");
feat(editor): add --gen-garden-pack composite Sixth themed mesh pack after camp / blacksmith / village / temple / graveyard. Garden-courtyard scene emitting a 7-primitive monastery / kitchen-garden / small park layout: • pergola — vine-arbor frame • fountain — centerpiece • stone-bench — seating • shrine — decorative focal • beehive — productive prop • scarecrow — rural touch • well — water source Together these form a recognizable contemplative-garden / small park / monastery courtyard when arranged in a zone. Composite-pack catalogue now: camp + blacksmith + village + temple + graveyard + garden = 6 themed mesh packs. --list-packs surfaces 11 total composite flags.
2026-05-09 13:01:21 -07:00
std::printf(" --gen-garden-pack <outDir>\n");
std::printf(" Convenience: emit pergola + fountain + stone-bench + shrine + beehive + scarecrow + well into outDir\n");
feat(editor): add --gen-dock-pack composite Seventh themed mesh pack after camp / blacksmith / village / temple / graveyard / garden. Harbor / dockyard scene emitting a 7-primitive port-side layout: • dock — the pier itself • crate-stack — cargo waiting to be loaded • barrel — sailor stash • canopy — shade for the dockmaster's station • bench — passenger waiting area • signpost — port marker • hitching-post — for tying up small boats / mounts Together these form a recognizable harbor / dockside pickup-and-drop area when arranged in a zone. Composite-pack catalogue: camp + blacksmith + village + temple + graveyard + garden + dock = 7 themed mesh packs.
2026-05-09 13:06:37 -07:00
std::printf(" --gen-dock-pack <outDir>\n");
std::printf(" Convenience: emit dock + crate-stack + barrel + canopy + bench + signpost + hitching-post into outDir\n");
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
std::printf(" --gen-tavern-pack <outDir>\n");
std::printf(" Convenience: emit house + chimney + table + bench + barrel + bookshelf + signpost into outDir\n");
feat(editor): add --gen-mining-pack composite Ninth themed mesh pack after camp / blacksmith / village / temple / graveyard / garden / dock / tavern. Mining-shaft / quarry-floor scene emitting a 7-primitive working-mine layout: • gravel-pile — loose rubble from the dig • crate-stack — raw-ore cargo waiting for transport • mine-cart — underground transport • pillar-row — roof support pillars (the colonnade pattern reads as mine-shaft supports underground) • lantern — light source • workbench — assay / sorting station • hitching-post — mule / cart tie Together these form a complete working-mine entrance / quarry-floor layout. Uses 3 primitives newly added in recent batches (mine-cart, pillar-row, lantern). Composite-pack catalogue: camp + blacksmith + village + temple + graveyard + garden + dock + tavern + mining = 9 themed mesh packs. --list-packs surfaces 14 total including the pre-existing zone/project starters.
2026-05-09 13:40:18 -07:00
std::printf(" --gen-mining-pack <outDir>\n");
std::printf(" Convenience: emit gravel-pile + crate-stack + mine-cart + pillar-row + lantern + workbench + hitching-post\n");
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
std::printf(" --gen-arena-pack <outDir>\n");
std::printf(" Convenience: emit training-dummy + archery-target + workbench + crate-stack + bench + water-trough + hitching-rail\n");
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
std::printf(" --gen-kitchen-pack <outDir>\n");
std::printf(" Convenience: emit stove + cauldron + prep-table + stool + barrel + mug + mortar (tavern back-of-house)\n");
feat(editor): add --gen-mesh-table furniture primitive 40th procedural mesh: simple 5-box table — flat top slab on 4 vertical corner legs. Pairs with --gen-mesh-bench / --gen-mesh-throne / --gen-mesh-bookshelf for taverns, dining halls, libraries, and study set dressing. Defaults to 1.6 × 1.0 base × 0.85 tall, 0.10-square legs, 0.06-thick top — sensible dining-table proportions. Customizable per dimension so a single primitive covers desks, end tables, and big banquet tables.
2026-05-09 06:58:38 -07:00
std::printf(" --gen-mesh-table <wom-base> [width] [depth] [height] [legThick] [topThick]\n");
std::printf(" Table: flat top slab on 4 corner legs (default 1.6/1.0/0.85/0.10/0.06)\n");
feat(editor): add --gen-mesh-lamppost urban-prop primitive 41st procedural mesh: 4-box urban lighting fixture — square base plinth, tall thin vertical pole, lantern body box around the pole top (overlaps so the lamp visually caps the pole), and a slightly-wider cap plate that reads as an awning. Useful for streets, plazas, courtyards, taverns — anywhere that wants explicit lighting fixtures without modeling each one by hand. Defaults to 3-meter pole + 0.5-meter lantern (~3.6m total). Customizable per dimension to cover everything from candlestick-stands to tall ornate streetlamps.
2026-05-09 07:12:46 -07:00
std::printf(" --gen-mesh-lamppost <wom-base> [poleH] [poleT] [baseSize] [lanternSize] [lanternH]\n");
std::printf(" Lamppost: square base + tall pole + lantern body + cap (default 3.0/0.12/0.4/0.35/0.5)\n");
feat(editor): add --gen-mesh-bed bedroom-prop primitive 42nd procedural mesh: 8-box bed — 4 corner legs, mattress slab, tall headboard at the +Z end, shorter footboard at the -Z end, and a small pillow on the mattress near the headboard. Pairs with --gen-mesh-table / --gen-mesh-bookshelf for inn rooms, manor bedrooms, barracks, dungeon cells. Defaults to 2.0 × 1.2 (length × width) with 0.30 leg height and 0.20 mattress thickness — proportions of a single bed. Customizable per dimension so the same primitive covers single, double, and king-size beds plus child cots.
2026-05-09 07:25:11 -07:00
std::printf(" --gen-mesh-bed <wom-base> [length] [width] [legH] [matThick] [headH] [footH]\n");
std::printf(" Bed: 4 legs + mattress + headboard + footboard + pillow (default 2.0/1.2/0.30/0.20/1.0/0.4)\n");
feat(editor): add --gen-mesh-ladder utility primitive 43rd procedural mesh: 2 vertical rails + N evenly-spaced horizontal rungs. Sits flat against +Z (the climbing face) so it can be parented to walls, wagons, ship hulls, mage tower trapdoors, attic openings, dungeon shafts. Defaults to 3.0m tall × 0.6m wide with 8 rungs (typical home/loft ladder). Rung spacing computes as height/(rungs+1) so the first rung sits a half-step from the floor and the last rung the same distance from the top — keeps the ladder visually symmetric regardless of rung count.
2026-05-09 07:36:02 -07:00
std::printf(" --gen-mesh-ladder <wom-base> [height] [width] [rungs] [railThick] [rungThick]\n");
std::printf(" Ladder: 2 vertical rails + N evenly-spaced horizontal rungs (default 3.0/0.6/8/0.06/0.04)\n");
feat(editor): add --gen-mesh-well village-prop primitive 44th procedural mesh: 7-box water well — 4 stone walls arranged in a hollow square (interior visible, like a real well shaft) + 2 vertical roof posts on opposite sides + 1 horizontal cross beam at the top where rope/bucket would mount. Useful for village squares, courtyards, dungeon water sources, druidic shrines. Defaults to 1.4 m square footprint with 0.8 m walls and 1.6 m roof posts (~2.4 m total height). The east/west walls are shortened so the corner joints line up cleanly without overlap geometry.
2026-05-09 07:47:15 -07:00
std::printf(" --gen-mesh-well <wom-base> [outerSize] [wallH] [wallT] [postH] [postT]\n");
std::printf(" Well: 4 stone walls in a hollow square + 2 roof posts + cross beam (default 1.4/0.8/0.15/1.6/0.12)\n");
feat(editor): add --gen-mesh-signpost wayfinding primitive 45th procedural mesh: 4-box signpost — stone base anchor, tall vertical pole, thin sign board mounted face-out near the top, and a small decorative cap. Useful for crossroads, tavern fronts, town entrances, dungeon area markers, quest hub indicators. Sign board's long axis runs along Z so the player reads the sign when facing parallel to the road. Defaults to a 2.5 m post with a 0.8 x 0.35 m board (~2.7 m total).
2026-05-09 07:58:45 -07:00
std::printf(" --gen-mesh-signpost <wom-base> [poleH] [poleT] [baseSize] [signWidth] [signHeight]\n");
std::printf(" Signpost: base + pole + sign board + cap (default 2.5/0.10/0.30/0.80/0.35)\n");
feat(editor): add --gen-mesh-mailbox wayside primitive 46th procedural mesh: 4-box mailbox — vertical post with a horizontal box body on top and a small flag (pole + plate) mounted on the right (+X) side near the front. Useful for inns, post stations, manor gates, frontier outposts, courier routes between zones. Defaults to a 1.10m post + 0.45L x 0.20W x 0.20H body (~1.44m total). The box body is intentionally slightly wider than the post on each axis so the body visually caps the post. Flag plate extends +X away from the body so it reads as a raised flag from the road side.
2026-05-09 08:08:37 -07:00
std::printf(" --gen-mesh-mailbox <wom-base> [postH] [postT] [boxL] [boxW] [boxH]\n");
std::printf(" Mailbox: post + horizontal box + side flag (default 1.10/0.08/0.45/0.20/0.20)\n");
feat(editor): add --gen-mesh-tombstone graveyard primitive 47th procedural mesh: 3-box vertical headstone — wide low base plinth, tall thin main slab on top, and a slightly- wider decorative crown that acts as a flat-cap stand-in for the arched-top headstone shape (which would need rotated faces). Pairs with --gen-mesh-grave (horizontal mound) and --gen-mesh-coffin for graveyards, dungeon crypts, haunted- zone set dressing. Vertical layout: 15% base, 75% slab, 10% crown. Defaults to 0.60 wide x 1.10 tall x 0.18 deep with the base 1.45x wider than the slab on each footprint axis.
2026-05-09 08:19:04 -07:00
std::printf(" --gen-mesh-tombstone <wom-base> [width] [height] [depth] [baseScale]\n");
std::printf(" Tombstone: base plinth + tall slab + decorative crown (default 0.60/1.10/0.18/1.45)\n");
feat(editor): add --gen-mesh-crate shipping-crate primitive 48th procedural mesh: 5-box wooden shipping crate — main cube body plus 4 reinforcement posts running along the vertical edges. The posts extend slightly proud of the body on each axis so they read as separate rails rather than texture detail, and don't z-fight the body's faces from any viewing angle. Useful for dock yards, warehouse interiors, dungeon room set dressing, NPC merchant shops. Defaults to a 0.80m cube with 0.05m post half-thickness.
2026-05-09 08:28:53 -07:00
std::printf(" --gen-mesh-crate <wom-base> [size] [postRadius]\n");
std::printf(" Crate: cube body + 4 corner reinforcement posts (default 0.80/0.05)\n");
feat(editor): add --gen-mesh-stool small-furniture primitive 49th procedural mesh: 5-box backless stool — flat square seat on 4 short legs at the corners. Smaller-footprint counterpart to --gen-mesh-bench, pairs with --gen-mesh-table for taverns, workshops, NPC market stalls, dwarven taprooms. Defaults to 0.36m square seat at 0.49m total height — typical 3-legged-bar-stool proportions. Customizable per dimension so the same primitive covers child stools, milking stools, and tall workshop stools.
2026-05-09 08:44:51 -07:00
std::printf(" --gen-mesh-stool <wom-base> [seatSize] [seatThick] [legHeight] [legThick]\n");
std::printf(" Stool: small backless seat on 4 corner legs (default 0.36/0.04/0.45/0.04)\n");
feat(editor): add --gen-mesh-cauldron — 50th procedural mesh Milestone: 50th procedural mesh primitive. 7-box witch's cauldron — 4 small corner legs at the floor, then three stacked tiers approximating the curved silhouette of a cast-iron pot: narrow bottom (60% of rim width), wider mid (90%), and a still-wider thin rim at the top (100%). Without rotated faces this stacked-tier approximation is the cleanest cast-iron-pot read available. Pairs with --gen-mesh-shrine / --gen-mesh-totem for ritual and alchemy set dressing — witch huts, druid camps, dungeon laboratories. Defaults to 0.80 rim width × 0.70 body height (0.80m total with legs).
2026-05-09 08:54:27 -07:00
std::printf(" --gen-mesh-cauldron <wom-base> [rimWidth] [bodyHeight] [legHeight]\n");
std::printf(" Cauldron: 4 legs + narrow bottom + wider mid + widest rim tiers (default 0.80/0.70/0.10)\n");
feat(editor): add --gen-mesh-gate wooden farm-gate primitive 51st procedural mesh: 5-box wooden gate — 2 vertical posts on either side and 3 horizontal cross rails (top, middle, bottom) spanning the opening. The gate sits flat in the X-Y plane (rails along X, posts along Y) so it can hang in a wall slot or fence gap without needing rotation. Useful for fenced fields, manor entrances, pen openings, courtyard barriers, dungeon archway closures. Defaults to a 1.80m opening with 1.30m-tall posts. Pairs with --gen-mesh-fence for complete enclosures, exporting through the open-format ecosystem (WOM -> OBJ / GLB / STL) so designers can preview the gate-to-fence joinery in any external tool.
2026-05-09 09:02:04 -07:00
std::printf(" --gen-mesh-gate <wom-base> [openingWidth] [postHeight] [postT] [railT]\n");
std::printf(" Gate: 2 vertical posts + 3 horizontal rails (default 1.80/1.30/0.10/0.06)\n");
feat(editor): add --gen-mesh-beehive (skep) primitive 52nd procedural mesh: woven straw beehive (skep) — 4 stacked tiers of decreasing width approximating a dome (100% / 90% / 70% / 40% of base width), an optional foundation plate underneath, and a small entrance notch box on the +Z face that reads as a cutout rather than texture detail. Useful for druidic groves, beekeeper farms, hunter camps, peasant cottages — anywhere a fantasy world wants honey production. Defaults to 0.70m base × 0.85m tall with a small 0.05m foundation plate.
2026-05-09 09:11:36 -07:00
std::printf(" --gen-mesh-beehive <wom-base> [baseWidth] [height] [plateH]\n");
std::printf(" Beehive (skep): 4 tapered tiers + entrance notch on +Z face (default 0.70/0.85/0.05)\n");
feat(editor): add --gen-mesh-weathervane rooftop primitive 53rd procedural mesh: 6-box rooftop wind indicator — base plate, tall vertical post, perpendicular N-S and E-W cross arms (cardinal direction markers), a long horizontal arrow on top of the cross, and a small tail box at the back end of the arrow that visually balances the head and gives the arrow its directional read. Useful for farm rooftops, chapel spires, town halls, lighthouse caps, manor turrets — anywhere a fantasy world wants visible wind direction. Defaults to a 1.50m post with 0.40m cross arms and a 0.55m-half-length arrow (~1.67m total).
2026-05-09 09:20:08 -07:00
std::printf(" --gen-mesh-weathervane <wom-base> [postH] [postT] [baseSize] [armLen] [arrowLen]\n");
std::printf(" Weathervane: base + post + N-S/E-W cross arms + arrow with tail (default 1.50/0.05/0.30/0.40/0.55)\n");
feat(editor): add --gen-mesh-scarecrow farm-prop primitive 54th procedural mesh: 5-box cruciform farm pest deterrent — vertical body post, horizontal cross arm, head box on top of the body, brimmed hat box that's wider than the head, and a narrower-but-taller crown box on top of the hat brim. The cross silhouette + brimmed-hat read as a scarecrow without needing rotated geometry. Useful for crop fields, abandoned villages, harvest set dressing, ritual circles, fields after a battle. Defaults to 1.80m body × 1.40m arm span (~2.18m total height).
2026-05-09 09:27:56 -07:00
std::printf(" --gen-mesh-scarecrow <wom-base> [bodyH] [armSpan] [postT] [headSize] [hatSize]\n");
std::printf(" Scarecrow: cruciform body + cross arms + head + brimmed hat (default 1.80/1.40/0.06/0.22/0.32)\n");
feat(editor): add --gen-mesh-sundial garden-timekeeper primitive 55th procedural mesh: 6-box garden sundial — square base plate at floor, central vertical gnomon slab spanning the diameter (long axis along Z, the blade that casts a shadow), and 4 small hour-marker nubs at the cardinal points (N/S/E/W) around the rim. Useful for monastery courtyards, mage tower observatories, druidic stone circles, manor gardens — anywhere a fantasy world wants visible time-keeping. Defaults to 0.80m square base with 0.35m gnomon (~0.41m total height).
2026-05-09 09:37:13 -07:00
std::printf(" --gen-mesh-sundial <wom-base> [baseSize] [baseH] [gnomonH] [gnomonT]\n");
std::printf(" Sundial: square base + central gnomon slab + 4 cardinal hour markers (default 0.80/0.06/0.35/0.04)\n");
feat(editor): add --gen-mesh-podium ceremony-platform primitive 56th procedural mesh: stepped pyramid speaker stand — configurable number of steps (2..8) tapering from base to top with equal step heights for visual rhythm, plus a small lectern box positioned at the back of the top platform so a speaker has room in front. Top platform is half the base footprint, with each step shrinking by an equal increment. Useful for throne rooms, ceremonial dais, NPC speaker positions, monument bases, judgment platforms. Defaults to 1.60m base × 3 steps with a 0.30m lectern (~0.96m total).
2026-05-09 09:46:59 -07:00
std::printf(" --gen-mesh-podium <wom-base> [baseSize] [stepH] [steps] [lecternSize]\n");
std::printf(" Podium: stepped pyramid + lectern at back of top platform (default 1.60/0.20/3/0.30)\n");
feat(editor): add --gen-mesh-brazier fire-pit primitive 57th procedural mesh: 7-box brazier — square base plate, narrow vertical stem, wider bowl on top of the stem, and 3 flame boxes of varying heights rising from the bowl. The flame layout is a triangle (tallest center, two shorter on either side) so the silhouette reads as fire rather than a uniform block. Useful for dungeons, temples, watchtowers, throne rooms, goblin camps — anywhere a fantasy world needs visible light sources. Defaults to 0.55m bowl on a 0.80m stem (~1.28m total height).
2026-05-09 09:56:38 -07:00
std::printf(" --gen-mesh-brazier <wom-base> [bowlSize] [stemH] [stemT] [baseSize]\n");
std::printf(" Brazier: base + stem + bowl + 3 flame boxes for fire-pit lighting (default 0.55/0.80/0.10/0.35)\n");
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
std::printf(" --gen-mesh-archway-double <wom-base> [openingW] [openingH] [postT] [lintelT]\n");
std::printf(" Double archway: 3 posts + 2 lintels for twin-opening passages (default 1.40/2.40/0.18/0.20)\n");
refactor(editor): extract printUsage into cli_help.cpp Pulls the 597-line block of printf calls that emits the --help text out of main.cpp into its own translation unit. printUsage is the longest single function in main.cpp by far and was pure boilerplate (no logic, just a flat list of help lines). Function moved verbatim to wowee::editor::cli::printUsage; all 6 in-tree callers (--list-commands, --info-cli-stats, --info-cli-categories, --info-cli-help, --validate-cli-help, and the bare --help/-h handler) updated to the namespaced name. The CLI-meta commands continue to capture printUsage's stdout the same way, so behavior is identical (verified by re-running --validate-cli-help, --info-cli-stats, --list-commands). main.cpp drops 26,650 → 26,286 lines (-364 net; -597 from the removal, +233 from the include and namespace-prefixing the six call sites... wait, no, +6). Actually main.cpp net delta matches the body extraction.
2026-05-08 20:12:15 -07:00
std::printf(" Procedural tree: cylindrical trunk + spherical foliage (default 0.1/2.0/0.7)\n");
std::printf(" --displace-mesh <wom-base> <heightmap.png> [scale]\n");
std::printf(" Offset each vertex along its normal by heightmap brightness × scale (default 1.0)\n");
std::printf(" --gen-mesh-from-heightmap <wom-base> <heightmap.png> [scaleXZ] [scaleY]\n");
std::printf(" Convert a grayscale PNG into a heightmap mesh (W×H verts, 2(W-1)(H-1) tris)\n");
std::printf(" --export-mesh-heightmap <wom-base> <out.png> <W> <H>\n");
std::printf(" Extract a grayscale heightmap PNG from a row-major W×H heightmap mesh\n");
std::printf(" --add-texture-to-mesh <wom-base> <png-path> [batchIdx]\n");
std::printf(" Bind an existing PNG into a WOM's texturePaths and point batchIdx (default 0) at it\n");
std::printf(" --scale-mesh <wom-base> <factor>\n");
std::printf(" Uniformly scale every vertex and bounds by <factor> (factor > 0)\n");
std::printf(" --translate-mesh <wom-base> <dx> <dy> <dz>\n");
std::printf(" Offset every vertex and bounds by (dx, dy, dz)\n");
std::printf(" --strip-mesh <wom-base> [--bones] [--anims] [--all]\n");
std::printf(" Drop bones / animations from a WOM in place (smaller file, static-only use)\n");
std::printf(" --rotate-mesh <wom-base> <x|y|z> <degrees>\n");
std::printf(" Rotate every vertex + normal around the chosen axis by <degrees>\n");
std::printf(" --center-mesh <wom-base>\n");
std::printf(" Translate so the bounds center lands at origin (no scale/rotation change)\n");
std::printf(" --flip-mesh-normals <wom-base>\n");
std::printf(" Invert every vertex normal (use for inside-out meshes or two-sided pre-flip)\n");
std::printf(" --mirror-mesh <wom-base> <x|y|z>\n");
std::printf(" Mirror every vertex + normal across the chosen axis (also flips winding)\n");
std::printf(" --smooth-mesh-normals <wom-base>\n");
std::printf(" Recompute per-vertex normals as area-weighted averages of incident face normals\n");
std::printf(" --merge-meshes <a-base> <b-base> <out-base>\n");
std::printf(" Combine two WOMs into one (vertex/index buffers concatenated, batches preserved)\n");
std::printf(" --add-item <zoneDir> <name> [id] [quality] [displayId] [itemLevel]\n");
std::printf(" Append one item entry to <zoneDir>/items.json (auto-creates the file)\n");
std::printf(" --random-populate-zone <zoneDir> [--seed N] [--creatures N] [--objects N]\n");
std::printf(" Add random creatures/objects to a zone (seeded for reproducibility)\n");
std::printf(" --random-populate-items <zoneDir> [--seed N] [--count N] [--max-quality Q]\n");
std::printf(" Generate random items.json entries (seeded; quality cap defaults to epic=4)\n");
std::printf(" --gen-zone-texture-pack <zoneDir> [--seed N]\n");
std::printf(" Drop a starter texture pack (grass/dirt/stone/brick/wood/water) into <zoneDir>/textures/\n");
std::printf(" --gen-zone-mesh-pack <zoneDir> [--seed N]\n");
std::printf(" Drop a starter WOM mesh pack (rock/tree/fence) into <zoneDir>/meshes/\n");
std::printf(" --gen-zone-starter-pack <zoneDir> [--seed N]\n");
std::printf(" Run both texture-pack + mesh-pack in one pass — full open-format bootstrap\n");
std::printf(" --gen-project-starter-pack <projectDir> [--seed N]\n");
std::printf(" Run starter-pack + audio-pack across every zone — full project-scope bootstrap\n");
std::printf(" --info-zone-summary <zoneDir> [--json]\n");
std::printf(" One-glance health digest for a zone: pack counts/bytes + audit pass/fail\n");
std::printf(" --info-zone-deps <zoneDir> [--json]\n");
std::printf(" Find textures referenced by WOMs but missing from <zoneDir>/textures/ (broken-ref audit)\n");
std::printf(" --info-project-deps <projectDir>\n");
std::printf(" Run --info-zone-deps across every zone; reports per-zone PASS/FAIL + grand total\n");
std::printf(" --info-project-summary <projectDir> [--json]\n");
std::printf(" One-glance status table per zone in a project (BOOTSTRAPPED/PARTIAL/EMPTY)\n");
std::printf(" --gen-zone-readme <zoneDir> [--out <path>]\n");
std::printf(" Auto-generate README.md from zone.json + asset inventory (writes README.md by default)\n");
std::printf(" --gen-project-readme <projectDir> [--out <path>]\n");
std::printf(" Auto-generate PROJECT.md with per-zone status + asset count rollup\n");
std::printf(" --validate-zone-pack <zoneDir> [--json]\n");
std::printf(" Audit a zone's open-format asset pack: textures/meshes/audio counts + WOM validity\n");
std::printf(" --validate-project-packs <projectDir>\n");
std::printf(" Run validate-zone-pack across every zone in a project; exits 1 if any fails\n");
std::printf(" --gen-audio-tone <out.wav> <freqHz> <durationSec> [sampleRate] [waveform]\n");
std::printf(" Synthesize a procedural WAV (PCM-16 mono). Waveform: sine|square|triangle|saw\n");
std::printf(" --gen-audio-noise <out.wav> <durationSec> [sampleRate] [color] [seed] [amplitude]\n");
std::printf(" Synthesize procedural noise WAV. Color: white|pink|brown (default white, amp 0.5)\n");
std::printf(" --gen-audio-sweep <out.wav> <startHz> <endHz> <durationSec> [sampleRate] [shape]\n");
std::printf(" Synthesize frequency sweep (chirp) WAV. Shape: linear|exp (default linear)\n");
std::printf(" --gen-zone-audio-pack <zoneDir>\n");
std::printf(" Drop a starter WAV pack (drone/chime/click/alert) into <zoneDir>/audio/\n");
std::printf(" --gen-random-zone <name> [tx ty] [--seed N] [--creatures N] [--objects N] [--items N]\n");
std::printf(" End-to-end: scaffold-zone + random-populate-zone + random-populate-items\n");
std::printf(" --gen-random-project <count> [--prefix N] [--seed N] [--creatures N] [--objects N] [--items N]\n");
std::printf(" Generate <count> random zones at once (names like Zone1, Zone2...; tile coords step)\n");
std::printf(" --info-zone-audio <zoneDir> [--json]\n");
std::printf(" Print zone audio config (music + ambience tracks, volumes)\n");
std::printf(" --info-project-audio <projectDir> [--json]\n");
std::printf(" Audio config table across every zone (which zones have music/ambience set)\n");
std::printf(" --snap-zone-to-ground <zoneDir>\n");
std::printf(" Re-snap every creature/object in a zone to actual terrain height\n");
std::printf(" --audit-zone-spawns <zoneDir> [--threshold yards]\n");
std::printf(" List spawns whose Z is more than <threshold> yards off from the terrain (default 5)\n");
std::printf(" --list-zone-spawns <zoneDir> [--json]\n");
std::printf(" Combined creature+object listing for a zone (kind, name, position, key fields)\n");
std::printf(" --diff-zone-spawns <aZoneDir> <bZoneDir>\n");
std::printf(" Compare two zones' creature+object lists (added/removed/moved)\n");
std::printf(" --info-spawn <zoneDir> <creature|object> <index> [--json]\n");
std::printf(" Detailed view of a single creature/object spawn by index\n");
std::printf(" --list-project-spawns <projectDir> [--json]\n");
std::printf(" Combined creature+object listing across every zone (zone column added)\n");
std::printf(" --audit-project-spawns <projectDir> [--threshold yards]\n");
std::printf(" Run --audit-zone-spawns across every zone (per-zone summary + total)\n");
std::printf(" --snap-project-to-ground <projectDir>\n");
std::printf(" Run --snap-zone-to-ground across every zone (per-zone summary + totals)\n");
std::printf(" --list-items <zoneDir> [--json]\n");
std::printf(" Print every item in <zoneDir>/items.json with quality colors and key fields\n");
std::printf(" --export-zone-items-md <zoneDir> [out.md]\n");
std::printf(" Render items.json as a Markdown table grouped by quality (rare/epic/etc.)\n");
std::printf(" --export-project-items-md <projectDir> [out.md]\n");
std::printf(" Project-wide items markdown: per-zone sections, project quality histogram\n");
std::printf(" --export-project-items-csv <projectDir> [out.csv]\n");
std::printf(" Single CSV with every item across every zone (zone column added for grouping)\n");
std::printf(" --info-item <zoneDir> <id|index> [--json]\n");
std::printf(" Detail view for one item (lookup by id, or by index if prefixed with '#')\n");
std::printf(" --set-item <zoneDir> <id|#index> [--name S] [--quality N] [--displayId N] [--itemLevel N] [--stackable N]\n");
std::printf(" Edit fields on an existing item in place; only specified flags are changed\n");
std::printf(" --remove-item <zoneDir> <index>\n");
std::printf(" Remove item at given 0-based index from <zoneDir>/items.json\n");
std::printf(" --copy-zone-items <fromZoneDir> <toZoneDir> [--merge]\n");
std::printf(" Copy items from one zone to another (default replaces; --merge appends with re-id)\n");
std::printf(" --clone-item <zoneDir> <index> [newName]\n");
std::printf(" Duplicate the item at index, assign next free id (and optional name override)\n");
std::printf(" --validate-items <zoneDir>\n");
std::printf(" Schema check on items.json: duplicate ids, quality range, required fields\n");
std::printf(" --validate-project-items <projectDir>\n");
std::printf(" Run --validate-items across every zone (per-zone PASS/FAIL + aggregate)\n");
std::printf(" --info-project-items <projectDir> [--json]\n");
std::printf(" Aggregate item counts and quality histogram across every zone in a project\n");
std::printf(" --convert-dbc-json <dbc-path> [out.json]\n");
std::printf(" Convert one DBC file to wowee JSON sidecar format\n");
std::printf(" --convert-json-dbc <json-path> [out.dbc]\n");
std::printf(" Convert a wowee JSON DBC back to binary DBC for private-server compat\n");
std::printf(" --convert-blp-png <blp-path> [out.png]\n");
std::printf(" Convert one BLP texture to PNG sidecar\n");
std::printf(" --convert-blp-batch <srcDir>\n");
std::printf(" Bulk BLP→PNG conversion across every .blp in <srcDir> (sidecars next to source)\n");
std::printf(" --migrate-wom <wom-base> [out-base]\n");
std::printf(" Upgrade an older WOM (v1/v2) to WOM3 with a default single-batch entry\n");
std::printf(" --migrate-zone <zoneDir>\n");
std::printf(" Run --migrate-wom in-place on every WOM under <zoneDir>\n");
std::printf(" --migrate-project <projectDir>\n");
std::printf(" Run --migrate-zone across every zone in <projectDir>\n");
std::printf(" --migrate-jsondbc <path> [out.json]\n");
std::printf(" Auto-fix a JSON DBC sidecar: add missing format/source, sync recordCount\n");
std::printf(" --list-zones [--json] List discovered custom zones and exit\n");
std::printf(" --zone-stats <projectDir> [--json]\n");
std::printf(" Aggregate counts across every zone in <projectDir>\n");
std::printf(" --info-tilemap <projectDir> [--json]\n");
std::printf(" ASCII-render the 64x64 WoW ADT grid showing tile claims by zone\n");
std::printf(" --list-project-orphans <projectDir> [--json]\n");
std::printf(" Find .wom/.wob files in zones not referenced by any objects.json or doodad list\n");
std::printf(" --remove-project-orphans <projectDir> [--dry-run]\n");
std::printf(" Delete the orphan .wom/.wob files surfaced by --list-project-orphans\n");
std::printf(" --list-zone-deps <zoneDir> [--json]\n");
std::printf(" List external M2/WMO model paths a zone references (objects + WOB doodads)\n");
std::printf(" --export-zone-deps-md <zoneDir> [out.md]\n");
std::printf(" Markdown dep table for a zone (with on-disk presence column)\n");
std::printf(" --export-zone-spawn-png <zoneDir> [out.png]\n");
std::printf(" Top-down PNG of creature + object spawn positions (per-tile-bounded)\n");
std::printf(" --check-zone-refs <zoneDir> [--json]\n");
std::printf(" Verify every referenced model/quest NPC actually exists; exit 1 on missing refs\n");
std::printf(" --check-project-refs <projectDir> [--json]\n");
std::printf(" Run --check-zone-refs across every zone in <projectDir>\n");
std::printf(" --check-zone-content <zoneDir> [--json]\n");
std::printf(" Sanity-check creature/object/quest fields for plausible values\n");
std::printf(" --check-project-content <projectDir> [--json]\n");
std::printf(" Run --check-zone-content across every zone in <projectDir>\n");
std::printf(" --for-each-zone <projectDir> -- <cmd...>\n");
std::printf(" Run <cmd...> for every zone in <projectDir>; '{}' in cmd is replaced with the zone path\n");
std::printf(" --for-each-tile <zoneDir> -- <cmd...>\n");
std::printf(" Run <cmd...> for every tile in <zoneDir>; '{}' replaced with the tile-base path\n");
std::printf(" --scaffold-zone <name> [tx ty] Create a blank zone in custom_zones/<name>/ and exit\n");
std::printf(" --mvp-zone <name> [tx ty]\n");
std::printf(" Scaffold + add a creature + object + quest (with objective+reward) for quick demos\n");
std::printf(" --add-tile <zoneDir> <tx> <ty> [baseHeight]\n");
std::printf(" Add a new ADT tile to an existing zone (extends the manifest's tiles list)\n");
std::printf(" --remove-tile <zoneDir> <tx> <ty>\n");
std::printf(" Remove a tile from a zone (drops manifest entry + deletes WHM/WOT/WOC files)\n");
std::printf(" --list-tiles <zoneDir> [--json]\n");
std::printf(" List every tile in a zone manifest with on-disk file presence\n");
std::printf(" --add-creature <zoneDir> <name> <x> <y> <z> [displayId] [level]\n");
std::printf(" Append one creature spawn to <zoneDir>/creatures.json and exit\n");
std::printf(" --add-object <zoneDir> <m2|wmo> <gamePath> <x> <y> <z> [scale]\n");
std::printf(" Append one object placement to <zoneDir>/objects.json and exit\n");
std::printf(" --add-quest <zoneDir> <title> [giverId] [turnInId] [xp] [level]\n");
std::printf(" Append one quest to <zoneDir>/quests.json and exit\n");
std::printf(" --add-quest-objective <zoneDir> <questIdx> <kill|collect|talk|explore|escort|use> <targetName> [count]\n");
std::printf(" Append one objective to a quest by index\n");
std::printf(" --remove-quest-objective <zoneDir> <questIdx> <objIdx>\n");
std::printf(" Remove the objective at given 0-based index from a quest\n");
std::printf(" --clone-quest <zoneDir> <questIdx> [newTitle]\n");
std::printf(" Duplicate a quest (with all objectives + rewards) and append it\n");
std::printf(" --clone-creature <zoneDir> <idx> [newName] [dx dy dz]\n");
std::printf(" Duplicate a creature spawn (defaults: '<orig> (copy)' offset by 5 yards)\n");
std::printf(" --clone-object <zoneDir> <idx> [dx dy dz]\n");
std::printf(" Duplicate an object placement (defaults: offset by 5 yards X)\n");
std::printf(" --add-quest-reward-item <zoneDir> <questIdx> <itemPath> [more...]\n");
std::printf(" Append item reward(s) to a quest's reward.itemRewards list\n");
std::printf(" --set-quest-reward <zoneDir> <questIdx> [--xp N] [--gold N] [--silver N] [--copper N]\n");
std::printf(" Update XP/coin reward fields on a quest by index\n");
std::printf(" --remove-creature <zoneDir> <index>\n");
std::printf(" Remove creature at given 0-based index from <zoneDir>/creatures.json\n");
std::printf(" --remove-object <zoneDir> <index>\n");
std::printf(" Remove object at given 0-based index from <zoneDir>/objects.json\n");
std::printf(" --remove-quest <zoneDir> <index>\n");
std::printf(" Remove quest at given 0-based index from <zoneDir>/quests.json\n");
std::printf(" --copy-zone <srcDir> <newName>\n");
std::printf(" Duplicate a zone to custom_zones/<slug>/ with renamed slug-prefixed files\n");
std::printf(" --rename-zone <srcDir> <newName>\n");
std::printf(" In-place rename (zone.json + slug-prefixed files + dir); no copy\n");
std::printf(" --remove-zone <zoneDir> [--confirm]\n");
std::printf(" Delete a zone directory entirely (requires --confirm to actually delete)\n");
std::printf(" --clear-zone-content <zoneDir> [--creatures] [--objects] [--quests] [--all]\n");
std::printf(" Wipe one or more content files (terrain + manifest preserved)\n");
std::printf(" --strip-zone <zoneDir> [--dry-run]\n");
std::printf(" Remove derived outputs (.glb/.obj/.stl/.html/.dot/.csv/ZONE.md/DEPS.md)\n");
std::printf(" --strip-project <projectDir> [--dry-run]\n");
std::printf(" Run --strip-zone across every zone (per-zone counts + aggregate freed bytes)\n");
std::printf(" --gen-makefile <zoneDir> [out.mk]\n");
std::printf(" Generate a Makefile that rebuilds every derived output for a zone\n");
std::printf(" --gen-project-makefile <projectDir> [out.mk]\n");
std::printf(" Generate a top-level Makefile that delegates to each zone's per-zone Makefile\n");
std::printf(" --repair-project <projectDir> [--dry-run]\n");
std::printf(" Run --repair-zone across every zone (manifest drift fixes, per-zone summary)\n");
std::printf(" --repair-zone <zoneDir> [--dry-run]\n");
std::printf(" Auto-fix manifest/disk drift (missing tiles in manifest, hasCreatures flag)\n");
std::printf(" --build-woc <wot-base> Generate a WOC collision mesh from WHM/WOT and exit\n");
std::printf(" --regen-collision <zoneDir> Rebuild every WOC under a zone dir and exit\n");
std::printf(" --fix-zone <zoneDir> Re-parse + re-save zone JSONs to apply latest scrubs/caps and exit\n");
std::printf(" --export-png <wot-base> Render heightmap, normal-map, and zone-map PNG previews\n");
std::printf(" --export-obj <wom-base> [out.obj]\n");
std::printf(" Convert a WOM model to Wavefront OBJ for use in Blender/MeshLab\n");
std::printf(" --export-glb <wom-base> [out.glb]\n");
std::printf(" Convert a WOM model to glTF 2.0 binary (.glb) — modern industry standard\n");
std::printf(" --export-stl <wom-base> [out.stl]\n");
std::printf(" Convert a WOM model to ASCII STL — works with any 3D printer slicer\n");
std::printf(" --import-stl <stl-path> [wom-base]\n");
std::printf(" Convert an ASCII STL back into WOM (round-trips with --export-stl)\n");
std::printf(" --export-wob-glb <wob-base> [out.glb]\n");
std::printf(" Convert a WOB building to glTF 2.0 binary (one mesh, per-group primitives)\n");
std::printf(" --export-whm-glb <wot-base> [out.glb]\n");
std::printf(" Convert WHM heightmap to glTF 2.0 binary terrain mesh (per-chunk primitives)\n");
std::printf(" --bake-zone-glb <zoneDir> [out.glb]\n");
std::printf(" Bake every WHM tile in a zone into one glTF (one node per tile)\n");
std::printf(" --bake-zone-stl <zoneDir> [out.stl]\n");
std::printf(" Bake every WHM tile in a zone into one STL for 3D-printing the terrain\n");
std::printf(" --bake-zone-obj <zoneDir> [out.obj]\n");
std::printf(" Bake every WHM tile in a zone into one Wavefront OBJ (one g-block per tile)\n");
std::printf(" --bake-project-obj <projectDir> [out.obj]\n");
std::printf(" Bake every zone in a project into one Wavefront OBJ (one g-block per zone)\n");
std::printf(" --bake-project-stl <projectDir> [out.stl]\n");
std::printf(" Bake every zone in a project into one ASCII STL for full-project printing\n");
std::printf(" --bake-project-glb <projectDir> [out.glb]\n");
std::printf(" Bake every zone in a project into one glTF 2.0 (one mesh per zone)\n");
feat(editor): add --bake-wom-collision WOM→WOC pipeline Convert any WOM mesh into a WOC collision file via WoweeCollisionBuilder::addMesh, with optional --weld <eps> that merges shared positions into a single canonical index before baking. The weld pass is what makes per-face-shaded procedural primitives produce a properly indexed collision mesh — adjacent faces that previously authored 4 unique verts per face now share 1 corner across all incident faces, so raycasts can traverse edges naturally. Also accepts --steep <deg> to control the walkable/steep classification threshold (default 50° from horizontal, matching the terrain pipeline). Smoke-tested end-to-end: • firepit: 240 verts → WOC with 120 tris (20 walkable floor, 20 steep stone walls, rest neutral) • tent_solid: 18 verts welds to 6, produces 8-tri WOC • canopy: 216 → 56 weld, 108 tris, 30° steep cut Pairs naturally with --info-mesh-stats --weld for collision-quality QA before baking.
2026-05-09 11:01:45 -07:00
std::printf(" --bake-wom-collision <wom-base> [out.woc] [--weld <eps>] [--steep <deg>]\n");
std::printf(" Convert a WOM into a WOC collision file (raycast / walkability mesh) with optional vertex weld\n");
feat(editor): add --bake-wob-collision multi-group WOB→WOC Sibling of --bake-wom-collision for buildings. Walks every group in a WOB, optionally welds vertices PER GROUP (groups are intentionally separate — rooms with portals between them, so welding across groups would fuse walls that should remain distinct collision surfaces), and appends each to a single WoweeCollision via WoweeCollisionBuilder::addMesh. Same flag surface as the WOM variant: optional [out.woc] output path, --weld <eps> for per-group vertex merge, --steep <deg> for the walkable/steep slope cutoff. Smoke tested on a 1-group cube WOB: 8 verts → 12-triangle WOC with proper bounds (-1,-1,-1)..(1,1,1) and walkable/ steep classification matching the cube face orientations.
2026-05-09 11:19:09 -07:00
std::printf(" --bake-wob-collision <wob-base> [out.woc] [--weld <eps>] [--steep <deg>]\n");
std::printf(" Convert a multi-group WOB building into a single WOC collision file (weld is per-group)\n");
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
std::printf(" --bake-zone-collision <zoneDir> [out.woc] [--weld <eps>] [--steep <deg>]\n");
std::printf(" Walk every .wom + .wob under zoneDir, weld each independently, append to one shared WOC\n");
feat(editor): add --summary flag to --audit-watertight CI-friendly one-line rollup mode for the welded watertight audit. Replaces the per-mesh PASS/FAIL detail lines with a single status line: watertight: FAIL (121 meshes, 27 failure(s)) [/tmp/migtest, weld 0.001000] watertight: PASS (6 meshes, 0 failure(s)) [/tmp/camp, weld 0.001000] Format: "watertight: <PASS|FAIL> (<N> meshes, <K> failure(s)) [<root>, weld <eps>]". Exit code unchanged — failure count capped at 255, matching the verbose-mode contract. Useful for build dashboards / CI grep lines / Slack-bot notifications where the full per-mesh dump would be too noisy. Verbose mode is still the default; opt in with --summary.
2026-05-09 13:09:28 -07:00
std::printf(" --audit-watertight <zoneDir|projectDir> [--weld <eps>] [--json] [--summary]\n");
std::printf(" Walk every .wom under root, run welded watertight check; --summary prints a one-line rollup\n");
feat(editor): add --summary flag to --audit-watertight-wob Parity with the WOM-side --audit-watertight --summary added last batch. Same one-line rollup format for CI dashboards: watertight-wob: PASS (1 buildings, 0 failure(s)) [/tmp/migtest, weld 0.001000] watertight-wob: FAIL (12 buildings, 4 failure(s)) [/tmp/zone, weld 0.001000] Format: "watertight-wob: <PASS|FAIL> (<N> buildings, <K> failure(s)) [<root>, weld <eps>]". Exit code unchanged — failure count capped at 255. Both --audit-watertight (WOM) and --audit-watertight-wob (WOB) now offer the same trio of output modes: verbose (default), --json (machine-readable), --summary (one-line CI rollup).
2026-05-09 13:12:42 -07:00
std::printf(" --audit-watertight-wob <zoneDir|projectDir> [--weld <eps>] [--json] [--summary]\n");
std::printf(" Walk every .wob, check that EVERY group is closed (per-group weld); --summary prints one-line rollup\n");
refactor(editor): extract printUsage into cli_help.cpp Pulls the 597-line block of printf calls that emits the --help text out of main.cpp into its own translation unit. printUsage is the longest single function in main.cpp by far and was pure boilerplate (no logic, just a flat list of help lines). Function moved verbatim to wowee::editor::cli::printUsage; all 6 in-tree callers (--list-commands, --info-cli-stats, --info-cli-categories, --info-cli-help, --validate-cli-help, and the bare --help/-h handler) updated to the namespaced name. The CLI-meta commands continue to capture printUsage's stdout the same way, so behavior is identical (verified by re-running --validate-cli-help, --info-cli-stats, --list-commands). main.cpp drops 26,650 → 26,286 lines (-364 net; -597 from the removal, +233 from the include and namespace-prefixing the six call sites... wait, no, +6). Actually main.cpp net delta matches the body extraction.
2026-05-08 20:12:15 -07:00
std::printf(" --import-obj <obj-path> [wom-base]\n");
std::printf(" Convert a Wavefront OBJ back into WOM (round-trips with --export-obj)\n");
std::printf(" --export-wob-obj <wob-base> [out.obj]\n");
std::printf(" Convert a WOB building to Wavefront OBJ (one group per WOB group)\n");
std::printf(" --import-wob-obj <obj-path> [wob-base]\n");
std::printf(" Convert a Wavefront OBJ back into WOB (round-trips with --export-wob-obj)\n");
std::printf(" --export-woc-obj <woc-path> [out.obj]\n");
std::printf(" Convert a WOC collision mesh to OBJ for visualization (per-flag color groups)\n");
std::printf(" --export-whm-obj <wot-base> [out.obj]\n");
std::printf(" Convert a WHM heightmap to OBJ terrain mesh (9x9 outer grid per chunk)\n");
std::printf(" --validate <zoneDir> [--json]\n");
std::printf(" Score zone open-format completeness and exit\n");
std::printf(" --validate-wom <wom-base> [--json]\n");
std::printf(" Deep-check a WOM file for index/bone/batch/bound invariants\n");
std::printf(" --validate-wob <wob-base> [--json]\n");
std::printf(" Deep-check a WOB file for group/portal/doodad invariants\n");
std::printf(" --validate-woc <woc-path> [--json]\n");
std::printf(" Deep-check a WOC collision mesh for finite verts and degeneracy\n");
std::printf(" --validate-whm <wot-base> [--json]\n");
std::printf(" Deep-check a WHM/WOT terrain pair for NaN heights and bad placements\n");
std::printf(" --validate-all <dir> [--json]\n");
std::printf(" Recursively run all per-format validators on every file\n");
std::printf(" --validate-project <projectDir> [--json]\n");
std::printf(" Run --validate-all on every zone in <projectDir>; exit 1 if any zone fails\n");
std::printf(" --bench-validate-project <projectDir> [--json]\n");
std::printf(" Time --validate-project per zone; report avg/min/max latency\n");
std::printf(" --bench-bake-project <projectDir> [--json]\n");
std::printf(" Time WHM/WOT load per zone (proxy for bake cost); report timings\n");
std::printf(" --validate-glb <path> [--json]\n");
std::printf(" Verify a glTF 2.0 binary's structure (magic, chunks, JSON, accessors)\n");
std::printf(" --check-glb-bounds <path> [--json]\n");
std::printf(" Verify position accessor min/max in a .glb actually matches the data\n");
std::printf(" --validate-stl <path> [--json]\n");
std::printf(" Verify an ASCII STL's structure (solid framing, facet/vertex shape, no NaN)\n");
std::printf(" --validate-png <path> [--json]\n");
std::printf(" Verify a PNG's structure (signature, chunks, CRC, IHDR/IDAT/IEND order)\n");
std::printf(" --validate-blp <path> [--json]\n");
std::printf(" Verify a BLP texture (magic, dimensions, mip offsets within file)\n");
std::printf(" --validate-jsondbc <path> [--json]\n");
std::printf(" Verify a JSON DBC sidecar's full schema (per-cell types, row width, format tag)\n");
std::printf(" --info-glb <path> [--json]\n");
std::printf(" Print glTF 2.0 binary metadata (chunks, mesh/primitive counts, accessors)\n");
std::printf(" --info-glb-bytes <path> [--json]\n");
std::printf(" Per-section + per-bufferView byte breakdown of a .glb file\n");
std::printf(" --info-glb-tree <path>\n");
std::printf(" Render glTF structure as a tree (scenes/nodes/meshes/primitives)\n");
std::printf(" --zone-summary <zoneDir> [--json]\n");
std::printf(" One-shot validate + creature/object/quest counts and exit\n");
std::printf(" --info-zone-tree <zoneDir>\n");
std::printf(" Render a hierarchical tree view of a zone's contents (no --json)\n");
std::printf(" --info-project-tree <projectDir>\n");
std::printf(" Tree view of every zone in a project with quick counts (no --json)\n");
std::printf(" --info-project-bytes <projectDir> [--json]\n");
std::printf(" Per-zone byte rollup with proprietary-vs-open category split (size audit)\n");
std::printf(" --validate-project-open-only <projectDir>\n");
std::printf(" Exit 1 if any proprietary Blizzard assets (.m2/.wmo/.blp/.dbc) remain — release gate\n");
std::printf(" --audit-project <projectDir>\n");
std::printf(" Run validate-project + open-only + check-project-refs together; one PASS/FAIL\n");
std::printf(" --bench-audit-project <projectDir>\n");
std::printf(" Time each --audit-project sub-step; shows where the slow ones are\n");
std::printf(" --info-zone-bytes <zoneDir> [--json]\n");
std::printf(" Per-file size breakdown grouped by category, sorted largest-first\n");
std::printf(" --info-project-extents <projectDir> [--json]\n");
std::printf(" Combined spatial bounding box across every zone (per-zone table + project union)\n");
std::printf(" --info-zone-extents <zoneDir> [--json]\n");
std::printf(" Compute the zone's bounding box (XY tile range, Z height min/max)\n");
std::printf(" --info-project-water <projectDir> [--json]\n");
std::printf(" Aggregate water-layer stats across every zone (per-zone breakdown + project totals)\n");
std::printf(" --info-zone-water <zoneDir> [--json]\n");
std::printf(" Aggregate water-layer stats across all tiles (layer count, types, area)\n");
std::printf(" --info-project-density <projectDir> [--json]\n");
std::printf(" Per-zone content density rollup (creatures/objects/quests per tile, project totals)\n");
std::printf(" --info-zone-density <zoneDir> [--json]\n");
std::printf(" Per-tile density (creatures/objects/quests per tile + overall avg)\n");
std::printf(" --export-zone-summary-md <zoneDir> [out.md]\n");
std::printf(" Render a markdown documentation page for a zone (manifest + content)\n");
std::printf(" --export-zone-csv <zoneDir> [outDir]\n");
std::printf(" Emit creatures.csv / objects.csv / quests.csv / items.csv for spreadsheet workflows\n");
std::printf(" --export-zone-checksum <zoneDir> [out.sha256]\n");
std::printf(" Emit a SHA-256 manifest of every source file in a zone (for integrity checks)\n");
std::printf(" --export-project-checksum <projectDir> [out.sha256]\n");
std::printf(" Project-wide SHA-256 manifest (paths are zone-relative) + single project fingerprint\n");
std::printf(" --validate-project-checksum <projectDir> [in.sha256]\n");
std::printf(" Verify PROJECT_SHA256SUMS in-tool (cross-platform, no sha256sum dependency)\n");
std::printf(" --export-zone-html <zoneDir> [out.html]\n");
std::printf(" Emit a single-file HTML viewer next to the zone .glb (model-viewer based)\n");
std::printf(" --export-project-html <projectDir> [out.html]\n");
std::printf(" Generate an index.html linking to every zone's HTML viewer in <projectDir>\n");
std::printf(" --export-project-md <projectDir> [out.md]\n");
std::printf(" Generate a README.md indexing every zone with counts + viewer/bake status\n");
std::printf(" --export-quest-graph <zoneDir> [out.dot]\n");
std::printf(" Render quest-chain DAG as Graphviz DOT (pipe to `dot -Tpng -o quests.png`)\n");
std::printf(" --info <wom-base> [--json]\n");
std::printf(" Print WOM file metadata (version, counts) and exit\n");
std::printf(" --info-batches <wom-base> [--json]\n");
std::printf(" Per-batch breakdown of a WOM3 (index range, texture, blend mode, flags)\n");
std::printf(" --info-textures <wom-base> [--json]\n");
std::printf(" List every texture path referenced by a WOM (with on-disk presence)\n");
std::printf(" --info-doodads <wob-base> [--json]\n");
std::printf(" List every doodad placement in a WOB (model path, position, rotation, scale)\n");
std::printf(" --info-attachments <m2-path> [--json]\n");
std::printf(" List M2 attachment points (weapon mounts, etc.) with bone + offset\n");
std::printf(" --info-particles <m2-path> [--json]\n");
std::printf(" List M2 particle + ribbon emitters (texture, blend, bone)\n");
std::printf(" --info-sequences <m2-path> [--json]\n");
std::printf(" List M2 animation sequences (id, duration, flags)\n");
std::printf(" --info-bones <m2-path> [--json]\n");
std::printf(" List M2 bones with parent tree, key-bone IDs, pivot offsets\n");
std::printf(" --export-bones-dot <wom-base> [out.dot]\n");
std::printf(" Render WOM bone hierarchy as Graphviz DOT (pipe to `dot -Tpng -o bones.png`)\n");
std::printf(" --list-project-meshes <projectDir> [--json]\n");
std::printf(" Project-wide WOM inventory across every zone (vert/tri totals + per-zone breakdown)\n");
std::printf(" --list-project-audio <projectDir> [--json]\n");
std::printf(" Project-wide WAV inventory across every zone (duration/bytes per zone + grand total)\n");
std::printf(" --list-project-textures <projectDir> [--json]\n");
std::printf(" Aggregate texture refs across every WOM in a project (deduped, with zone breakdown)\n");
std::printf(" --list-zone-meshes <zoneDir> [--json]\n");
std::printf(" List every WOM in <zoneDir> with vert/tri/bone/anim/batch counts and file size\n");
std::printf(" --list-zone-audio <zoneDir> [--json]\n");
std::printf(" List every WAV under <zoneDir>/audio/ with format/duration/sample-rate/size\n");
std::printf(" --list-zone-textures <zoneDir> [--json]\n");
std::printf(" Aggregate texture refs across all WOM models in a zone (deduped)\n");
std::printf(" --info-zone-models-total <zoneDir> [--json]\n");
std::printf(" Aggregate WOM/WOB stats across a zone (verts, tris, bones, batches, doodads)\n");
std::printf(" --list-zone-meshes-detail <zoneDir> [--json]\n");
std::printf(" Per-mesh listing of every .wom in a zone, sorted by triangle count\n");
std::printf(" --info-mesh <wom-base> [--json]\n");
std::printf(" Single-mesh detail: bounds, version, batches, bones, textures, attachments in one view\n");
std::printf(" --info-mesh-storage-budget <wom-base> [--json]\n");
std::printf(" Estimated bytes-per-category breakdown for a single WOM (vertices/indices/bones/...)\n");
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
std::printf(" --info-mesh-stats <wom-base> [--json]\n");
std::printf(" Geometric stats: total surface area, triangle area histogram, edge use, watertight check\n");
refactor(editor): extract printUsage into cli_help.cpp Pulls the 597-line block of printf calls that emits the --help text out of main.cpp into its own translation unit. printUsage is the longest single function in main.cpp by far and was pure boilerplate (no logic, just a flat list of help lines). Function moved verbatim to wowee::editor::cli::printUsage; all 6 in-tree callers (--list-commands, --info-cli-stats, --info-cli-categories, --info-cli-help, --validate-cli-help, and the bare --help/-h handler) updated to the namespaced name. The CLI-meta commands continue to capture printUsage's stdout the same way, so behavior is identical (verified by re-running --validate-cli-help, --info-cli-stats, --list-commands). main.cpp drops 26,650 → 26,286 lines (-364 net; -597 from the removal, +233 from the include and namespace-prefixing the six call sites... wait, no, +6). Actually main.cpp net delta matches the body extraction.
2026-05-08 20:12:15 -07:00
std::printf(" --list-project-meshes-detail <projectDir> [--json]\n");
std::printf(" Per-mesh listing across every zone in a project (sorted by triangle count)\n");
std::printf(" --info-project-models-total <projectDir> [--json]\n");
std::printf(" Aggregate WOM/WOB stats across an entire project (per-zone breakdown + totals)\n");
std::printf(" --info-wob <wob-base> [--json]\n");
std::printf(" Print WOB building metadata (groups, portals, doodads) and exit\n");
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
std::printf(" --info-wob-stats <wob-base> [--weld <eps>] [--json]\n");
std::printf(" Per-group + aggregate geometric stats (surface area, edges, watertight) for a WOB building\n");
refactor(editor): extract printUsage into cli_help.cpp Pulls the 597-line block of printf calls that emits the --help text out of main.cpp into its own translation unit. printUsage is the longest single function in main.cpp by far and was pure boilerplate (no logic, just a flat list of help lines). Function moved verbatim to wowee::editor::cli::printUsage; all 6 in-tree callers (--list-commands, --info-cli-stats, --info-cli-categories, --info-cli-help, --validate-cli-help, and the bare --help/-h handler) updated to the namespaced name. The CLI-meta commands continue to capture printUsage's stdout the same way, so behavior is identical (verified by re-running --validate-cli-help, --info-cli-stats, --list-commands). main.cpp drops 26,650 → 26,286 lines (-364 net; -597 from the removal, +233 from the include and namespace-prefixing the six call sites... wait, no, +6). Actually main.cpp net delta matches the body extraction.
2026-05-08 20:12:15 -07:00
std::printf(" --info-woc <woc-path> [--json]\n");
std::printf(" Print WOC collision metadata (triangle counts, bounds) and exit\n");
feat(pipeline): add Wowee Open Light (.wol) atmosphere format New open replacement for WoW's Light.dbc / LightParams.dbc / LightIntBand.dbc / LightFloatBand.dbc stack — a single .wol file holds a list of time-of-day keyframes for one zone, each capturing the ambient + directional + fog state at that moment. The renderer interpolates between adjacent keyframes by time-of-day. Binary layout: magic[4] = "WOLA", version (uint32), nameLen + name bytes, keyframeCount + keyframes (each 13 floats + 1 uint32 time) Per keyframe: • timeOfDayMin (0..1439 = minutes since midnight) • ambientColor.rgb, directionalColor.rgb, directionalDir.xyz • fogColor.rgb, fogStart, fogEnd CLI: • --gen-light <wol-base> [zoneName] — emit a starter file with 4-keyframe day/night cycle (midnight/dawn/noon/dusk) using reasonable outdoor defaults • --info-wol <wol-base> [--json] — inspect: zone name + per-keyframe time-of-day + colors + fog distances The 7th open-format addition to the Wowee pipeline: M2 → WOM (model) WMO → WOB (building) WMO collision → WOC ADT → WOT (terrain) DBC → JsonDBC BLP → PNG Light.dbc family → WOL ← new Smoke-tested round-trip: gen → info shows correct 4 keyframes at 00:00 / 06:00 / 12:00 / 18:00 with the canonical color ramps. JSON output for tooling integration.
2026-05-09 13:52:07 -07:00
std::printf(" --info-wol <wol-base> [--json]\n");
std::printf(" Print WOL lighting keyframes (zone name + per-time-of-day ambient/directional/fog) and exit\n");
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
std::printf(" --info-wol-at <wol-base> <HH:MM|minutes>\n");
std::printf(" Sample the WOL's interpolated lighting at a specific time-of-day (linear blend between keyframes)\n");
std::printf(" --validate-wol <wol-base> [--json]\n");
std::printf(" Walk every keyframe; check time bounds + sort order + fogEnd > fogStart + finite color components\n");
feat(pipeline): add Wowee Open Light (.wol) atmosphere format New open replacement for WoW's Light.dbc / LightParams.dbc / LightIntBand.dbc / LightFloatBand.dbc stack — a single .wol file holds a list of time-of-day keyframes for one zone, each capturing the ambient + directional + fog state at that moment. The renderer interpolates between adjacent keyframes by time-of-day. Binary layout: magic[4] = "WOLA", version (uint32), nameLen + name bytes, keyframeCount + keyframes (each 13 floats + 1 uint32 time) Per keyframe: • timeOfDayMin (0..1439 = minutes since midnight) • ambientColor.rgb, directionalColor.rgb, directionalDir.xyz • fogColor.rgb, fogStart, fogEnd CLI: • --gen-light <wol-base> [zoneName] — emit a starter file with 4-keyframe day/night cycle (midnight/dawn/noon/dusk) using reasonable outdoor defaults • --info-wol <wol-base> [--json] — inspect: zone name + per-keyframe time-of-day + colors + fog distances The 7th open-format addition to the Wowee pipeline: M2 → WOM (model) WMO → WOB (building) WMO collision → WOC ADT → WOT (terrain) DBC → JsonDBC BLP → PNG Light.dbc family → WOL ← new Smoke-tested round-trip: gen → info shows correct 4 keyframes at 00:00 / 06:00 / 12:00 / 18:00 with the canonical color ramps. JSON output for tooling integration.
2026-05-09 13:52:07 -07:00
std::printf(" --gen-light <wol-base> [zoneName]\n");
std::printf(" Emit a starter .wol with the canonical 4-keyframe day/night cycle (midnight + dawn + noon + dusk)\n");
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
std::printf(" --gen-light-cave <wol-base> [zoneName]\n");
std::printf(" Emit a single-keyframe .wol with dim cool ambient + heavy short-range fog (cave / mine interior)\n");
std::printf(" --gen-light-dungeon <wol-base> [zoneName]\n");
std::printf(" Emit a single-keyframe .wol with warm torchlit ambient + medium fog (dungeon / crypt interior)\n");
std::printf(" --gen-light-night <wol-base> [zoneName]\n");
std::printf(" Emit a single-keyframe .wol with moonlit directional + far fog (always-night zone / shadow realm)\n");
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
std::printf(" --export-wol-json <wol-base> [out.json]\n");
std::printf(" Export binary .wol to a human-editable JSON sidecar (defaults to <base>.wol.json)\n");
std::printf(" --import-wol-json <json-path> [out-base]\n");
std::printf(" Import a .wol.json sidecar back into binary .wol (round-trip with --export-wol-json)\n");
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
std::printf(" --export-wow-json <wow-base> [out.json]\n");
std::printf(" Export binary .wow to a human-editable JSON sidecar (defaults to <base>.wow.json)\n");
std::printf(" --import-wow-json <json-path> [out-base]\n");
std::printf(" Import a .wow.json sidecar back into binary .wow (accepts type-name string OR typeId int)\n");
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
std::printf(" --info-wow <wow-base> [--json]\n");
std::printf(" Print WOW weather entries (zone + per-state type / intensity / weight / duration) and exit\n");
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
std::printf(" --validate-wow <wow-base> [--json]\n");
std::printf(" Walk every WOW entry; check typeId / intensity bounds [0,1] / weight > 0 / duration min ≤ max\n");
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
std::printf(" --validate-wom <wom-base> [--json]\n");
std::printf(" Static sanity checks on .wom: index range, bone refs, bound box, batch coverage, animation track count\n");
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
std::printf(" --gen-world-map <womx-base> [mapName]\n");
std::printf(" Emit .womx world-tile manifest: 64x64 continent grid with all tiles present (open WDT replacement)\n");
std::printf(" --gen-world-map-instance <womx-base> [mapName]\n");
std::printf(" Emit .womx world-tile manifest: 4x4 instance grid (small-world / dungeon scale)\n");
std::printf(" --gen-world-map-arena <womx-base> [mapName]\n");
std::printf(" Emit .womx world-tile manifest: 1x1 single-tile arena (smallest valid world)\n");
std::printf(" --info-womx <womx-base> [--json]\n");
std::printf(" Print WOMX manifest (worldType / gridSize / tilesPresent / defaultLightId / defaultWeatherId)\n");
std::printf(" --validate-womx <womx-base> [--json]\n");
std::printf(" Static checks on .womx: gridSize 1..128, worldType in range, tileBitmap matches expected size\n");
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
std::printf(" --export-womx-json <womx-base> [out.json]\n");
std::printf(" Export binary .womx to a human-editable JSON sidecar (rows of '1'/'0' strings, easy to hand-edit)\n");
std::printf(" --import-womx-json <json-path> [out-base]\n");
std::printf(" Import a .womx.json sidecar back into binary .womx (round-trip with --export-womx-json)\n");
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
std::printf(" --gen-sound-catalog <wsnd-base> [name]\n");
std::printf(" Emit .wsnd starter catalog (one entry per kind: sfx/music/ambient/ui/voice/spell/combat)\n");
std::printf(" --gen-sound-catalog-ambient <wsnd-base> [name]\n");
std::printf(" Emit .wsnd wilderness catalog: looped birds + wind + 3 footstep variants\n");
std::printf(" --gen-sound-catalog-tavern <wsnd-base> [name]\n");
std::printf(" Emit .wsnd tavern catalog: fire-crackle + crowd murmur + drink-clink + door-creak + lute music\n");
std::printf(" --info-wsnd <wsnd-base> [--json]\n");
std::printf(" Print WSND catalog entries (id / kind / flags / volume / 3D distances / file path / label)\n");
std::printf(" --validate-wsnd <wsnd-base> [--json]\n");
std::printf(" Static checks: kind in 0..6, finite distances, 3D needs max>min>=0, no duplicate sound IDs\n");
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
std::printf(" --export-wsnd-json <wsnd-base> [out.json]\n");
std::printf(" Export binary .wsnd to a human-editable JSON sidecar (defaults to <base>.wsnd.json)\n");
std::printf(" --import-wsnd-json <json-path> [out-base]\n");
std::printf(" Import a .wsnd.json sidecar back into binary .wsnd (accepts either kind int OR kindName string)\n");
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
std::printf(" --gen-spawns <wspn-base> [name]\n");
std::printf(" Emit .wspn starter spawn catalog: 1 creature + 1 game object + 1 doodad near origin\n");
std::printf(" --gen-spawns-camp <wspn-base> [name]\n");
std::printf(" Emit .wspn bandit-camp catalog: 4 creatures around a wander ring + 1 chest + 2 tents\n");
std::printf(" --gen-spawns-village <wspn-base> [name]\n");
std::printf(" Emit .wspn village catalog: 6 friendly NPCs (mixed roles) + 2 signs + 4 corner trees\n");
std::printf(" --info-wspn <wspn-base> [--json]\n");
std::printf(" Print WSPN spawn entries (kind / entryId / position / respawn / wander radius / label)\n");
std::printf(" --validate-wspn <wspn-base> [--json]\n");
std::printf(" Static checks: kind 0..2, finite position/scale/wander, doodads have respawn=0, no orphan entryId=0\n");
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
std::printf(" --export-wspn-json <wspn-base> [out.json]\n");
std::printf(" Export binary .wspn to a human-editable JSON sidecar (defaults to <base>.wspn.json)\n");
std::printf(" --import-wspn-json <json-path> [out-base]\n");
std::printf(" Import a .wspn.json sidecar back into binary .wspn (accepts either kind int OR kindName string)\n");
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
std::printf(" --gen-items <wit-base> [name]\n");
std::printf(" Emit .wit starter item catalog: 1 weapon + 1 chest + 1 potion + 1 quest item\n");
std::printf(" --gen-items-weapons <wit-base> [name]\n");
std::printf(" Emit .wit weapon catalog: 5 entries spanning common -> legendary, both 1H and 2H\n");
std::printf(" --gen-items-armor <wit-base> [name]\n");
std::printf(" Emit .wit full mail-armor set: head + chest + legs + feet + hands + cloak (BoE)\n");
std::printf(" --info-wit <wit-base> [--json]\n");
std::printf(" Print WIT item entries (id / ilvl / quality / class / slot / buy price / name)\n");
std::printf(" --validate-wit <wit-base> [--json]\n");
std::printf(" Static checks: itemId>0 + unique, weapon damage>0 + min<=max, equippable durability>0, sell<buy\n");
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
std::printf(" --export-wit-json <wit-base> [out.json]\n");
std::printf(" Export binary .wit to a human-editable JSON sidecar (defaults to <base>.wit.json)\n");
std::printf(" --import-wit-json <json-path> [out-base]\n");
std::printf(" Import a .wit.json sidecar back into binary .wit (accepts quality/class/slot int OR name string)\n");
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
std::printf(" --gen-loot <wlot-base> [name]\n");
std::printf(" Emit .wlot starter loot catalog: 1 creature with 1 drop slot, 1 item @ 50%%, 0..50 copper\n");
std::printf(" --gen-loot-bandit <wlot-base> [name]\n");
std::printf(" Emit .wlot bandit loot table: dropCount=2, 4 candidate items, 5..50 copper\n");
std::printf(" --gen-loot-boss <wlot-base> [name]\n");
std::printf(" Emit .wlot elite boss table: dropCount=4, 6 candidates incl. quest item + group-only epic, 50..200 silver\n");
std::printf(" --info-wlot <wlot-base> [--json]\n");
std::printf(" Print WLOT loot tables (creatureId / dropCount / money range / per-drop chance + qty + flags)\n");
std::printf(" --validate-wlot <wlot-base> [--json]\n");
std::printf(" Static checks: creatureId>0 + unique, chance in 0..100, minQty<=maxQty, money min<=max\n");
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
std::printf(" --export-wlot-json <wlot-base> [out.json]\n");
std::printf(" Export binary .wlot to a human-editable JSON sidecar (defaults to <base>.wlot.json)\n");
std::printf(" --import-wlot-json <json-path> [out-base]\n");
std::printf(" Import a .wlot.json sidecar back into binary .wlot (accepts flag int OR flagsList strings)\n");
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
std::printf(" --gen-creatures <wcrt-base> [name]\n");
std::printf(" Emit .wcrt starter creature template: 1 friendly innkeeper (vendor + repair flags)\n");
std::printf(" --gen-creatures-bandit <wcrt-base> [name]\n");
std::printf(" Emit .wcrt bandit (creatureId=1000, matches WSPN camp + WLOT bandit table, equips WIT sword)\n");
std::printf(" --gen-creatures-merchants <wcrt-base> [name]\n");
std::printf(" Emit .wcrt 3-NPC village set (innkeeper / smith / alchemist, matches WSPN village creatureIds)\n");
std::printf(" --info-wcrt <wcrt-base> [--json]\n");
std::printf(" Print WCRT entries (id / level / hp / type / faction / npc-flags / name + subname)\n");
std::printf(" --validate-wcrt <wcrt-base> [--json]\n");
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
std::printf(" Static checks: creatureId>0+unique, level/hp>0, min<=max, attackSpeed>0, behavior flag conflicts\n");
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
std::printf(" --export-wcrt-json <wcrt-base> [out.json]\n");
std::printf(" Export binary .wcrt to a human-editable JSON sidecar (defaults to <base>.wcrt.json)\n");
std::printf(" --import-wcrt-json <json-path> [out-base]\n");
std::printf(" Import a .wcrt.json sidecar back into binary .wcrt (accepts type/family/flag int OR name forms)\n");
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
std::printf(" --gen-quests <wqt-base> [name]\n");
std::printf(" Emit .wqt starter quest: 'Kill 10 Defias Bandits' giver=4001 (matches WCRT village innkeeper)\n");
std::printf(" --gen-quests-chain <wqt-base> [name]\n");
std::printf(" Emit .wqt 3-quest chain: Investigate -> Recover -> Report (chained via prev/next questId)\n");
std::printf(" --gen-quests-daily <wqt-base> [name]\n");
std::printf(" Emit .wqt daily repeatable quest with the Daily + Repeatable + AutoAccept flag combo\n");
std::printf(" --info-wqt <wqt-base> [--json]\n");
std::printf(" Print WQT entries (questId / level / giver / objectives / rewards / chain links)\n");
std::printf(" --validate-wqt <wqt-base> [--json]\n");
std::printf(" Static checks: questId>0+unique, level>0+min<=max, title not empty, no rewards warning, daily needs repeatable\n");
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
std::printf(" --export-wqt-json <wqt-base> [out.json]\n");
std::printf(" Export binary .wqt to a human-editable JSON sidecar (defaults to <base>.wqt.json)\n");
std::printf(" --import-wqt-json <json-path> [out-base]\n");
std::printf(" Import a .wqt.json sidecar back into binary .wqt (accepts kind/flag int OR name forms)\n");
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
std::printf(" --gen-objects <wgot-base> [name]\n");
std::printf(" Emit .wgot starter object catalog: 1 chest + 1 mailbox + 1 sign\n");
std::printf(" --gen-objects-dungeon <wgot-base> [name]\n");
std::printf(" Emit .wgot dungeon set: door + button + 2 chests (bandit + boss) + spike trap (cross-refs WLOT)\n");
std::printf(" --gen-objects-gather <wgot-base> [name]\n");
std::printf(" Emit .wgot gathering nodes: Peacebloom (herb) + Tin Vein (ore) + Schools of Fish, with skill reqs\n");
std::printf(" --info-wgot <wgot-base> [--json]\n");
std::printf(" Print WGOT entries (objectId / type / lock / loot / required skill / name)\n");
std::printf(" --validate-wgot <wgot-base> [--json]\n");
std::printf(" Static checks: objectId>0+unique, size>0, time min<=max, gathering needs skill, chest warns on no loot\n");
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
std::printf(" --export-wgot-json <wgot-base> [out.json]\n");
std::printf(" Export binary .wgot to a human-editable JSON sidecar (defaults to <base>.wgot.json)\n");
std::printf(" --import-wgot-json <json-path> [out-base]\n");
std::printf(" Import a .wgot.json sidecar back into binary .wgot (accepts type/flag int OR name forms)\n");
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
std::printf(" --gen-factions <wfac-base> [name]\n");
std::printf(" Emit .wfac starter: 3 factions (Friendly id=35 / Hostile id=14 / Player id=1) matching WCRT defaults\n");
std::printf(" --gen-factions-alliance <wfac-base> [name]\n");
std::printf(" Emit .wfac Alliance set: header + Stormwind + Darnassus + Ironforge (reciprocal friends) + Defias enemy\n");
std::printf(" --gen-factions-wildlife <wfac-base> [name]\n");
std::printf(" Emit .wfac wildlife: wolves + bears + spiders + kobolds (each hostile to player, ignores other beasts)\n");
std::printf(" --info-wfac <wfac-base> [--json]\n");
std::printf(" Print WFAC entries (id / parent / flags / enemy + friend counts / name)\n");
std::printf(" --validate-wfac <wfac-base> [--json]\n");
std::printf(" Static checks: factionId>0+unique, name not empty, threshold ordering, no self-enemy, no enemy/friend overlap\n");
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
std::printf(" --export-wfac-json <wfac-base> [out.json]\n");
std::printf(" Export binary .wfac to a human-editable JSON sidecar (defaults to <base>.wfac.json)\n");
std::printf(" --import-wfac-json <json-path> [out-base]\n");
std::printf(" Import a .wfac.json sidecar back into binary .wfac (accepts flag int OR flagsList strings)\n");
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
std::printf(" --gen-locks <wlck-base> [name]\n");
std::printf(" Emit .wlck starter: 2 locks (Iron Door key+force, Wooden Chest force-only) — lockId=1 matches WGOT\n");
std::printf(" --gen-locks-dungeon <wlck-base> [name]\n");
std::printf(" Emit .wlck dungeon set: light/heavy lockpicks (lockId=2 matches WGOT bandit chest), boss-key seal\n");
std::printf(" --gen-locks-professions <wlck-base> [name]\n");
std::printf(" Emit .wlck profession-keyed locks at lockpick rank 1/100/175/250 (junkbox tier progression)\n");
std::printf(" --info-wlck <wlck-base> [--json]\n");
std::printf(" Print WLCK lock entries with per-channel detail (kind / target / required skill rank)\n");
std::printf(" --validate-wlck <wlck-base> [--json]\n");
std::printf(" Static checks: lockId>0+unique, at least 1 active channel, item/spell/lockpick need targetId\n");
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
std::printf(" --export-wlck-json <wlck-base> [out.json]\n");
std::printf(" Export binary .wlck to a human-editable JSON sidecar (defaults to <base>.wlck.json)\n");
std::printf(" --import-wlck-json <json-path> [out-base]\n");
std::printf(" Import a .wlck.json sidecar back into binary .wlck (accepts kind/flag int OR name forms)\n");
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
std::printf(" --gen-skills <wskl-base> [name]\n");
std::printf(" Emit .wskl starter: Swords + Common + First Aid + Mining (id=186) + Lockpicking (id=633) — matches WGOT/WLCK\n");
std::printf(" --gen-skills-professions <wskl-base> [name]\n");
std::printf(" Emit .wskl 12 classic professions (9 primary + 3 secondary) with canonical SkillLine IDs\n");
std::printf(" --gen-skills-weapons <wskl-base> [name]\n");
std::printf(" Emit .wskl all 16 weapon skills with rankPerLevel=5 auto-grow (use-trained, not trainer-trained)\n");
std::printf(" --info-wskl <wskl-base> [--json]\n");
std::printf(" Print WSKL entries (id / category / max rank / per-level grow / trainer-required / name)\n");
std::printf(" --validate-wskl <wskl-base> [--json]\n");
std::printf(" Static checks: skillId>0+unique, name not empty, maxRank>0, weapon needs rankPerLevel>0\n");
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
std::printf(" --export-wskl-json <wskl-base> [out.json]\n");
std::printf(" Export binary .wskl to a human-editable JSON sidecar (defaults to <base>.wskl.json)\n");
std::printf(" --import-wskl-json <json-path> [out-base]\n");
std::printf(" Import a .wskl.json sidecar back into binary .wskl (accepts category int OR categoryName string)\n");
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
std::printf(" --gen-spells <wspl-base> [name]\n");
std::printf(" Emit .wspl starter spell catalog: 4 spells covering damage / heal / buff / teleport effect kinds\n");
std::printf(" --gen-spells-mage <wspl-base> [name]\n");
std::printf(" Emit .wspl mage spell set: Frostbolt + Fireball + Arcane Intellect + Blink (canonical IDs 116/133/1459/1953)\n");
std::printf(" --gen-spells-warrior <wspl-base> [name]\n");
std::printf(" Emit .wspl warrior spell set: Heroic Strike + Thunder Clap + Battle Shout + Mortal Strike\n");
std::printf(" --info-wspl <wspl-base> [--json]\n");
std::printf(" Print WSPL spell entries (id / school / effect / cast/cd / mana / range / damage range / name)\n");
std::printf(" --validate-wspl <wspl-base> [--json]\n");
std::printf(" Static checks: spellId>0+unique, name not empty, school 0..6, range/value min<=max, friendly+hostile incoherent\n");
feat(editor): add WSPL JSON round-trip authoring workflow Closes the WSPL open-format loop with --export-wspl-json / --import-wspl-json, mirroring the JSON pairs added for every other novel binary format. All 14 binary formats added since WOL now have full JSON round-trip authoring. Each spell round-trips all 18 scalar fields. Four enum-typed fields emit dual int + name forms so a hand-author can use either: • school (physical / holy / fire / nature / frost / shadow / arcane) • targetType (self / single / cone / aoe-self / line / ground) • effectKind (damage / heal / buff / debuff / teleport / summon / dispel) • flags (passive / channeled / ranged / aoe / friendly / hostile / ...) The flags bitset emits string-array form so a hand-author can write ["hostile", "aoe"] instead of having to remember that HostileOnly|AreaOfEffect = 0x110. Verified byte-identical round-trip on the mage preset (4 spells covering frost / fire / arcane schools and damage / buff / teleport effects, full flag and effect-value coverage). Adds 2 flags (544 documented total now).
2026-05-09 16:06:29 -07:00
std::printf(" --export-wspl-json <wspl-base> [out.json]\n");
std::printf(" Export binary .wspl to a human-editable JSON sidecar (defaults to <base>.wspl.json)\n");
std::printf(" --import-wspl-json <json-path> [out-base]\n");
std::printf(" Import a .wspl.json sidecar back into binary .wspl (accepts school/target/effect/flag int OR name forms)\n");
feat(pipeline): add WACH (Wowee Achievement Catalog) format Novel open replacement for Blizzard's Achievement.dbc + AchievementCriteria.dbc + AchievementCategory.dbc + the AzerothCore-style character_achievement / character_achievement_progress SQL tables. The 21st open format added to the editor. Each achievement carries display metadata (name, description, icon, points, faction restriction) plus a list of criteria the player must satisfy. Criteria mirror the WQT objective model (kind + targetId + quantity), so the runtime can reuse the same progress-tracking machinery for both quests and achievements. Cross-references with previously-added formats — every criterion kind has a real format target: WACH.criteria.targetId (kind=KillCreature) -> WCRT.creatureId WACH.criteria.targetId (kind=CompleteQuest) -> WQT.questId WACH.criteria.targetId (kind=LootItem) -> WIT.itemId WACH.criteria.targetId (kind=CastSpell) -> WSPL.spellId WACH.criteria.targetId (kind=ReachSkillLevel) -> WSKL.skillId WACH.criteria.targetId (kind=EarnReputation) -> WFAC.factionId WACH.criteria.targetId (kind=CompleteAchievement) -> WACH.achievementId (meta-achievements) Format: • magic "WACH", version 1, little-endian • per achievement: id / categoryId / name / description / iconPath / titleReward / points / minLevel / faction / flags / criteria[] • per criterion: criteriaId / kind / targetId / quantity / description Enums: • CriteriaKind (9): KillCreature / CompleteQuest / LootItem / ReachLevel / EarnReputation / CastSpell / ReachSkillLevel / VisitArea / CompleteAchievement • Faction: Both / Alliance / Horde • Flags: HiddenUntilEarned / ServerFirst / RealmFirst / Tracking / Counter / Account API: WoweeAchievementLoader::save / load / exists / findById; presets makeStarter (3 simple kill/quest/level demos), makeBandit (3 with WCRT/WGOT/WQT cross-refs), makeMeta (3 base + 1 meta-achievement granting "the Versatile" title, exercising CompleteAchievement criterion kind that lets achievements depend on other achievements). CLI added (5 flags, 542 documented total now): --gen-achievements / --gen-achievements-bandit / --gen-achievements-meta --info-wach / --validate-wach Validator catches: achievementId=0 + duplicates, empty name, faction out of range, no criteria (achievement can never be earned), criterion quantity=0, unknown criterion kind, targetId=0 on criterion kinds that need a real resource reference (everything except ReachLevel which uses the quantity field for the level number). The bandit preset's cross-references close the gameplay graph end-to-end: kill 50 creatureId=1000 (matches WCRT/ WSPN/WLOT bandit), loot objectId=2000 (matches WGOT bandit strongbox), complete questId=1 (matches WQT Bandit Trouble). The meta preset closes a separate loop: 3 sub-achievements covering Mining (skillId=186), Lockpicking (skillId=633), and Frostbolt cast count (spellId=116) — each pointing at a real WSKL/WSPL entry that already exists in the demo content stack.
2026-05-09 16:04:30 -07:00
std::printf(" --gen-achievements <wach-base> [name]\n");
std::printf(" Emit .wach starter: 3 achievements (First Blood / Helping Hand / Coming of Age)\n");
std::printf(" --gen-achievements-bandit <wach-base> [name]\n");
std::printf(" Emit .wach bandit-themed: 3 achievements with cross-refs to WCRT/WGOT/WQT bandit IDs\n");
std::printf(" --gen-achievements-meta <wach-base> [name]\n");
std::printf(" Emit .wach 3 base achievements + 1 meta-achievement (Jack of All Trades, title 'the Versatile')\n");
std::printf(" --info-wach <wach-base> [--json]\n");
std::printf(" Print WACH entries (id / points / faction / flags / criteria with kind+target+qty)\n");
std::printf(" --validate-wach <wach-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, faction 0..2, criteria need targetId+quantity>0\n");
feat(editor): add WACH JSON round-trip authoring workflow Closes the WACH open-format loop with --export-wach-json / --import-wach-json, mirroring the JSON pairs added for every other novel binary format. All 15 binary formats added since WOL now have full JSON round-trip authoring. Each achievement round-trips: • 11 scalar fields (id, categoryId, name, description, icon, titleReward, points, minLevel, faction, flags) • criteria array with full per-criterion fields Three enum-typed fields emit dual int + name forms so a hand-author can use either: • criterion.kind (kill/quest/loot/level/rep/cast/skill/visit/meta) • faction (both/alliance/horde) • flags (hidden/server-first/realm-first/tracking/...) Verified byte-identical round-trip on the meta preset (4 achievements, 6 criteria including the 3 CompleteAchievement criteria that wire the meta-achievement to its prerequisites). Adds 2 flags (546 documented total now).
2026-05-09 16:07:53 -07:00
std::printf(" --export-wach-json <wach-base> [out.json]\n");
std::printf(" Export binary .wach to a human-editable JSON sidecar (defaults to <base>.wach.json)\n");
std::printf(" --import-wach-json <json-path> [out-base]\n");
std::printf(" Import a .wach.json sidecar back into binary .wach (accepts kind/faction/flag int OR name forms)\n");
feat(pipeline): add WTRN (Wowee Trainer / Vendor catalog) format Novel open replacement for AzerothCore-style npc_trainer + npc_vendor SQL tables PLUS the Blizzard TrainerSpells.dbc family. The 22nd open format added to the editor. Unifies trainer spell lists and vendor item inventories into one per-NPC entry. A creature flagged Trainer or Vendor in WCRT references a WTRN entry that lists what they teach / sell. The same NPC can be both — kindMask is a bitmask covering the Trainer (0x01) and Vendor (0x02) kinds. This format closes a major cross-format gap: WCRT.npcFlags already had Vendor / Trainer bits, but until now there was no format defining what a vendor sells or what a trainer teaches. Now an NPC marked Vendor in WCRT has a real inventory, and an NPC marked Trainer has a real spell list. Cross-references — every WTRN field has a real format target: WTRN.entry.npcId -> WCRT.entry.creatureId WTRN.spell.spellId -> WSPL.entry.spellId WTRN.spell.requiredSkillId -> WSKL.entry.skillId WTRN.item.itemId -> WIT.entry.itemId Format: • magic "WTRN", version 1, little-endian • per NPC: npcId / kindMask / greeting + spells[] + items[] • per spell offer: spellId / moneyCostCopper / requiredSkillId / requiredSkillRank / requiredLevel • per item offer: itemId / stockCount (0xFFFFFFFF = unlimited) / restockSec / extendedCost / moneyCostCopper (0 = inherit from WIT.buyPrice) API: WoweeTrainerLoader::save / load / exists / findByNpc; presets makeStarter (innkeeper 4001 as both trainer + vendor: teaches First Aid + sells starter items), makeMageTrainer (NPC 4003 teaches the WSPL mage spells at scaling cost), makeWeaponVendor (NPC 4002 sells WIT weapons with mixed unlimited/finite stock + restock timers). CLI added (5 flags, 551 documented total now): --gen-trainers / --gen-trainers-mage / --gen-trainers-weapons --info-wtrn / --validate-wtrn Validator catches: npcId=0 + duplicates, kindMask=0 (NPC offers nothing), Trainer flag without spells, Vendor flag without items, spells/items present without the matching kind bit (silently ignored at runtime), spellId=0 / itemId=0 in offers, finite stock with restockSec=0 (single-fill — usually intentional but worth surfacing). The 3 presets deliberately use npcIds matching WCRT village merchants (4001/4002/4003) so the demo content stack is self-consistent: WCRT 4001 has the Vendor + Trainer flag, and WTRN 4001 actually defines what they sell and teach.
2026-05-09 16:12:58 -07:00
std::printf(" --gen-trainers <wtrn-base> [name]\n");
std::printf(" Emit .wtrn starter: 1 NPC (innkeeper 4001) acting as both vendor + trainer with WSKL/WIT cross-refs\n");
std::printf(" --gen-trainers-mage <wtrn-base> [name]\n");
std::printf(" Emit .wtrn mage trainer (npcId=4003): teaches Frostbolt/Fireball/Arcane Intellect/Blink at scaling cost\n");
std::printf(" --gen-trainers-weapons <wtrn-base> [name]\n");
std::printf(" Emit .wtrn weapon vendor (npcId=4002): 5 weapons with mixed unlimited/finite stock + restock timers\n");
std::printf(" --info-wtrn <wtrn-base> [--json]\n");
std::printf(" Print WTRN entries (npc / kind / spells with skill+level reqs / items with stock + restock)\n");
std::printf(" --validate-wtrn <wtrn-base> [--json]\n");
std::printf(" Static checks: npcId>0+unique, kindMask>0, Trainer needs spells, Vendor needs items, no orphan offers\n");
feat(editor): add WTRN JSON round-trip authoring workflow Closes the WTRN open-format loop with --export-wtrn-json / --import-wtrn-json, mirroring the JSON pairs added for every other novel binary format. All 16 binary formats added since WOL now have full JSON round-trip authoring. Each NPC round-trips: • npcId, kindMask (dual int + kindList string array), greeting • spells[]: spellId / cost / requiredSkill+rank / minLevel • items[]: itemId / stockCount / restockSec / extendedCost / moneyCostCopper The stockCount field has special handling — the sentinel 0xFFFFFFFF value emits as the string "unlimited" instead of the raw integer, since 4294967295 reads as a magic-number typo in hand-edit JSON. The importer accepts either form. Verified byte-identical round-trip on the starter preset (innkeeper 4001 with 1 spell + 3 items, exercising both unlimited-stock and finite-stock-with-restock cases). Adds 2 flags (553 documented total now).
2026-05-09 16:14:50 -07:00
std::printf(" --export-wtrn-json <wtrn-base> [out.json]\n");
std::printf(" Export binary .wtrn to a human-editable JSON sidecar (defaults to <base>.wtrn.json)\n");
std::printf(" --import-wtrn-json <json-path> [out-base]\n");
std::printf(" Import a .wtrn.json sidecar back into binary .wtrn (accepts kindMask int OR kindList string array)\n");
feat(pipeline): add WGSP (Wowee Gossip Menu) format Novel open replacement for AzerothCore-style gossip_menu + gossip_menu_option + npc_text SQL tables PLUS the Blizzard NpcText.dbc family. The 23rd open format added to the editor. An NPC's dialogue tree: a menu of options the player can pick from when right-clicking the NPC. Each option may bridge to another menu, trigger a vendor / trainer interaction, offer a quest, etc. The simplified per-option model (kind + actionTarget + flags + moneyCost) covers the common cases without needing separate npc_text condition tables. Closes a major cross-format gap: WCRT.entry.gossipId has existed since batch 116 (when WCRT was added) but pointed to a format that didn't exist yet. The innkeeper preset's menuId=4001 deliberately matches WCRT's Bartleby NPC so the demo content stack can wire WCRT.gossipId = 4001 once that field is plumbed through the runtime. Cross-references: WCRT.entry.gossipId -> WGSP.entry.menuId WGSP.option.actionTarget (Submenu) -> WGSP.entry.menuId WGSP.option.actionTarget (Vendor / Trainer) -> WTRN.entry.npcId WGSP.option.actionTarget (Quest) -> WQT.entry.questId Format: • magic "WGSP", version 1, little-endian • per menu: menuId / titleText + options[] • per option: optionId / text / kind / actionTarget / requiredFlags / moneyCostCopper Enums: • OptionKind (13): Close / Submenu / Vendor / Trainer / Quest / Tabard / Banker / Innkeeper / FlightMaster / TextOnly / Script / Battlemaster / Auctioneer • OptionFlags: AllianceOnly / HordeOnly / Coinpouch / QuestGated / Closes API: WoweeGossipLoader::save / load / exists / findById; presets makeStarter (1 menu with vendor + trainer + close), makeInnkeeper (2-menu tree: main menu 4001 with hearth / vendor / flight / submenu options + lore submenu 4002 that links back), makeQuestGiver (1 menu with 2 quest options referencing WQT 1 and 100, plus a paid respec script exercising the Coinpouch flag with a 10g cost). CLI added (5 flags, 558 documented total now): --gen-gossip / --gen-gossip-innkeeper / --gen-gossip-questgiver --info-wgsp / --validate-wgsp Validator catches: menuId=0 + duplicates, empty title / options, unknown option kind, empty option text, Submenu options pointing at non-existent menuIds (intra-format cross-reference resolution), Coinpouch flag without moneyCost (misleading UI), AllianceOnly+HordeOnly conflict.
2026-05-09 16:20:07 -07:00
std::printf(" --gen-gossip <wgsp-base> [name]\n");
std::printf(" Emit .wgsp starter: 1 menu with greeting + 3 options (vendor / trainer / close)\n");
std::printf(" --gen-gossip-innkeeper <wgsp-base> [name]\n");
std::printf(" Emit .wgsp 2-menu innkeeper tree (menuId=4001 closes WCRT.gossipId gap; submenu 4002 area lore)\n");
std::printf(" --gen-gossip-questgiver <wgsp-base> [name]\n");
std::printf(" Emit .wgsp questgiver menu: 2 quest options + bank + paid respec (Coinpouch flag, 10g)\n");
std::printf(" --info-wgsp <wgsp-base> [--json]\n");
std::printf(" Print WGSP entries (menuId / title / per-option kind / target / cost / flags)\n");
std::printf(" --validate-wgsp <wgsp-base> [--json]\n");
std::printf(" Static checks: menuId>0+unique, options non-empty, Submenu actionTarget exists, Coinpouch needs cost, faction conflict\n");
feat(editor): add WGSP JSON round-trip authoring workflow Closes the WGSP open-format loop with --export-wgsp-json / --import-wgsp-json, mirroring the JSON pairs added for every other novel binary format. All 17 binary formats added since WOL now have full JSON round-trip authoring. Each menu round-trips: • menuId, titleText • options[] with optionId / text / kind (dual int + name) / actionTarget / requiredFlags (dual int + flag-string array) / moneyCostCopper The kindName field makes it obvious that a hand-edited "vendor" / "trainer" / "submenu" string maps to the right internal value without needing to know that vendor=2 and submenu=1. Verified byte-identical round-trip on the innkeeper preset (2 menus, 7 options including Submenu cross-references that must stay byte-stable to preserve the inter-menu graph). Adds 2 flags (566 documented total now).
2026-05-09 16:28:12 -07:00
std::printf(" --export-wgsp-json <wgsp-base> [out.json]\n");
std::printf(" Export binary .wgsp to a human-editable JSON sidecar (defaults to <base>.wgsp.json)\n");
std::printf(" --import-wgsp-json <json-path> [out-base]\n");
std::printf(" Import a .wgsp.json sidecar back into binary .wgsp (accepts kind/flag int OR name forms)\n");
feat(pipeline): add WTAX (Wowee Taxi catalog) format Novel open replacement for Blizzard's TaxiNodes.dbc + TaxiPath.dbc + TaxiPathNode.dbc. The 24th open format added to the editor. Defines the flight-master network: a set of named nodes (positions on the world map) plus the paths between them (sequences of waypoints with per-segment delay and a per-path gold cost). The same file holds both node and path lists — flat arrays keyed by id, with intra-format references from path.fromNodeId / toNodeId to node.nodeId. Cross-references: WCRT.entry (with FlightMaster npcFlag) ~= WTAX.nodeId (matched by world position; flight master NPCs stand at their nodes) WTAX.path.fromNodeId / toNodeId -> WTAX.entry.nodeId (intra-format graph) Format: • magic "WTAX", version 1, little-endian • nodes (each): nodeId / mapId / name / iconPath / position / faction restrictions • paths (each): pathId / from+toNodeId / moneyCostCopper / waypoints[] each with position + per-waypoint delaySec API: WoweeTaxiLoader::save / load / exists + WoweeTaxi::findNode / findPath / findPathBetween. Three preset emitters showcase different graph shapes: • makeStarter — 2 nodes + 2 paths (round-trip) • makeRegion — 4 nodes at a 500m square + 4-path directed ring (NW->NE->SE->SW->NW) • makeContinent — 6 nodes hub-spoke + 3 perimeter shortcuts; intermediate waypoints climb to altitude 120m for visual arc effect CLI added (5 flags, 564 documented total now): --gen-taxi / --gen-taxi-region / --gen-taxi-continent --info-wtax / --validate-wtax Validator catches: nodeId/pathId=0 + duplicates, empty node name, non-finite positions, fromNodeId == toNodeId (self-loop path), path references to non-existent nodes (intra-format cross-reference resolution), negative waypoint delays.
2026-05-09 16:26:27 -07:00
std::printf(" --gen-taxi <wtax-base> [name]\n");
std::printf(" Emit .wtax starter: 2 nodes (Stormwind / Goldshire) + 2 paths (round-trip, 50s each, 3 waypoints)\n");
std::printf(" --gen-taxi-region <wtax-base> [name]\n");
std::printf(" Emit .wtax 4-node region: NW/NE/SE/SW outposts on a 500m square + 4-path directed ring\n");
std::printf(" --gen-taxi-continent <wtax-base> [name]\n");
std::printf(" Emit .wtax 6-node hub-spoke continent: central crossroads + 5 outliers + 3 perimeter shortcuts (8 paths)\n");
std::printf(" --info-wtax <wtax-base> [--json]\n");
std::printf(" Print WTAX nodes (id / map / position / name) + paths (id / from->to / cost / waypoint count)\n");
std::printf(" --validate-wtax <wtax-base> [--json]\n");
std::printf(" Static checks: ids>0+unique, finite positions, paths reference real nodes, no self-loop, non-negative delays\n");
feat(editor): add WTAX JSON round-trip authoring workflow Closes the WTAX open-format loop with --export-wtax-json / --import-wtax-json, mirroring the JSON pairs added for every other novel binary format. All 18 binary formats added since WOL now have full JSON round-trip authoring. Two top-level arrays mirror the binary layout: • nodes[] — nodeId / mapId / name / iconPath / position[3] / factionAlliance + factionHorde restrictions • paths[] — pathId / fromNodeId / toNodeId / moneyCostCopper / waypoints[] each with position[3] + delaySec Vec3 fields become 3-element JSON arrays for natural hand-edit. The intra-format graph (paths reference nodeIds) round-trips exactly so the catalog's connectivity is preserved. Verified byte-identical round-trip on the continent preset (6 nodes + 8 paths covering hub-and-spoke + 3 perimeter shortcuts, 16 total waypoints). Adds 2 flags (573 documented total now).
2026-05-09 16:35:01 -07:00
std::printf(" --export-wtax-json <wtax-base> [out.json]\n");
std::printf(" Export binary .wtax to a human-editable JSON sidecar (defaults to <base>.wtax.json)\n");
std::printf(" --import-wtax-json <json-path> [out-base]\n");
std::printf(" Import a .wtax.json sidecar back into binary .wtax (round-trip with --export-wtax-json)\n");
feat(pipeline): add WTAL (Wowee Talent catalog) format Novel open replacement for Blizzard's TalentTab.dbc + Talent.dbc + the AzerothCore-style talent_progression SQL tables. The 25th open format added to the editor. Defines class talent specialization trees: per-class set of named tabs (Arms / Fury / Protection for warrior, Fire / Frost / Arcane for mage), each with talents arranged in a row/column grid, each talent having up to 5 ranks and an optional prerequisite chain. Cross-references with previously-added formats: WTAL.talent.prereqTalentId -> WTAL.talent.talentId (intra-format chain) WTAL.talent.rankSpellIds[] -> WSPL.entry.spellId (spell granted at each rank) Format: • magic "WTAL", version 1, little-endian • per tree: treeId / name / iconPath / requiredClassMask / talents[] (row, col, maxRank, prereqTalentId+rank, rankSpellIds[5] zero-padded for unused ranks) Enums: • ClassMask: bit positions match canonical CharClasses.dbc classIds — Warrior / Paladin / Hunter / Rogue / Priest / DK / Shaman / Mage / Warlock / Druid API: WoweeTalentLoader::save / load / exists + WoweeTalent::findTree / findTalent (global lookup across all trees in the catalog). Three preset emitters showcase tree shapes: • makeStarter — 1 small tree (3-talent vertical chain) • makeWarrior — 3 trees (Arms 4 / Fury 4 / Protection 3) with WSPL cross-refs at capstones (Mortal Strike -> WSPL 12294, Battle Shout -> WSPL 6673, Thunder Clap -> WSPL 6343) • makeMage — 3 trees (Arcane / Fire / Frost) with capstones referencing Frostbolt 116 / Fireball 133 / Blink 1953 from WSPL CLI added (5 flags, 571 documented total now): --gen-talents / --gen-talents-warrior / --gen-talents-mage --info-wtal / --validate-wtal Validator catches: tree+talent ids=0 or duplicates, empty tree name, requiredClassMask=0 (every class would see this tree — usually a typo), maxRank not in 1..5, talent listing itself as prerequisite, prereqTalentId pointing at a talent that doesn't exist in this catalog (intra-format cross-reference resolution), prereqRank=0 or > the prereq talent's maxRank (catches off-by-one references), gaps in rankSpellIds progression (rank N has spell but rank N-1 doesn't — usually a typo). The validator caught a real authoring bug in the makeMage / makeWarrior presets during smoke testing — initial check was comparing prereqRank against the WRONG talent's maxRank (this talent's rather than the prereq's). Fixed in the same commit by hoisting the check into the cross-reference resolution pass where the prereq talent is in hand.
2026-05-09 16:33:45 -07:00
std::printf(" --gen-talents <wtal-base> [name]\n");
std::printf(" Emit .wtal starter: 1 small tree (3 talents in chain) for class warrior\n");
std::printf(" --gen-talents-warrior <wtal-base> [name]\n");
std::printf(" Emit .wtal warrior trees: Arms (4 talents) + Fury (4) + Protection (3) with WSPL spell cross-refs\n");
std::printf(" --gen-talents-mage <wtal-base> [name]\n");
std::printf(" Emit .wtal mage trees: Arcane (3 talents) + Fire (3) + Frost (3) with WSPL Frostbolt/Fireball/Blink refs\n");
std::printf(" --info-wtal <wtal-base> [--json]\n");
std::printf(" Print WTAL trees + per-talent grid position / max rank / prereq chain / rank-1 spellId\n");
std::printf(" --validate-wtal <wtal-base> [--json]\n");
std::printf(" Static checks: tree+talent ids>0+unique, maxRank 1..5, prereq references resolve, no self-prereq\n");
feat(editor): add WTAL JSON round-trip authoring workflow Closes the WTAL open-format loop with --export-wtal-json / --import-wtal-json, mirroring the JSON pairs added for every other novel binary format. All 19 binary formats added since WOL now have full JSON round-trip authoring. Each tree round-trips: • treeId, name, iconPath, requiredClassMask • talents[] with talentId / row / col / maxRank / prereqTalentId+Rank / rankSpellIds[5] (always emitted as a 5-element array, zero-padded for unused ranks) The fixed-size rankSpellIds array round-trips exactly even when most slots are zero — preserves binary layout parity for downstream consumers expecting fixed-stride talent records. Verified byte-identical round-trip on the warrior preset (3 trees, 11 talents with prereq chains and capstone WSPL spell references intact). Adds 2 flags (580 documented total now).
2026-05-09 16:41:37 -07:00
std::printf(" --export-wtal-json <wtal-base> [out.json]\n");
std::printf(" Export binary .wtal to a human-editable JSON sidecar (defaults to <base>.wtal.json)\n");
std::printf(" --import-wtal-json <json-path> [out-base]\n");
std::printf(" Import a .wtal.json sidecar back into binary .wtal (round-trip with --export-wtal-json)\n");
feat(pipeline): add WMS (Wowee Map / Area) catalog format Novel open replacement for Blizzard's Map.dbc + AreaTable.dbc + the AzerothCore-style world_zone SQL tables. The 26th open format added to the editor. Defines two related kinds of locator in one catalog: • Maps — top-level worlds (continents / instances / raids / battlegrounds / arenas) with a friendly name, type, expansion tag, and player-count cap. • Areas — sub-zones within maps with friendly names, parent- area chain, recommended level range, faction- territory marker (alliance / horde / contested / both), exploration XP, and an ambient-sound cross-reference into WSND. The runtime uses Areas for minimap labels, location strings under the player frame, "Discover Sub-zone" XP gains, and ambient-music selection on zone entry. Cross-references with previously-added formats: WMS.area.ambienceSoundId -> WSND.entry.soundId WMS.area.parentAreaId -> WMS.area.areaId (intra-format sub-zone hierarchy) WSPN entries are tied to WMS.area boundaries by world position (no direct ID — the runtime resolves position -> area at lookup time) Format: • magic "WMSX", version 1, little-endian • maps[] (each): mapId / name / shortName / mapType / expansionId / maxPlayers • areas[] (each): areaId / mapId / parentAreaId / name / minLevel..maxLevel / factionGroup / explorationXP / ambienceSoundId Enums: • MapType (5): Continent / Instance / Raid / Battleground / Arena • ExpansionId (5): Classic / Tbc / Wotlk / Cata / Mop • FactionGroup: Both / Alliance / Horde / Contested (PvP-flagging zone) API: WoweeMapsLoader::save / load / exists + WoweeMaps::findMap / findArea. Three preset emitters showcase the catalog shape: • makeStarter — 1 continent + 3 areas with parent chain (Goldshire is a sub-zone of Elwynn Forest) • makeClassic — 2 continents + Deadmines instance + 6 areas (Stormwind/Elwynn/Goldshire/Westfall/ Duskwood/Teldrassil/Deadmines) with WSND ambient-sound refs • makeBgArena — Alterac Valley (40-player BG) + Nagrand Arena (5v5 with maxPlayers=10) CLI added (5 flags, 578 documented total now): --gen-maps / --gen-maps-classic / --gen-maps-bgarena --info-wms / --validate-wms Validator catches: empty map name, unknown mapType / expansion, BG/Arena with maxPlayers=0 (no participant cap), area ids=0 + duplicates, empty area name, maxLevel < minLevel, areas referencing non-existent maps, parentAreaId chains crossing maps (sub-zones must be on the same world), self-parent.
2026-05-09 16:40:00 -07:00
std::printf(" --gen-maps <wms-base> [name]\n");
std::printf(" Emit .wms starter: 1 map (Eastern Kingdoms) + 3 areas (Stormwind / Elwynn / Goldshire) with parent chain\n");
std::printf(" --gen-maps-classic <wms-base> [name]\n");
std::printf(" Emit .wms classic set: 2 continents + Deadmines instance + 6 areas with sub-zone parent chains + WSND refs\n");
std::printf(" --gen-maps-bgarena <wms-base> [name]\n");
std::printf(" Emit .wms PvP maps: Alterac Valley (40-player BG) + Nagrand Arena (5v5)\n");
std::printf(" --info-wms <wms-base> [--json]\n");
std::printf(" Print WMS maps (id / type / expansion / max players) + areas (id / map / parent / level / faction / xp)\n");
std::printf(" --validate-wms <wms-base> [--json]\n");
std::printf(" Static checks: ids unique, areas reference real maps, parent areas exist + same map, BG/Arena needs maxPlayers\n");
feat(editor): add WMS JSON round-trip authoring workflow Closes the WMS open-format loop with --export-wms-json / --import-wms-json, mirroring the JSON pairs added for every other novel binary format. All 20 binary formats added since WOL now have full JSON round-trip authoring. Two top-level arrays mirror the binary layout: • maps[] — mapId / name / shortName / mapType (dual int + name) / expansionId (dual int + name) / maxPlayers • areas[] — areaId / mapId / parentAreaId / name / minLevel..maxLevel / factionGroup (dual int + name) / explorationXP / ambienceSoundId Three enum-typed fields (mapType, expansionId, factionGroup) emit dual int + name forms — a hand-author can write "continent" / "wotlk" / "alliance" instead of remembering the integer values. Verified byte-identical round-trip on the classic preset (3 maps including Deadmines instance, 6 areas with full parent-chain hierarchy + WSND ambient cross-refs preserved). Adds 2 flags (587 documented total now).
2026-05-09 16:48:34 -07:00
std::printf(" --export-wms-json <wms-base> [out.json]\n");
std::printf(" Export binary .wms to a human-editable JSON sidecar (defaults to <base>.wms.json)\n");
std::printf(" --import-wms-json <json-path> [out-base]\n");
std::printf(" Import a .wms.json sidecar back into binary .wms (accepts mapType/expansion/faction int OR name forms)\n");
feat(pipeline): add WCHC (Wowee Character Classes/Races) format Novel open replacement for Blizzard's CharClasses.dbc + CharRaces.dbc + CharStartOutfit.dbc trio. The 27th open format added to the editor — completes the foundational character-creation surface. One file holds three flat arrays: • classes — playable classes (Warrior / Mage / etc.) with power type (mana/rage/focus/energy/runic), base HP+power scaling, faction availability • races — playable races with faction (Alliance/Horde/ Neutral), starting map+zone, default language spell, base stats, racial mount spell • outfits — starting gear loadout per (class, race, gender) triple, listing item IDs and display slots Cross-references with previously-added formats: WCHC.race.startingMapId -> WMS.map.mapId WCHC.race.startingZoneAreaId -> WMS.area.areaId WCHC.race.defaultLanguageSpellId -> WSPL.entry.spellId WCHC.race.mountSpellId -> WSPL.entry.spellId WCHC.outfit.items.itemId -> WIT.entry.itemId The starter preset's outfits use real WIT itemIds (1=Worn Shortsword, 2=Linen Vest, 3=Healing Potion) so the demo content stack is consistent: a freshly created Human Warrior in WCHC starts with WIT items 1/2/3, drops them on death into a WLOT-tracked corpse loot, and can be respawned via WSPN, etc. Format: • magic "WCHC", version 1, little-endian • classes[]: classId / name / icon / powerType / display / baseHP+perLevel / basePower+perLevel / factionAvailability • races[]: raceId / name / icon / factionId / male+female displayId / 5 base stats / startingMap+zone / defaultLanguage+mount spell IDs • outfits[]: classId+raceId+gender + items[] (each: itemId + displaySlot) Enums: • PowerType (6): Mana / Rage / Focus / Energy / RunicPower / Runes • RaceFaction (3): Alliance / Horde / Neutral • Gender: Male / Female • FactionAvailability bitmask: AvailableAlliance, AvailableHorde API: WoweeCharsLoader::save / load / exists + WoweeChars::findClass / findRace / findOutfit (by class+race+gender). CLI added (5 flags, 585 documented total now): --gen-chars / --gen-chars-alliance / --gen-chars-allraces --info-wchc / --validate-wchc Validator catches: ids unique, baseHealth=0 (instant-death character), factionAvailability=0 (no faction can pick), empty names, factionId out of range, outfit references to non-existent class/race ids (cross-format resolution), gender > 1, outfit items with itemId=0, outfit with no items (warning — naked character).
2026-05-09 16:47:04 -07:00
std::printf(" --gen-chars <wchc-base> [name]\n");
std::printf(" Emit .wchc starter: 2 classes (Warrior + Mage) + 2 races (Human + Orc) + 4 outfits with WIT cross-refs\n");
std::printf(" --gen-chars-alliance <wchc-base> [name]\n");
std::printf(" Emit .wchc Alliance set: 4 classes (Warrior/Paladin/Rogue/Mage) + 4 races (Human/Dwarf/NightElf/Gnome)\n");
std::printf(" --gen-chars-allraces <wchc-base> [name]\n");
std::printf(" Emit .wchc all 8 classic races (4 Alliance + 4 Horde) + 9 classes (no DK)\n");
std::printf(" --info-wchc <wchc-base> [--json]\n");
std::printf(" Print WCHC classes (id / power / hp scaling) + races (faction / starting zone) + outfit item lists\n");
std::printf(" --validate-wchc <wchc-base> [--json]\n");
std::printf(" Static checks: class+race ids unique, baseHealth>0, faction availability set, outfit refs resolve\n");
feat(editor): add WCHC JSON round-trip authoring workflow Closes the WCHC open-format loop with --export-wchc-json / --import-wchc-json, mirroring the JSON pairs added for every other novel binary format. All 21 binary formats added since WOL now have full JSON round-trip authoring. Three top-level arrays mirror the binary layout: • classes[] — id / name / icon / powerType (dual int + name) / displayPower / baseHP+power scaling / factionAvailability bitmask • races[] — id / name / icon / factionId (dual int + name) / male+female displayId / 5 base stats / starting map+zone / language+mount spell IDs • outfits[] — classId+raceId+gender (dual int + name) + items array (each: itemId + displaySlot) Verified byte-identical round-trip on the starter preset (2 classes / 2 races / 4 outfits with full WIT itemId cross-references preserved through the JSON layer). Adds 2 flags (594 documented total now).
2026-05-09 16:55:31 -07:00
std::printf(" --export-wchc-json <wchc-base> [out.json]\n");
std::printf(" Export binary .wchc to a human-editable JSON sidecar (defaults to <base>.wchc.json)\n");
std::printf(" --import-wchc-json <json-path> [out-base]\n");
std::printf(" Import a .wchc.json sidecar back into binary .wchc (accepts power/faction/gender int OR name forms)\n");
feat(pipeline): add WTKN (Wowee Token catalog) format Novel open replacement for Blizzard's Currency.dbc + CurrencyCategory.dbc + CurrencyTypes.dbc + the AzerothCore- style player_currency SQL tables. The 28th open format added to the editor. Defines secondary currency tokens beyond gold: Honor Points (PvP), Arena Points (rated PvP), Marks of Honor (per battleground), faction reputation tokens, holiday-event currencies. Each token has a balance cap, optional weekly cap (regenerating earnings limit), and a category for grouping in the player's currency tab. Cross-references: WTRN.item.extendedCost -> WTKN.entry.tokenId (vendors can charge in tokens instead of copper — when extendedCost > 0 the runtime looks up the matching token) Format: • magic "WTKN", version 1, little-endian • per token: tokenId / name / description / iconPath / category / maxBalance / weeklyCap / flags Enums: • Category (6): Misc / Pvp / Reputation / Crafting / Seasonal / Holiday • Flags: AccountWide / Tradeable / HiddenUntilEarned / ResetsOnLogout / ConvertsToGold API: WoweeTokenLoader::save / load / exists / findById. Three preset emitters showcase typical token shapes: • makeStarter — 3 tokens (Honor / Marks / Stormwind Guard rep) covering Pvp + Reputation categories • makePvp — full PvP set: Honor (75k) + Arena (5k + weekly 1500) + 6 BG marks of honor for classic + TBC + WotLK battlegrounds • makeSeasonal — 4 holiday tokens (Tricky Treats / Brewfest / Coin of Ancestry / Stranger's Gift) all flagged ResetsOnLogout to make them event-bound CLI added (5 flags, 592 documented total now): --gen-tokens / --gen-tokens-pvp / --gen-tokens-seasonal --info-wtkn / --validate-wtkn Validator catches: tokenId=0 + duplicates, empty name, unknown category, weeklyCap > maxBalance (cap unreachable), ResetsOnLogout + AccountWide combo (incoherent — account state survives logout by definition).
2026-05-09 16:53:11 -07:00
std::printf(" --gen-tokens <wtkn-base> [name]\n");
std::printf(" Emit .wtkn starter: 3 tokens (Honor / Marks / Stormwind Guard) covering Pvp + Reputation categories\n");
std::printf(" --gen-tokens-pvp <wtkn-base> [name]\n");
std::printf(" Emit .wtkn full PvP set: Honor (75k cap) + Arena (5k cap, weekly 1500) + 6 BG marks of honor\n");
std::printf(" --gen-tokens-seasonal <wtkn-base> [name]\n");
std::printf(" Emit .wtkn 4 holiday tokens (Tricky Treats / Brewfest / Coin of Ancestry / Stranger's Gift) — ResetsOnLogout\n");
std::printf(" --info-wtkn <wtkn-base> [--json]\n");
std::printf(" Print WTKN entries (id / category / max balance / weekly cap / flags / name)\n");
std::printf(" --validate-wtkn <wtkn-base> [--json]\n");
std::printf(" Static checks: tokenId>0+unique, name not empty, weeklyCap<=maxBalance, no Resets+AccountWide conflict\n");
feat(editor): add WTKN JSON round-trip authoring workflow Closes the WTKN open-format loop with --export-wtkn-json / --import-wtkn-json, mirroring the JSON pairs added for every other novel binary format. All 22 binary formats added since WOL now have full JSON round-trip authoring. Each token round-trips all 8 scalar fields (tokenId, name, description, iconPath, category, maxBalance, weeklyCap, flags). Two enum-typed fields (category and flags) emit dual int + name forms. The flag bitset emits string-array form so a hand-author can write ["hidden", "resets"] instead of having to remember that HiddenUntilEarned|ResetsOnLogout = 0xC. Verified byte-identical round-trip on the PvP preset (8 tokens: Honor + Arena + 6 BG marks of honor with maxBalance + weeklyCap + flags all preserved). Adds 2 flags (596 documented total now).
2026-05-09 16:56:55 -07:00
std::printf(" --export-wtkn-json <wtkn-base> [out.json]\n");
std::printf(" Export binary .wtkn to a human-editable JSON sidecar (defaults to <base>.wtkn.json)\n");
std::printf(" --import-wtkn-json <json-path> [out-base]\n");
std::printf(" Import a .wtkn.json sidecar back into binary .wtkn (accepts category/flag int OR name forms)\n");
feat(pipeline): add WTRG (Wowee Area Trigger) format Novel open replacement for Blizzard's AreaTrigger.dbc + AreaTriggerTeleport.dbc + the AzerothCore-style areatrigger_template / areatrigger_teleport SQL tables. The 29th open format added to the editor. Defines proximity-based event zones — when a player enters a defined region (box or sphere), the runtime fires the trigger's action: teleport to another map, award exploration XP for a quest, run a server script, gate an instance entrance behind a key item, mark a PvP boundary, or simply display a "Discovered: {area name}" banner. Cross-references with previously-added formats — every trigger field has a real format target: WTRG.entry.mapId / areaId -> WMS.map.mapId / WMS.area.areaId WTRG.actionTarget (Teleport) -> WMS.mapId WTRG.actionTarget (QuestExploration) -> WQT.questId WTRG.requiredQuestId -> WQT.entry.questId WTRG.requiredItemId -> WIT.entry.itemId (key) Format: • magic "WTRG", version 1, little-endian • per trigger: triggerId / mapId / areaId / name / center vec3 / shape / kind / boxDims vec3 / radius / actionTarget / dest vec3 / destOrientation / requiredQuestId / requiredItemId / minLevel Enums: • Shape (2): Box / Sphere • Kind (7): Teleport / QuestExploration / Script / InstanceEntrance / AreaName / CombatStartZone / Waypoint API: WoweeTriggerLoader::save / load / exists / findById. Three preset emitters showcase common trigger shapes: • makeStarter — area-name + quest-exploration with cross-ref to WQT 100 ("Investigate the Camp") • makeDungeon — outdoor area-name + portal-style InstanceEntrance with Deadmines key gate (WIT itemId 5200, matches WLCK.makeDungeon's Boss Vault Seal) + interior exit teleport back outdoors • makeFlightPath — 2 sphere waypoints near flight masters so the runtime can auto-open the flight UI on proximity (matches WTAX starter node positions) CLI added (5 flags, 601 documented total now): --gen-triggers / --gen-triggers-dungeon / --gen-triggers-flightpath --info-wtrg / --validate-wtrg Validator catches: triggerId=0 + duplicates, unknown shape / kind, non-finite center, sphere with radius<=0, box with all-zero half-extents, teleport / instance with dest=(0,0,0) (silently does nothing — usually a typo), QuestExploration without an actionTarget questId.
2026-05-09 17:01:43 -07:00
std::printf(" --gen-triggers <wtrg-base> [name]\n");
std::printf(" Emit .wtrg starter: 2 triggers (Goldshire area-name + bandit-camp quest exploration ref WQT 100)\n");
std::printf(" --gen-triggers-dungeon <wtrg-base> [name]\n");
std::printf(" Emit .wtrg dungeon set: outdoor area-name + Deadmines portal (key-gated) + interior exit teleport\n");
std::printf(" --gen-triggers-flightpath <wtrg-base> [name]\n");
std::printf(" Emit .wtrg flight-master proximity waypoints (Stormwind / Goldshire) for auto-open flight UI\n");
std::printf(" --info-wtrg <wtrg-base> [--json]\n");
std::printf(" Print WTRG triggers (id / map / area / kind / shape + dims / dest + facing / quest+key gates)\n");
std::printf(" --validate-wtrg <wtrg-base> [--json]\n");
std::printf(" Static checks: id>0+unique, finite center, sphere needs radius>0, box needs >=1 nonzero half-extent, quest-explore needs target\n");
feat(editor): add WTRG JSON round-trip authoring workflow Closes the WTRG open-format loop with --export-wtrg-json / --import-wtrg-json, mirroring the JSON pairs added for every other novel binary format. All 23 binary formats added since WOL now have full JSON round-trip authoring. Each trigger round-trips: • triggerId / mapId / areaId / name / minLevel • center / boxDims / dest as 3-element JSON arrays • shape (dual int + name) / kind (dual int + name) • radius / actionTarget / destOrientation • requiredQuestId / requiredItemId Verified byte-identical round-trip on the dungeon preset (3 triggers including the box-shaped Deadmines portal with WIT key gate (itemId=5200) and full destination + facing preserved through the JSON layer). Adds 2 flags (603 documented total now).
2026-05-09 17:03:27 -07:00
std::printf(" --export-wtrg-json <wtrg-base> [out.json]\n");
std::printf(" Export binary .wtrg to a human-editable JSON sidecar (defaults to <base>.wtrg.json)\n");
std::printf(" --import-wtrg-json <json-path> [out-base]\n");
std::printf(" Import a .wtrg.json sidecar back into binary .wtrg (accepts shape/kind int OR name forms)\n");
feat(pipeline): add WTIT (Wowee Title catalog) format Novel open replacement for Blizzard's CharTitles.dbc + the AzerothCore-style character_title SQL table. The 30th open format added to the editor. Defines the player-display titles awarded for completing achievements ("the Versatile"), reaching PvP ranks ("Sergeant Major" / "Stone Guard"), participating in raids ("Champion of the Naaru"), levelling a profession ("Master Locksmith"), or seasonal events ("Brewmaster", "the Hallowed"). Closes a long-standing gap: WACH.entry.titleReward has been a free-form string since batch 116 with no formal catalog to resolve against. WTIT systematizes those strings into a real catalog — the runtime resolves WACH.titleReward to a WTIT entry by name, then displays the titleId in the player title selector. Cross-references: WACH.entry.titleReward (string) ~= WTIT.entry.name (string match — runtime resolves achievement- granted titles by looking up matching WTIT entry by name) Format: • magic "WTIT", version 1, little-endian • per title: titleId / name / nameMale / nameFemale / iconPath / prefix (suffix vs prefix display) / category / sortOrder Enums: • Category (8): Achievement / Pvp / Raid / ClassTitle / Event / Profession / Lore / Custom API: WoweeTitleLoader::save / load / exists + WoweeTitle::findById / findByName. Three preset emitters showcase typical title catalogs: • makeStarter — 4 titles (Versatile / Sergeant / Champion / Hallowed) covering 4 categories • makePvp — 28-title classic Honor System ladder (14 Alliance ranks Private->Grand Marshal + 14 Horde ranks Scout->High Warlord) • makeAchievement — 8 achievement titles including "the Versatile" matching WACH.makeMeta's achievement 250 titleReward + capstone profession titles CLI added (5 flags, 608 documented total now): --gen-titles / --gen-titles-pvp / --gen-titles-achievement --info-wtit / --validate-wtit Validator catches: titleId=0 + duplicates, empty name, unknown category, gender variants set on only one side (causes mixed-gender display when the runtime falls back to canonical for the unset side).
2026-05-09 17:07:56 -07:00
std::printf(" --gen-titles <wtit-base> [name]\n");
std::printf(" Emit .wtit starter: 4 titles covering Achievement / Pvp / Raid / Event categories\n");
std::printf(" --gen-titles-pvp <wtit-base> [name]\n");
std::printf(" Emit .wtit Honor System ladder: 14 Alliance + 14 Horde rank titles (Private..Grand Marshal / Scout..High Warlord)\n");
std::printf(" --gen-titles-achievement <wtit-base> [name]\n");
std::printf(" Emit .wtit achievement titles incl. 'the Versatile' (matches WACH meta-achievement 250 titleReward)\n");
std::printf(" --info-wtit <wtit-base> [--json]\n");
std::printf(" Print WTIT entries (id / sort / prefix vs suffix / category / canonical name)\n");
std::printf(" --validate-wtit <wtit-base> [--json]\n");
std::printf(" Static checks: titleId>0+unique, name not empty, category in 0..7, gender variants paired\n");
feat(editor): add WTIT JSON round-trip authoring workflow Closes the WTIT open-format loop with --export-wtit-json / --import-wtit-json, mirroring the JSON pairs added for every other novel binary format. All 24 binary formats added since WOL now have full JSON round-trip authoring. Each title round-trips all 8 scalar fields (titleId, name, nameMale, nameFemale, iconPath, prefix, category, sortOrder). Two enum-typed fields emit dual int + name forms: • category (achievement/pvp/raid/class/event/profession/...) • prefix (1=prefix vs 0=suffix display position) Verified byte-identical round-trip on the PvP preset (28-title Honor System ladder with full Alliance + Horde rank coverage preserved through the JSON layer). Adds 2 flags (616 documented total now).
2026-05-09 17:16:41 -07:00
std::printf(" --export-wtit-json <wtit-base> [out.json]\n");
std::printf(" Export binary .wtit to a human-editable JSON sidecar (defaults to <base>.wtit.json)\n");
std::printf(" --import-wtit-json <json-path> [out-base]\n");
std::printf(" Import a .wtit.json sidecar back into binary .wtit (accepts category/prefix int OR name forms)\n");
feat(pipeline): add WSEA (Wowee Seasonal Event) format Novel open replacement for Blizzard's GameEvents.dbc + the AzerothCore-style game_event / game_event_creature / game_event_gameobject SQL tables. The 31st open format added to the editor. Calendar-based content: holidays (Hallow's End, Winter's Veil), recurring promotional events (Children's Week, Lunar Festival, Brewfest), one-time anniversaries, and XP-bonus weekends. Each event has a start date, duration, optional recurrence (yearly / monthly / weekly), faction restriction, optional XP bonus, and a reward currency cross-reference into WTKN. Cross-references with previously-added formats: WSEA.entry.tokenIdReward -> WTKN.entry.tokenId (the seasonal currency the event hands out — Tricky Treats during Hallow's End, Brewfest Tokens during Brewfest, etc.) The yearly preset's tokenIdReward values (200/201/202/203) deliberately match WTKN.makeSeasonal's seasonal token ids so the demo content stack already wires together: WSEA yearly events grant WTKN tokens that vendors can charge in via WTRN.item.extendedCost. Format: • magic "WSEA", version 1, little-endian • per event: eventId / name / description / iconPath / announceMessage / startDate (Unix epoch seconds) / duration_seconds / recurrenceDays (0=one-shot, 365=yearly) / holidayKind / factionGroup / bonusXpPercent / tokenIdReward Enums: • HolidayKind (7): Combat / Collection / Racial / Anniversary / Fishing / Cosmetic / WorldEvent • FactionGroup (3): Both / Alliance / Horde API: WoweeEventLoader::save / load / exists / findById. Three preset emitters showcase typical event shapes: • makeStarter — 3 events covering Combat / Fishing / Anniversary kinds • makeYearly — 4 yearly holidays with full WTKN cross-refs (Hallow's End / Brewfest / Lunar Festival / Winter's Veil) • makeBonusWeekends — 3 monthly Fri-Sun bonus tiers (50% / 100% / 200% RAF-style) CLI added (5 flags, 614 documented total now): --gen-events / --gen-events-yearly / --gen-events-weekends --info-wsea / --validate-wsea Validator catches: eventId=0 + duplicates, empty name, unknown holidayKind / factionGroup, duration_seconds=0 (event never runs), duration > recurrence period (events would overlap themselves on next iteration), bonusXpPercent > 200 (very high — verify intentional).
2026-05-09 17:14:46 -07:00
std::printf(" --gen-events <wsea-base> [name]\n");
std::printf(" Emit .wsea starter: 3 events (Brawl Week / Fishing Extravaganza / Anniversary) covering kind categories\n");
std::printf(" --gen-events-yearly <wsea-base> [name]\n");
std::printf(" Emit .wsea 4 yearly holidays (Hallow's End / Brewfest / Lunar Festival / Winter's Veil) with WTKN reward refs\n");
std::printf(" --gen-events-weekends <wsea-base> [name]\n");
std::printf(" Emit .wsea 3 monthly XP-bonus weekends (50%% / 100%% / 200%% RAF tiers)\n");
std::printf(" --info-wsea <wsea-base> [--json]\n");
std::printf(" Print WSEA entries (id / kind / duration / recurrence / xp bonus / token reward / name)\n");
std::printf(" --validate-wsea <wsea-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, kind in 0..6, duration>0, no overlapping recurrence\n");
feat(editor): add WSEA JSON round-trip authoring workflow Closes the WSEA open-format loop with --export-wsea-json / --import-wsea-json, mirroring the JSON pairs added for every other novel binary format. All 25 binary formats added since WOL now have full JSON round-trip authoring. Each event round-trips all 11 scalar fields. Two enum-typed fields emit dual int + name forms: • holidayKind (combat / collection / racial / anniversary / fishing / cosmetic / world-event) • factionGroup (both / alliance / horde) Verified byte-identical round-trip on the yearly preset (4 holidays — Hallow's End / Brewfest / Lunar Festival / Winter's Veil — with full WTKN tokenIdReward cross-refs preserved through the JSON layer). Adds 2 flags (623 documented total now).
2026-05-09 17:24:50 -07:00
std::printf(" --export-wsea-json <wsea-base> [out.json]\n");
std::printf(" Export binary .wsea to a human-editable JSON sidecar (defaults to <base>.wsea.json)\n");
std::printf(" --import-wsea-json <json-path> [out-base]\n");
std::printf(" Import a .wsea.json sidecar back into binary .wsea (accepts kind/faction int OR name forms)\n");
feat(pipeline): add WMOU (Wowee Mount catalog) format Novel open replacement for Blizzard's Mount.dbc + MountCapability.dbc + MountType.dbc + the mount-related subsets of Spell.dbc / Item.dbc. The 32nd open format added to the editor. Defines all summonable steeds: ground mounts, flying mounts, swimming mounts, racial mounts (Tauren Plainsrunner for druids), and class mounts (Warlock dreadsteed, Paladin charger). Each mount has a summon spell, optional teach item, riding skill prerequisite, speed bonus, and faction / race availability mask. Cross-references with previously-added formats: WMOU.entry.summonSpellId -> WSPL.entry.spellId WMOU.entry.itemIdToLearn -> WIT.entry.itemId WMOU.entry.requiredSkillId -> WSKL.entry.skillId (Riding skill ID 762) WCHC.race.mountSpellId ~= WMOU.entry.summonSpellId (loose match by spellId) Format: • magic "WMOU", version 1, little-endian • per mount: mountId / name / description / icon / displayId / summonSpellId / itemIdToLearn / requiredSkillId+Rank / speedPercent / mountKind / factionId / categoryId / raceMask Enums: • Kind (5): Ground / Flying / Swimming / Hybrid / Aquatic • Faction (3): Both / Alliance / Horde • Category (8): Common / Epic / Racial / Event / Achievement / Pvp / Quest / ClassMount API: WoweeMountLoader::save / load / exists / findById. Three preset emitters showcase typical mount catalogs: • makeStarter — 3 mounts (ground horse + epic flying gryphon + aquatic riding turtle) • makeRacial — 6 racial mounts (4 Alliance: Pinto / Ram / Frostsaber / Mechanostrider; 2 Horde: Dire Wolf / Skeletal Horse) with raceMask gating per WCHC race bit positions • makeFlying — 4 flying mounts spanning Common (60%) -> Epic (100%) -> Achievement (280%) -> Pvp (310%) speed tiers CLI added (5 flags, 621 documented total now): --gen-mounts / --gen-mounts-racial / --gen-mounts-flying --info-wmou / --validate-wmou Validator catches: mountId=0 + duplicates, empty name, summonSpellId=0 (mount cannot be cast), unknown enum values, speedPercent=0 (no speed bonus), flying mount with requiredSkillRank<150 (player can't fly), Racial category without raceMask (any race could use — usually a typo).
2026-05-09 17:23:00 -07:00
std::printf(" --gen-mounts <wmou-base> [name]\n");
std::printf(" Emit .wmou starter: 3 mounts (Brown Horse / Swift Gryphon / Riding Turtle) covering ground/flying/aquatic\n");
std::printf(" --gen-mounts-racial <wmou-base> [name]\n");
std::printf(" Emit .wmou 6 racial mounts (4 Alliance + 2 Horde) with raceMask gating\n");
std::printf(" --gen-mounts-flying <wmou-base> [name]\n");
std::printf(" Emit .wmou 4 flying mounts spanning common/epic/achievement/pvp tiers (60%%/100%%/280%%/310%% speed)\n");
std::printf(" --info-wmou <wmou-base> [--json]\n");
std::printf(" Print WMOU entries (id / kind / speed / required riding rank / faction / category / name)\n");
std::printf(" --validate-wmou <wmou-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, summonSpellId>0, flying needs rank>=150, racial needs raceMask\n");
feat(editor): add WMOU JSON round-trip authoring workflow Closes the WMOU open-format loop with --export-wmou-json / --import-wmou-json, mirroring the JSON pairs added for every other novel binary format. All 26 binary formats added since WOL now have full JSON round-trip authoring. Each mount round-trips all 14 scalar fields. Three enum-typed fields emit dual int + name forms: • mountKind (ground / flying / swimming / hybrid / aquatic) • factionId (both / alliance / horde) • categoryId (common / epic / racial / event / achievement / pvp / quest / class) Verified byte-identical round-trip on the flying preset (4 mounts spanning common/epic/achievement/pvp tiers with full WSPL spell + WIT item + WSKL riding skill cross-refs preserved through the JSON layer). Adds 2 flags (630 documented total now).
2026-05-09 17:33:54 -07:00
std::printf(" --export-wmou-json <wmou-base> [out.json]\n");
std::printf(" Export binary .wmou to a human-editable JSON sidecar (defaults to <base>.wmou.json)\n");
std::printf(" --import-wmou-json <json-path> [out-base]\n");
std::printf(" Import a .wmou.json sidecar back into binary .wmou (accepts kind/faction/category int OR name forms)\n");
feat(pipeline): add WBGD (Wowee Battleground Definition) format Novel open replacement for Blizzard's BattlemasterList.dbc + PvpDifficulty.dbc + the AzerothCore-style battleground_template SQL tables. The 33rd open format added to the editor. Defines per-BG gameplay rules: player count brackets, score-to-win, time limit, objective type (annihilation / capture flag / control nodes / king of hill / resource race / carry object), per-team start positions, respawn timer, and the WTKN currency token awarded on win. Cross-references with previously-added formats: WBGD.entry.mapId -> WMS.map.mapId (where mapType=Battleground) WBGD.entry.markTokenId -> WTKN.entry.tokenId (Mark of Honor for that BG) The classic preset's markTokenId fields (102/103/104) deliberately match WTKN.makePvp's "Mark of Honor: Warsong Gulch / Arathi Basin / Alterac Valley" token ids — so the demo content stack already wires together: WBGD.scoreToWin reached → grant WTKN mark → which a vendor in WTRN can charge in via item.extendedCost. Format: • magic "WBGD", version 1, little-endian • per BG: battlegroundId / mapId / name / description / objectiveKind / min+maxPlayersPerSide / minLevel..maxLevel / scoreToWin / timeLimitSeconds / bracketSize / allianceStart vec3 + facing / hordeStart vec3 + facing / respawnTimeSeconds / markTokenId Enums: • ObjectiveKind (6): Annihilation / CaptureFlag / ControlNodes / KingOfHill / ResourceRace / CarryObject API: WoweeBattlegroundLoader::save / load / exists / findById. Three preset emitters showcase typical BG shapes: • makeStarter — 1 king-of-hill BG (10v10, 3-cap to win) • makeClassic — 3 classic BGs with authentic player counts, level brackets, scoring, and WTKN cross-refs (Warsong Gulch CTF / Arathi Basin nodes / Alterac Valley resource race) • makeArena — 3 arena formats (Nagrand 2v2 / Blade's Edge 3v3 / Lordaeron 5v5) — annihilation objective + no respawn + 25 min cap CLI added (5 flags, 628 documented total now): --gen-bg / --gen-bg-classic / --gen-bg-arena --info-wbgd / --validate-wbgd Validator catches: bgId=0 + duplicates, empty name, unknown objectiveKind, player count=0, min>max counts/levels, scoreToWin=0 (no win condition), non-annihilation BG with respawnTimeSeconds=0 (losing side cannot recover).
2026-05-09 17:30:59 -07:00
std::printf(" --gen-bg <wbgd-base> [name]\n");
std::printf(" Emit .wbgd starter: 1 king-of-hill BG (10v10, 3-cap to win, 30 min limit)\n");
std::printf(" --gen-bg-classic <wbgd-base> [name]\n");
std::printf(" Emit .wbgd 3 classic BGs: Warsong Gulch (CTF) + Arathi Basin (nodes) + Alterac Valley (resource race)\n");
std::printf(" --gen-bg-arena <wbgd-base> [name]\n");
std::printf(" Emit .wbgd 3 arena formats: Nagrand 2v2 + Blade's Edge 3v3 + Lordaeron 5v5 (annihilation)\n");
std::printf(" --info-wbgd <wbgd-base> [--json]\n");
std::printf(" Print WBGD entries (id / map / objective / player counts / level range / score / token reward)\n");
std::printf(" --validate-wbgd <wbgd-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, player counts>0+min<=max, level range valid, scoreToWin>0\n");
feat(editor): add WBGD JSON round-trip authoring workflow Closes the WBGD open-format loop with --export-wbgd-json / --import-wbgd-json, mirroring the JSON pairs added for every other novel binary format. All 27 binary formats added since WOL now have full JSON round-trip authoring. Each battleground round-trips all scalar fields plus the allianceStart and hordeStart vec3 + facing pairs (positions become 3-element JSON arrays for natural hand-edit). The objectiveKind enum emits dual int + name forms. Verified byte-identical round-trip on the classic preset (3 BGs spanning CTF / control nodes / resource race objectives with full WMS map + WTKN markTokenId cross-refs preserved through the JSON layer). Adds 2 flags (637 documented total now).
2026-05-09 17:53:41 -07:00
std::printf(" --export-wbgd-json <wbgd-base> [out.json]\n");
std::printf(" Export binary .wbgd to a human-editable JSON sidecar (defaults to <base>.wbgd.json)\n");
std::printf(" --import-wbgd-json <json-path> [out-base]\n");
std::printf(" Import a .wbgd.json sidecar back into binary .wbgd (accepts objectiveKind int OR name string)\n");
feat(pipeline): add WMAL (Wowee Mail Template) format Novel open replacement for AzerothCore-style mail_loot_template SQL + the in-game mail subset of the inventory + currency systems. The 34th open format added to the editor. Defines templated mail messages with currency + item attachments. Triggered by quest reward delivery (overflow when bag is full), auction house bid wins / sales, achievement reward attachments, GM correspondence, holiday event mailings (Brewfest samples, Hallow's End candy), and returned-mail-on-rejection. Cross-references with previously-added formats: WMAL.entry.senderNpcId -> WCRT.entry.creatureId WMAL.entry.attachments.itemId -> WIT.entry.itemId Format: • magic "WMAL", version 1, little-endian • per template: templateId / senderNpcId / subject / body / senderName / moneyCopperAttached / categoryId / cod / returnable / expiryDays / attachments[] (each: itemId + quantity) Enums: • Category (8): QuestReward / Auction / GmCorrespondence / AchievementReward / EventMailing / Raffle / ScriptDelivery / ReturnedMail API: WoweeMailLoader::save / load / exists / findById. Three preset emitters showcase typical mail templates: • makeStarter — 3 templates (quest overflow / auction won / GM gift) covering the 3 most common categories • makeHoliday — 4 holiday samples that cross-reference the WTKN seasonal token IDs (200=Tricky Treats, 201=Brewfest, 202=Coin of Ancestry, 203=Stranger's Gift) so the demo content stack ships a full holiday onboarding experience • makeAuction — 5-template auction-house family (outbid / won / sold / expired / cancelled) — runtime fills in actual bid amounts / sold items at send time CLI added (5 flags, 635 documented total now): --gen-mail / --gen-mail-holiday / --gen-mail-auction --info-wmal / --validate-wmal Validator catches: templateId=0 + duplicates, empty subject, neither senderNpcId nor senderName set (no displayable sender), unknown category, expiryDays=0 (mail expires immediately), cod=1 with no money attached (free COD), empty mail in categories where the runtime doesn't fill in content (skips Auction / GmCorrespondence / ReturnedMail where empty templates are intentional). Two bugs caught + fixed during smoke-test on the auction preset: • print formatting glued the `0` from senderNpcId after the senderName when no NPC was set (rendered as "Postmaster0" instead of "Postmaster") — fixed with an explicit if/else split • validator's "no money + no items" warning was too aggressive for the Auction category, where templates are intentionally informational and the runtime fills in the real values — added Auction + ReturnedMail to the skip list
2026-05-09 17:41:03 -07:00
std::printf(" --gen-mail <wmal-base> [name]\n");
std::printf(" Emit .wmal starter: 3 templates (quest overflow / auction won / GM gift) covering main mail categories\n");
std::printf(" --gen-mail-holiday <wmal-base> [name]\n");
std::printf(" Emit .wmal 4 holiday samples (Tricky Treats / Brewfest / Lunar / Winter's Veil) with WTKN cross-refs\n");
std::printf(" --gen-mail-auction <wmal-base> [name]\n");
std::printf(" Emit .wmal 5-template auction-house family (outbid / won / sold / expired / cancelled)\n");
std::printf(" --info-wmal <wmal-base> [--json]\n");
std::printf(" Print WMAL templates (id / category / sender / subject + body / money + items / cod / expiry)\n");
std::printf(" --validate-wmal <wmal-base> [--json]\n");
std::printf(" Static checks: id>0+unique, subject not empty, sender set, attachments valid, no money+no items info-only\n");
feat(editor): add WMAL JSON round-trip authoring workflow Closes the WMAL open-format loop with --export-wmal-json / --import-wmal-json, mirroring the JSON pairs added for every other novel binary format. All 28 binary formats added since WOL now have full JSON round-trip authoring. Each template round-trips all 11 scalar fields plus the variable-length attachments array. categoryId emits dual int + name forms (quest / auction / gm / achievement / event / raffle / script / returned). Verified byte-identical round-trip on the holiday preset (4 templates with full WIT itemId attachments matching WTKN seasonal token IDs preserved through the JSON layer). Adds 2 flags (644 documented total now).
2026-05-09 18:04:03 -07:00
std::printf(" --export-wmal-json <wmal-base> [out.json]\n");
std::printf(" Export binary .wmal to a human-editable JSON sidecar (defaults to <base>.wmal.json)\n");
std::printf(" --import-wmal-json <json-path> [out-base]\n");
std::printf(" Import a .wmal.json sidecar back into binary .wmal (accepts category int OR name string)\n");
feat(pipeline): add WGEM (Wowee Gem / Enchantment) format Novel open replacement for Blizzard's ItemEnchantment.dbc + GemProperties.dbc + SpellItemEnchantment.dbc. The 35th open format added to the editor. Defines two related kinds of item enhancement in one catalog: • Gems — socketable jewelry pieces with color (red / blue / yellow / meta) that fit into gear sockets, granting stats or triggering passive spells when socketed • Enchantments — persistent buffs applied to weapon / armor pieces, either by an enchanter spell or by an item proc (Mongoose, Crusader, Berserking) Cross-references with previously-added formats: WGEM.gem.itemIdToInsert -> WIT.entry.itemId WGEM.gem.spellId -> WSPL.entry.spellId WGEM.enchantment.spellId -> WSPL.entry.spellId Format: • magic "WGEM", version 1, little-endian • gems[]: gemId / itemIdToInsert / name / color / statType + statValue / requiredItemQuality / spellId • enchantments[]: enchantId / name / description / iconPath / enchantSlot / statType + statValue / spellId / durationSeconds / chargeCount Enums: • Color (8): Meta / Red / Yellow / Blue / Purple / Green / Orange / Prismatic • EnchantSlot (5): Permanent / Temporary / SocketColor / Ring / Cloak API: WoweeGemLoader::save / load / exists + WoweeGem::findGem / findEnchant. Three preset emitters showcase common shapes: • makeStarter — 3 gems (one per primary color) + 2 enchantments (proc + stat) • makeGemSet — 6-gem full color palette covering primary + secondary combinations • makeEnchants — 5 enchant variants spanning slots (Mongoose / Deadly Poison / stats ring / cloak / Berserking) CLI added (5 flags, 642 documented total now): --gen-gems / --gen-gems-set / --gen-gems-enchants --info-wgem / --validate-wgem Validator catches: ids=0 + duplicates, empty name, color / slot out of range, stat-only entries with statValue=0 (gem provides nothing), chargeCount > 0 on non-Temporary enchant slots (charges silently ignored at runtime). The validator caught a real preset issue on first run — the proc enchants (Mongoose / Deadly Poison / Berserking) had spellId=0 and statValue=0, providing nothing. Fixed by adding placeholder spellIds in the 28000-29000 range, with a comment noting they resolve to real WSPL proc spells when the spell catalog is extended.
2026-05-09 18:01:48 -07:00
std::printf(" --gen-gems <wgem-base> [name]\n");
std::printf(" Emit .wgem starter: 3 gems (red/yellow/blue) + 2 enchantments (Crusader proc + Greater Stats)\n");
std::printf(" --gen-gems-set <wgem-base> [name]\n");
std::printf(" Emit .wgem 6-gem full color set (3 primary + 3 secondary purple/green/orange)\n");
std::printf(" --gen-gems-enchants <wgem-base> [name]\n");
std::printf(" Emit .wgem 5 enchant variants (Mongoose / Deadly Poison / stats ring / cloak / Berserking proc)\n");
std::printf(" --info-wgem <wgem-base> [--json]\n");
std::printf(" Print WGEM gems (id / color / stat / item) + enchantments (id / slot / stat / duration / charges)\n");
std::printf(" --validate-wgem <wgem-base> [--json]\n");
std::printf(" Static checks: ids>0+unique, name not empty, color/slot in range, stat-only entries need non-zero value\n");
feat(editor): add WGEM JSON round-trip authoring workflow Closes the WGEM open-format loop with --export-wgem-json / --import-wgem-json, mirroring the JSON pairs added for every other novel binary format. All 29 binary formats added since WOL now have full JSON round-trip authoring. Two top-level arrays mirror the binary layout: • gems[] — gemId / itemIdToInsert / name / color (dual int + name) / statType+Value / requiredItemQuality / spellId • enchantments[] — enchantId / name / description / icon / enchantSlot (dual int + name) / statType+Value / spellId / duration / chargeCount Verified byte-identical round-trip on the enchants preset (5 enchantments including 3 proc-based with WSPL spellId cross-refs in the 28000-29000 placeholder range, plus ring/cloak slot variants with chargeCount preserved). Adds 2 flags (651 documented total now).
2026-05-09 18:12:33 -07:00
std::printf(" --export-wgem-json <wgem-base> [out.json]\n");
std::printf(" Export binary .wgem to a human-editable JSON sidecar (defaults to <base>.wgem.json)\n");
std::printf(" --import-wgem-json <json-path> [out-base]\n");
std::printf(" Import a .wgem.json sidecar back into binary .wgem (accepts color/slot int OR name strings)\n");
feat(pipeline): add WGLD (Wowee Guild) catalog format Novel open replacement for AzerothCore-style guild + guild_member + guild_rank + guild_bank_tab + guild_perk SQL tables. The 36th open format added to the editor. Each guild entry holds the complete social-organization state: header (name, leader, faction, MOTD, info, creation date, level + experience, bank money, packed emblem), rank ladder with permissions bitmask + daily withdraw caps, member roster with rank + join date + public/officer notes, bank tabs with per-tab and per-rank deposit / withdraw / view permission masks, and purchased guild perks referencing WSPL spell IDs. Cross-references with previously-added formats: WGLD.entry.factionId ~ WCHC.race.factionId (guilds are faction-locked) WGLD.entry.perks.spellId -> WSPL.entry.spellId Format: • magic "WGLD", version 1, little-endian • per guild: header (12 scalar fields + 4 strings) + ranks[] + members[] + bankTabs[] + perks[] • per rank: rankIndex / name / permissionsMask / moneyPerDayCopper • per member: characterName / rankIndex / joinedDate / publicNote / officerNote • per bankTab: tabIndex / name / iconPath / deposit+withdraw+view permission masks • per perk: perkId / name / spellId / requiredGuildLevel Enums: • Faction (2): Alliance / Horde • RankPermissionFlags (14): GuildChat / OfficerChat / Invite / Remove / Promote / Demote / SetMotd / EditPublicNote / EditOfficerNote / ViewBank / Deposit / Withdraw / Disband / RepairFromBank API: WoweeGuildLoader::save / load / exists / findById + shared addDefaultRanks helper used by both starter and faction-pair presets. Three preset emitters: • makeStarter — 1 small guild, default 5-rank ladder (GM/Officer/Veteran/Member/Initiate), 3 members borrowing names from WCRT merchants for cross-format consistency • makeFull — 1 fleshed-out guild: 6 ranks (with Recruit added) + 8 members + 4 bank tabs (officer-only withdraw on tabs 3+4) + 3 perks referencing WSPL spell IDs (Heroic Strike / Battle Shout / Thunder Clap as placeholder perk procs) • makeFactionPair — 2 parallel guilds, one Alliance + one Horde, with identical rank structures CLI added (5 flags, 649 documented total now): --gen-guilds / --gen-guilds-full / --gen-guilds-pair --info-wgld / --validate-wgld Validator catches: guildId=0 + duplicates, empty name / leaderName, factionId out of range, no ranks (members can't exist without a rank ladder), member.rankIndex exceeding the highest defined rank (intra-format cross-reference resolution), duplicate bank tabIndices, perks with spellId=0 (perk does nothing).
2026-05-09 18:10:45 -07:00
std::printf(" --gen-guilds <wgld-base> [name]\n");
std::printf(" Emit .wgld starter: 1 guild (Sentinels of Dawn) with default 5-rank ladder + 3 members\n");
std::printf(" --gen-guilds-full <wgld-base> [name]\n");
std::printf(" Emit .wgld fleshed-out guild: 6 ranks + 8 members + 4 bank tabs (officer-only on tabs 3+4) + 3 perks\n");
std::printf(" --gen-guilds-pair <wgld-base> [name]\n");
std::printf(" Emit .wgld 2 guilds: 1 Alliance (Light's Vanguard) + 1 Horde (Bloodfang Warband) with parallel ranks\n");
std::printf(" --info-wgld <wgld-base> [--json]\n");
std::printf(" Print WGLD entries (id / faction / level / leader + motd / rank+member+tab+perk counts)\n");
std::printf(" --validate-wgld <wgld-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name+leader not empty, faction 0..1, members reference valid ranks, unique tab indices\n");
feat(editor): add WGLD JSON round-trip authoring workflow Closes the WGLD open-format loop with --export-wgld-json / --import-wgld-json, mirroring the JSON pairs added for every other novel binary format. All 30 binary formats added since WOL now have full JSON round-trip authoring. Each guild round-trips header scalars (12 fields) plus the 4 sub-arrays: • ranks[] — rank ladder with permissions + money cap • members[] — character roster with rank + notes • bankTabs[] — per-tab name + 3 permission masks • perks[] — purchased buffs with WSPL spell refs factionId emits dual int + name forms (alliance / horde). Verified byte-identical round-trip on the full preset (1 guild with 6 ranks + 8 members + 4 bank tabs + 3 perks; all permission masks and per-rank money caps preserved through the JSON layer). Adds 2 flags (658 documented total now).
2026-05-09 18:20:43 -07:00
std::printf(" --export-wgld-json <wgld-base> [out.json]\n");
std::printf(" Export binary .wgld to a human-editable JSON sidecar (defaults to <base>.wgld.json)\n");
std::printf(" --import-wgld-json <json-path> [out-base]\n");
std::printf(" Import a .wgld.json sidecar back into binary .wgld (accepts faction int OR name string)\n");
feat(pipeline): add WPCD (Wowee Player Condition) format Novel open replacement for Blizzard's PlayerCondition.dbc + the AzerothCore-style condition_template SQL tables. The 37th open format added to the editor. Defines reusable boolean conditions that other formats can reference for gating: "player has quest X completed", "player level >= N", "player class is mage", "player has item Y in inventory", "WSEA event Z is active". Conditions can be grouped and combined with AND/OR aggregators on a per-group basis: a quest-giver gossip option that says "show only to level 60 alliance mages who completed quest 1234" composes 4 conditions sharing the same groupId with AND aggregation. The runtime walks each group, applies the group's aggregator, and returns the boolean result to the caller. Cross-references with previously-added formats — the targetId field has a polymorphic interpretation by kind: WPCD.targetId (kind=QuestCompleted/Active) -> WQT.questId WPCD.targetId (kind=HasItem) -> WIT.itemId WPCD.targetId (kind=HasSpell) -> WSPL.spellId WPCD.targetId (kind=HasAchievement) -> WACH.achievementId WPCD.targetId (kind=AreaId) -> WMS.areaId WPCD.targetId (kind=EventActive) -> WSEA.eventId WPCD.targetId (kind=HasTitle) -> WTIT.titleId WPCD.targetId (kind=FactionRep) -> WFAC.factionId WPCD.targetId (kind=Class/Race) -> WCHC class/race id Future format extensions can reference WPCD.conditionId in their own gating fields — WTRG triggers gated by player state, WGSP options visible only when conditions are met, WMOU summon spells condition-gated by quest progress, etc. Format: • magic "WPCD", version 1, little-endian • per condition: conditionId / groupId (0 = standalone) / name / description / kind / aggregator / negated / targetId / minValue / maxValue Enums: • Kind (17): AlwaysTrue / AlwaysFalse / QuestCompleted / QuestActive / HasItem / HasSpell / MinLevel / MaxLevel / ClassMatch / RaceMatch / FactionRep / HasAchievement / TeamSize / GuildLevel / EventActive / AreaId / HasTitle • Aggregator (2): And / Or API: WoweeConditionLoader::save / load / exists / findById. Three preset emitters showcase typical usage: • makeStarter — 4 standalone conditions covering the most common kinds (quest-done / has-item / min-level / class) • makeGated — 5 conditions in 2 groups demonstrating AND-aggregation (alliance + mage + lvl 60) and OR-aggregation (did quest 1 OR quest 100) • makeEvent — 3 event-gated conditions cross-referencing WSEA event IDs (Hallow's End / Brewfest / Winter's Veil) CLI added (5 flags, 656 documented total now): --gen-conditions / --gen-conditions-gated / --gen-conditions-event --info-wpcd / --validate-wpcd Validator catches: conditionId=0 + duplicates, kind / aggregator out of range, kinds requiring targetId having target=0 (skips AlwaysTrue/False, MinLevel/MaxLevel, TeamSize, GuildLevel which use min/max instead), TeamSize with min > max.
2026-05-09 18:18:27 -07:00
std::printf(" --gen-conditions <wpcd-base> [name]\n");
std::printf(" Emit .wpcd starter: 4 conditions covering quest-done / has-item / min-level / class kinds\n");
std::printf(" --gen-conditions-gated <wpcd-base> [name]\n");
std::printf(" Emit .wpcd 5 conditions in 2 groups (group 100 AND alliance+mage+lvl60; group 200 OR did-quest-1/100)\n");
std::printf(" --gen-conditions-event <wpcd-base> [name]\n");
std::printf(" Emit .wpcd 3 event-gated conditions referencing WSEA event IDs (Hallow's End / Brewfest / Winter's Veil)\n");
std::printf(" --info-wpcd <wpcd-base> [--json]\n");
std::printf(" Print WPCD entries (id / group / kind / aggregator / negated / target / min..max value / name)\n");
std::printf(" --validate-wpcd <wpcd-base> [--json]\n");
std::printf(" Static checks: id>0+unique, kind in 0..16, aggregator 0..1, kinds that need targetId have non-zero target\n");
feat(editor): add WPCD JSON round-trip authoring workflow Closes the WPCD open-format loop with --export-wpcd-json / --import-wpcd-json, mirroring the JSON pairs added for every other novel binary format. All 31 binary formats added since WOL now have full JSON round-trip authoring. Each condition round-trips all 9 scalar fields. Two enum-typed fields emit dual int + name forms: • kind (true / false / quest-done / has-item / min-level / class / event / area / title / ...) • aggregator (and / or) Verified byte-identical round-trip on the gated preset (5 conditions in 2 groups demonstrating both AND and OR aggregation, with full polymorphic targetId / minValue / maxValue payload preserved through the JSON layer). Adds 2 flags (665 documented total now).
2026-05-09 18:28:47 -07:00
std::printf(" --export-wpcd-json <wpcd-base> [out.json]\n");
std::printf(" Export binary .wpcd to a human-editable JSON sidecar (defaults to <base>.wpcd.json)\n");
std::printf(" --import-wpcd-json <json-path> [out-base]\n");
std::printf(" Import a .wpcd.json sidecar back into binary .wpcd (accepts kind/aggregator int OR name forms)\n");
feat(pipeline): add WPET (Wowee Pet System) catalog Novel open replacement for AzerothCore-style pet_template + pet_levelstats SQL + the pet-related subsets of CreatureFamily.dbc + SpellFamilyName.dbc. The 38th open format added to the editor. Defines two related kinds of player-controlled NPCs in one catalog: • Pet families — hunter pet families (Wolf / Cat / Bear / Boar / Raptor / Spider / etc.) with per-family ability sets, base stat multipliers, and diet preferences • Warlock minions — Imp / Voidwalker / Succubus / Felhunter / Felguard, each with their own summon spell, creature template, and ability list Cross-references with previously-added formats: WPET.family.familyId -> WCRT.entry.familyId (matches creature family) WPET.family.abilities.spellId -> WSPL.entry.spellId WPET.minion.summonSpellId -> WSPL.entry.spellId WPET.minion.creatureId -> WCRT.entry.creatureId (used for stat scaling) WPET.minion.abilities.spellId -> WSPL.entry.spellId The starter preset's familyIds (1=Wolf, 2=Cat) match WCRT::FamilyId enum values, so a hunter taming a wolf via WCRT links straight through to WPET ability sets. Format: • magic "WPET", version 1, little-endian • families[]: familyId / name / description / icon / petType / baseAttackSpeed / damageMultiplier / armorMultiplier / dietMask / abilities[] • minions[]: minionId / name / summonSpellId / creatureId / abilities[] (each: spellId / rank / autocastDefault) Enums: • PetType (3): Cunning / Ferocity / Tenacity (WotLK+ talent tree categorization) • DietFlags: Meat / Fish / Bread / Cheese / Fruit / Fungus API: WoweePetLoader::save / load / exists + WoweePet::findFamily / findMinion + dietMaskName helper that decodes a dietMask into a "meat+fish" string. Three preset emitters showcase typical pet catalogs: • makeStarter — 2 hunter families (Wolf + Cat) with full 3-ability sets + 1 warlock Imp • makeHunter — 8 classic hunter families covering all 3 petType categories with appropriate diet masks • makeWarlock — 5 warlock minions each with summon spell ID and creatureId pointing into WCRT CLI added (5 flags, 663 documented total now): --gen-pets / --gen-pets-hunter / --gen-pets-warlock --info-wpet / --validate-wpet Validator catches: ids=0 + duplicates, empty name, petType out of range, baseAttackSpeed<=0 (would divide by zero in DPS calc), dietMask=0 (pet cannot be fed for happiness), minion missing summonSpellId / creatureId.
2026-05-09 18:27:02 -07:00
std::printf(" --gen-pets <wpet-base> [name]\n");
std::printf(" Emit .wpet starter: 2 hunter families (Wolf + Cat) + 1 warlock minion (Imp) with WSPL ability refs\n");
std::printf(" --gen-pets-hunter <wpet-base> [name]\n");
std::printf(" Emit .wpet 8 classic hunter families (Wolf/Cat/Bear/Boar/Raptor/Hyena/Spider/Crab) with diet+petType\n");
std::printf(" --gen-pets-warlock <wpet-base> [name]\n");
std::printf(" Emit .wpet 5 warlock minions (Imp/Voidwalker/Succubus/Felhunter/Felguard) with summon spell + WCRT ref\n");
std::printf(" --info-wpet <wpet-base> [--json]\n");
std::printf(" Print WPET families (id / petType / atkSpd / dmg+arm mult / diet) + minions (id / summon / creatureId)\n");
std::printf(" --validate-wpet <wpet-base> [--json]\n");
std::printf(" Static checks: ids>0+unique, name not empty, petType 0..2, atkSpeed>0, minion needs summon+creatureId\n");
feat(editor): add WPET JSON round-trip authoring workflow Closes the WPET open-format loop with --export-wpet-json / --import-wpet-json, mirroring the JSON pairs added for every other novel binary format. All 32 binary formats added since WOL now have full JSON round-trip authoring. Two top-level arrays mirror the binary layout: • families[] — familyId / name / description / icon / petType (dual int + name) / baseAttackSpeed / damageMultiplier / armorMultiplier / dietMask + name / abilities[] • minions[] — minionId / name / summonSpellId / creatureId / abilities[] Verified byte-identical round-trip on the starter preset (2 hunter families with 3 abilities each + 1 warlock Imp with 2 abilities including autocast preferences preserved through the JSON layer). Adds 2 flags (672 documented total now).
2026-05-09 18:37:12 -07:00
std::printf(" --export-wpet-json <wpet-base> [out.json]\n");
std::printf(" Export binary .wpet to a human-editable JSON sidecar (defaults to <base>.wpet.json)\n");
std::printf(" --import-wpet-json <json-path> [out-base]\n");
std::printf(" Import a .wpet.json sidecar back into binary .wpet (accepts petType int OR name string)\n");
feat(pipeline): add WAUC (Wowee Auction House) catalog Novel open replacement for Blizzard's AuctionHouse.dbc + the AzerothCore-style auctionhouse / auctionhousebot SQL tables. The 39th open format added to the editor. Defines per-house rules for the auction system: faction access, deposit rate (basis points of buyout price), house cut on successful sale, three listing duration tiers with per-tier deposit multipliers, disallowed item-class bitmask, and the auctioneer NPC. Cross-references with previously-added formats: WAUC.entry.auctioneerNpcId -> WCRT.entry.creatureId (Auctioneer-flagged NPC) WAUC.entry.disallowedClassMask bitmask of WIT.Class values that may not be auctioned at this house The faction-pair preset captures the canonical asymmetry: faction houses charge 5% on a successful sale while neutral houses charge 15% — the cross-faction tax that makes neutral AHs profitable for goblins. Format: • magic "WAUC", version 1, little-endian • per house: houseId / auctioneerNpcId / name / factionAccess / baseDepositRateBp / houseCutRateBp / maxBidCopper / 3 duration hours + 3 deposit multipliers / disallowedClassMask Enums: • FactionAccess (4): Alliance / Horde / Neutral / Both • Rates use basis points: 10000 = 100% API: WoweeAuctionLoader::save / load / exists / findById. Three preset emitters showcase typical auction setups: • makeStarter — 1 neutral house with default 12h / 24h / 48h tiers • makeFactionPair — 3 houses (Stormwind / Orgrimmar / Booty Bay) with auctioneer NPC IDs + canonical faction-vs-neutral cut rates • makeRestricted — 1 house disallowing Containers (1) + Quest items (12) + Keys (13) with tighter durations + 1000g bid cap CLI added (5 flags, 670 documented total now): --gen-auction / --gen-auction-pair / --gen-auction-restricted --info-wauc / --validate-wauc Validator catches: houseId=0 + duplicates, empty name, factionAccess out of range, duration tier=0, durations not in short<=medium<=long order, houseCutRateBp >= 100% (seller loses money on a sale), warns on >50% cut.
2026-05-09 18:34:54 -07:00
std::printf(" --gen-auction <wauc-base> [name]\n");
std::printf(" Emit .wauc starter: 1 neutral house with stock 12h/24h/48h tiers and 5%% house cut\n");
std::printf(" --gen-auction-pair <wauc-base> [name]\n");
std::printf(" Emit .wauc 3 houses (Stormwind / Orgrimmar / Booty Bay) — faction 5%% cut vs neutral 15%% asymmetry\n");
std::printf(" --gen-auction-restricted <wauc-base> [name]\n");
std::printf(" Emit .wauc 1 house with disallowedClassMask (no Containers/Quest/Keys) + tighter durations + bid cap\n");
std::printf(" --info-wauc <wauc-base> [--json]\n");
std::printf(" Print WAUC houses (id / faction / deposit + cut percent / 3 duration tiers / disallow mask / npc)\n");
std::printf(" --validate-wauc <wauc-base> [--json]\n");
std::printf(" Static checks: id>0+unique, faction 0..3, durations short<=medium<=long, cut < 100%%\n");
feat(editor): add WAUC JSON round-trip authoring workflow Closes the WAUC open-format loop with --export-wauc-json / --import-wauc-json, mirroring the JSON pairs added for every other novel binary format. All 33 binary formats added since WOL now have full JSON round-trip authoring. Each house round-trips all 14 scalar fields plus the factionAccess enum dual int + name forms (alliance / horde / neutral / both). Verified byte-identical round-trip on the faction-pair preset (3 houses including Stormwind/Orgrimmar/Booty Bay with different cut rates and auctioneer NPC IDs preserved through the JSON layer). Adds 2 flags (679 documented total now).
2026-05-09 18:45:01 -07:00
std::printf(" --export-wauc-json <wauc-base> [out.json]\n");
std::printf(" Export binary .wauc to a human-editable JSON sidecar (defaults to <base>.wauc.json)\n");
std::printf(" --import-wauc-json <json-path> [out-base]\n");
std::printf(" Import a .wauc.json sidecar back into binary .wauc (accepts factionAccess int OR name string)\n");
feat(pipeline): add WCHN (Wowee Chat Channel) catalog Novel open replacement for Blizzard's ChatChannels.dbc + the AzerothCore-style chat_channel SQL tables. The 40th open format added to the editor. Defines the world chat channel system: General, Trade, LookingForGroup, GuildRecruitment, LocalDefense, plus per-zone area channels and custom user-created channels. Each channel has access rules (faction / level), join behavior (auto vs opt-in), broadcast policy (announce / moderated), and optional area / map gating that auto-joins or auto-leaves the channel as the player moves. Cross-references with previously-added formats: WCHN.entry.areaIdGate -> WMS.area.areaId (channel auto-attaches in this area) WCHN.entry.mapIdGate -> WMS.map.mapId (channel auto-attaches on this map) Format: • magic "WCHN", version 1, little-endian • per channel: channelId / name / description / channelType / factionAccess / autoJoin / announce / moderated / minLevel / areaIdGate / mapIdGate Enums: • ChannelType (10): AreaLocal / Zone / Continent / World / Trade / LookingForGroup / GuildRecruit / LocalDefense / Custom / Pvp • FactionAccess (3): Alliance / Horde / Both API: WoweeChannelLoader::save / load / exists / findById. Three preset emitters: • makeStarter — 4 stock channels (General Zone + Trade + LFG + GuildRecruit) with default autoJoin policies • makeCity — 5 city-specific channels (3 Stormwind + 2 Orgrimmar) with mapId / areaId gates so they auto-attach on entry • makeModerated — 3 moderated / restricted channels (LocalDefense level 10+, WorldDefense moderated, RaidCoordination level 60+) CLI added (5 flags, 677 documented total now): --gen-channels / --gen-channels-city / --gen-channels-moderated --info-wchn / --validate-wchn Validator catches: channelId=0 + duplicates, empty name, unknown channelType / factionAccess, world / continent channel with area or map gate (gate is silently ignored at runtime — usually a typo), minLevel=0 (no level gate at all).
2026-05-09 18:43:26 -07:00
std::printf(" --gen-channels <wchn-base> [name]\n");
std::printf(" Emit .wchn starter: 4 stock channels (General / Trade / LFG / GuildRecruit) with autoJoin defaults\n");
std::printf(" --gen-channels-city <wchn-base> [name]\n");
std::printf(" Emit .wchn 5 city channels (Stormwind General/Trade/LFG + Orgrimmar General/Trade) with map+area gates\n");
std::printf(" --gen-channels-moderated <wchn-base> [name]\n");
std::printf(" Emit .wchn 3 moderated channels (LocalDefense / WorldDefense moderated / RaidCoordination level 60+)\n");
std::printf(" --info-wchn <wchn-base> [--json]\n");
std::printf(" Print WCHN entries (id / type / faction / autoJoin/announce/moderated / level / map+area gates / name)\n");
std::printf(" --validate-wchn <wchn-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, type 0..9, faction 0..2, world+area-gate combo warning\n");
feat(editor): add WCHN JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the channels catalog format shipped last batch. --export-wchn-json emits all 10 scalar fields plus dual int + name forms for channelType and factionAccess so hand-edits can use either representation. --import-wchn-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / city / moderated).
2026-05-09 18:52:32 -07:00
std::printf(" --export-wchn-json <wchn-base> [out.json]\n");
std::printf(" Export binary .wchn to a human-editable JSON sidecar (defaults to <base>.wchn.json)\n");
std::printf(" --import-wchn-json <json-path> [out-base]\n");
std::printf(" Import a .wchn.json sidecar back into binary .wchn (accepts channelType/factionAccess int OR name string)\n");
feat(pipeline): add WCMS (Wowee Cinematic) catalog 41st open format — replaces Movie.dbc / CinematicCamera.dbc / CinematicSequences.dbc plus the AzerothCore cinematic_camera SQL table. Defines pre-rendered videos, in-engine camera flythroughs, text crawls, and still images, each with a media path, duration, skippable flag, and a polymorphic trigger that fires on quest events / class first-login / zone entry / dungeon clear / achievements / level milestones. Cross-references with prior formats — triggerTargetId resolves by triggerKind to WQT.questId / WMS.areaId / WMS.mapId / WCHC.classId / WACH.achievementId, and soundtrackId points at WSND.soundId. CLI: --gen-cinematics (3-entry starter), --gen-cinematics-intros (4 class intros), --gen-cinematics-quests (3 quest-bound cinematics referencing demo questIds 1/100/102), --info-wcms, --validate-wcms with --json variants. Validator catches id=0/duplicates, empty name/mediaPath, kind/trigger out of range, missing target id for non-Manual/Login/LevelUp triggers, zero-duration entries, and non-skippable pre-rendered videos.
2026-05-09 18:50:43 -07:00
std::printf(" --gen-cinematics <wcms-base> [name]\n");
std::printf(" Emit .wcms starter: 3 cinematics (pre-rendered intro / quest cutscene / login splash)\n");
std::printf(" --gen-cinematics-intros <wcms-base> [name]\n");
std::printf(" Emit .wcms 4 class intros (Warrior / Hunter / Rogue / Mage) triggered on first ClassStart\n");
std::printf(" --gen-cinematics-quests <wcms-base> [name]\n");
std::printf(" Emit .wcms 3 quest-bound cinematics referencing WQT questIds 1 / 100 / 102 (start / start / end)\n");
std::printf(" --info-wcms <wcms-base> [--json]\n");
std::printf(" Print WCMS entries (id / kind / trigger / target / duration / skippable / soundtrackId / name)\n");
std::printf(" --validate-wcms <wcms-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name+mediaPath not empty, kind 0..4, trigger 0..8, target required for non-Manual triggers\n");
feat(editor): add WCMS JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the cinematic catalog format shipped two batches ago. --export-wcms-json emits all 9 scalar fields plus dual int + name forms for kind and triggerKind so hand-edits can use either representation. --import-wcms-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / intros / quests).
2026-05-09 18:56:29 -07:00
std::printf(" --export-wcms-json <wcms-base> [out.json]\n");
std::printf(" Export binary .wcms to a human-editable JSON sidecar (defaults to <base>.wcms.json)\n");
std::printf(" --import-wcms-json <json-path> [out-base]\n");
std::printf(" Import a .wcms.json sidecar back into binary .wcms (accepts kind/triggerKind int OR name string)\n");
feat(pipeline): add WGLY (Wowee Glyph) catalog 42nd open format — replaces GlyphProperties.dbc + GlyphSlot.dbc plus the AzerothCore-style glyph_properties SQL table. Defines the WotLK glyph system: per-class inscribable glyphs that modify spell behavior. Each entry pairs a glyph item (the inscriber's craft output) with the spell aura that applies the modification, tagged with a Major / Minor / Prime slot type and a classMask of allowed classes. Cross-references with prior formats — spellId points at WSPL.spellId (the aura), itemId points at WIT.itemId (the inscribed item), and classMask bit positions match the WCHC classId enum (1=Warrior, 2=Paladin, 3=Hunter, etc). CLI: --gen-glyphs (3-entry per-role starter), --gen-glyphs-warrior (6-entry full warrior allotment), --gen-glyphs-universal (4 classMask=All utility glyphs), --info-wgly, --validate-wgly with --json variants. Validator catches id=0/duplicates, empty name, spellId=0 (glyph applies no aura), classMask=0 (no class can inscribe), itemId=0 warning, requiredLevel<25 warning (below WotLK glyph threshold), and glyphType out-of-range.
2026-05-09 18:55:22 -07:00
std::printf(" --gen-glyphs <wgly-base> [name]\n");
std::printf(" Emit .wgly starter: 3 glyphs (1 warrior + 1 mage + 1 rogue) showing per-class Major slot picks\n");
std::printf(" --gen-glyphs-warrior <wgly-base> [name]\n");
std::printf(" Emit .wgly 6 warrior glyphs (3 major + 3 minor) demonstrating per-class allotment\n");
std::printf(" --gen-glyphs-universal <wgly-base> [name]\n");
std::printf(" Emit .wgly 4 universal glyphs (classMask=All) covering hearthstone/levitate/mounting/salvation\n");
std::printf(" --info-wgly <wgly-base> [--json]\n");
std::printf(" Print WGLY entries (id / type / spellId / itemId / classMask / requiredLevel / name)\n");
std::printf(" --validate-wgly <wgly-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name+spellId not empty, type 0..2, classMask>0, level<25 warning, missing-itemId warning\n");
feat(editor): add WGLY JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the glyph catalog format shipped last batch. --export-wgly-json emits all 8 scalar fields plus a dual int + name form for glyphType so hand-edits can use either representation. --import-wgly-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / warrior / universal). 700 documented CLI flags.
2026-05-09 19:01:03 -07:00
std::printf(" --export-wgly-json <wgly-base> [out.json]\n");
std::printf(" Export binary .wgly to a human-editable JSON sidecar (defaults to <base>.wgly.json)\n");
std::printf(" --import-wgly-json <json-path> [out-base]\n");
std::printf(" Import a .wgly.json sidecar back into binary .wgly (accepts glyphType int OR name string)\n");
feat(pipeline): add WVHC (Wowee Vehicle) catalog 43rd open format — replaces Vehicle.dbc + VehicleSeat.dbc plus the AzerothCore-style vehicle_template SQL tables. Defines drivable vehicles: tanks, demolishers, motorcycles, gryphons, choppers, siege weapons, multi-passenger transports. Each entry pairs a creature template (the rendered model) with a fixed seat layout — driver / passenger / gunner seats with their own attachment points, control flags (kSeatDriver / kSeatGunner / kSeatPassenger / kSeatHidesPlayer / kSeatNoEjectByCC), and per-seat abilities mounted to the action bar. Cross-references with prior formats — creatureId points at WCRT.creatureId (the rendered model), flightCapabilityId points at WMNT.mountId for shared fly-speed tables, and per-seat controlSpellId / exitSpellId point at WSPL.spellId. CLI: --gen-vehicles (3-vehicle starter chopper/wind-rider/tank), --gen-vehicles-siege (3 siege weapons with control spellIds), --gen-vehicles-flying (3 flying mounts cross-ref WMNT flightCapabilityIds), --info-wvhc, --validate-wvhc with --json variants. Validator catches id=0/duplicates, missing creature, enum out-of-range, empty seat list, flying-vehicle on wrong movement (would fall through world), driver-flag exclusivity (0 or >1 drivers), and duplicate seatIndex within a vehicle.
2026-05-09 18:59:49 -07:00
std::printf(" --gen-vehicles <wvhc-base> [name]\n");
std::printf(" Emit .wvhc starter: 3 vehicles (chopper / wind rider / salvaged tank) covering ground+air+siege roles\n");
std::printf(" --gen-vehicles-siege <wvhc-base> [name]\n");
std::printf(" Emit .wvhc 3 siege weapons (Demolisher 2-seat / Glaive Thrower / Salvaged Cannon) with control spellIds\n");
std::printf(" --gen-vehicles-flying <wvhc-base> [name]\n");
std::printf(" Emit .wvhc 3 flying mounts (Wind Rider / Storm Gryphon / Twilight Drake) cross-ref WMNT flightCapabilityIds\n");
std::printf(" --info-wvhc <wvhc-base> [--json]\n");
std::printf(" Print WVHC entries with seat layout (id / creature / kind / movement / power / seat count / name)\n");
std::printf(" --validate-wvhc <wvhc-base> [--json]\n");
std::printf(" Static checks: id>0+unique, creatureId>0, kind/movement/power in range, exactly 1 driver seat, no duplicate seatIndex\n");
feat(editor): add WVHC JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the vehicle catalog format shipped last batch. --export-wvhc-json emits all 10 scalar fields plus a nested array of seats per entry, and dual int + name forms for vehicleKind / movementKind / powerType so hand-edits can use either representation. --import-wvhc-json accepts either form, falling back to the int when both are present, and reconstructs the seat array preserving seat flags / attachments / control-spell cross-refs. Verified byte-identical round-trip on all three preset emitters (starter / siege / flying), including nested seat data. 702 documented CLI flags.
2026-05-09 19:02:17 -07:00
std::printf(" --export-wvhc-json <wvhc-base> [out.json]\n");
std::printf(" Export binary .wvhc to a human-editable JSON sidecar with nested seat arrays (defaults to <base>.wvhc.json)\n");
std::printf(" --import-wvhc-json <json-path> [out-base]\n");
std::printf(" Import a .wvhc.json sidecar back into binary .wvhc (accepts vehicleKind/movementKind/powerType int OR name string)\n");
feat(pipeline): add WHOL (Wowee Holiday) catalog 44th open format — replaces Holidays.dbc + HolidayDescriptions.dbc + HolidayNames.dbc plus the AzerothCore-style game_event SQL tables. Defines time-gated world events: seasonal holidays (Hallow's End / Brewfest / Winter Veil), weekly call-to-arms BG bonuses, world-PvP windows (Wintergrasp), one-shot specials, and recurring daily / weekly resets. Each holiday has a recurrence rule (Annual / Monthly / WeeklyRecur / OneTime), a calendar window (startMonth + startDay + durationHours), and optional cross-refs to a feature creature, an intro quest, and a token / item reward issued during the window. Cross-references with prior formats — holidayQuestId points at WQT.questId, bossCreatureId points at WCRT.creatureId, itemRewardId points at WIT.itemId, and areaIdGate / mapIdGate point at WMS.areaId / WMS.mapId. CLI: --gen-holidays (3 seasonal starter), --gen-holidays-weekly (3 weekly BG call-to-arms windows), --gen-holidays-special (3 world-PvP / lunar / children events), --info-whol, --validate-whol with --json variants. Validator catches id=0/duplicates, kind / recurrence out of range, durationHours=0, invalid month/day for non-weekly recurrence, and calendar-only events (no quest + boss + reward) as a warning.
2026-05-09 19:05:33 -07:00
std::printf(" --gen-holidays <whol-base> [name]\n");
std::printf(" Emit .whol starter: 3 seasonal holidays (Hallow's End / Brewfest / Winter Veil) with boss+reward+quest cross-refs\n");
std::printf(" --gen-holidays-weekly <whol-base> [name]\n");
std::printf(" Emit .whol 3 weekly call-to-arms BG bonus windows (Warsong Gulch / Arathi Basin / Eye of the Storm)\n");
std::printf(" --gen-holidays-special <whol-base> [name]\n");
std::printf(" Emit .whol 3 special events (Wintergrasp world-PvP / Lunar Festival / Children's Week)\n");
std::printf(" --info-whol <whol-base> [--json]\n");
std::printf(" Print WHOL entries (id / kind / recurrence / start MM/DD / duration / quest+boss+reward IDs / name)\n");
std::printf(" --validate-whol <whol-base> [--json]\n");
std::printf(" Static checks: id>0+unique, kind 0..5, recurrence 0..3, duration>0, valid month/day for non-weekly, calendar-only warning\n");
feat(editor): add WHOL JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the holiday catalog format shipped last batch. --export-whol-json emits all 13 scalar fields plus dual int + name forms for holidayKind and recurrence so hand-edits can use either representation. --import-whol-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / weekly / special). 709 documented CLI flags.
2026-05-09 19:07:08 -07:00
std::printf(" --export-whol-json <whol-base> [out.json]\n");
std::printf(" Export binary .whol to a human-editable JSON sidecar (defaults to <base>.whol.json)\n");
std::printf(" --import-whol-json <json-path> [out-base]\n");
std::printf(" Import a .whol.json sidecar back into binary .whol (accepts holidayKind/recurrence int OR name string)\n");
feat(pipeline): add WLIQ (Wowee Liquid Type) catalog 45th open format — replaces LiquidType.dbc plus the AzerothCore-style terrain liquid descriptor data. Defines liquid materials used by terrain MCNK liquid layers, WMO interior pools, and procedurally generated fluid bodies in custom zones. Each liquid pairs a render material (shader + texture array + flow vectors + fog color) with gameplay data (damage spell, raw DPS, ambient + splash audio cross-refs). Cross-references with prior formats — ambientSoundId and splashSoundId point at WSND.soundId, damageSpellId points at WSPL.spellId. 10 liquid kinds (Water / Magma / Slime / OceanSalt / FelFire / HolyLight / TarOil / AcidBog / FrozenWater / UnderworldGoo) covering both natural and magical fluids. Per-liquid: viscosity (0=water, 1=slime), flow direction+speed (radians+units/sec), fog density+RGB, packed minimap RGBA color. CLI: --gen-liquids (3-entry classic Water/Lava/Slime starter), --gen-liquids-magical (4 magical pools incl. fel/holy/cosmic), --gen-liquids-hazardous (3 high-damage liquids with WSPL DoT cross-refs), --info-wliq, --validate-wliq with --json variants. Validator catches id=0/duplicates, missing shader/material, kind out of range, fog/viscosity outside 0..1, hazardous-kind- without-damage warning, and Water/OceanSalt-with-damage warning to flag accidental misconfiguration.
2026-05-09 19:10:03 -07:00
std::printf(" --gen-liquids <wliq-base> [name]\n");
std::printf(" Emit .wliq starter: 3 stock liquids (Fresh Water / Lava / Sludge Slime) with shaders+sounds+DPS\n");
std::printf(" --gen-liquids-magical <wliq-base> [name]\n");
std::printf(" Emit .wliq 4 magical liquids (Fel Fire / Holy Light / Underworld / Cosmic) with damage spell IDs\n");
std::printf(" --gen-liquids-hazardous <wliq-base> [name]\n");
std::printf(" Emit .wliq 3 high-damage liquids (Naxx Slime / Acid Bog / Fel Lava) with WSPL cross-refs\n");
std::printf(" --info-wliq <wliq-base> [--json]\n");
std::printf(" Print WLIQ entries (id / kind / fog RGB / density / viscosity / DPS / spell+sound IDs / name)\n");
std::printf(" --validate-wliq <wliq-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name+shader+material not empty, kind 0..9, fog/visc 0..1, hazardous-no-damage warning\n");
feat(editor): add WLIQ JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the liquid catalog format shipped this batch. --export-wliq-json emits all 14 scalar fields (incl. 3-byte fog RGB) plus a dual int + name form for liquidKind so hand-edits can use either representation. --import-wliq-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / magical / hazardous). 716 documented CLI flags.
2026-05-09 19:11:14 -07:00
std::printf(" --export-wliq-json <wliq-base> [out.json]\n");
std::printf(" Export binary .wliq to a human-editable JSON sidecar (defaults to <base>.wliq.json)\n");
std::printf(" --import-wliq-json <json-path> [out-base]\n");
std::printf(" Import a .wliq.json sidecar back into binary .wliq (accepts liquidKind int OR name string)\n");
feat(editor): add --list-formats catalog discoverability flag New top-level CLI flag prints a table of every novel open format the project ships: 4-char binary magic, file extension, category label, the proprietary file(s) it replaces, and a one-line description. 44 formats total covering 5 world/asset foundations (.wom / .wob / .whm / .wot / .wow) and 39 catalog DBC/SQL replacements. Also exposes formats not previously surfaced via --gen-* flags (WFAC factions, WLCK locks, WSKL skills, WOLA outdoor light, WOWA weather, WMPX world map) — these are loaded directly by the engine. Supports --json variant for tooling integration.
2026-05-09 19:14:55 -07:00
std::printf(" --list-formats [--json]\n");
std::printf(" Print the catalog of all novel open formats (magic / extension / category / replaces / description)\n");
feat(editor): add --info-magic auto-detect inspector Reads the first 4 bytes of any file, looks the magic up in the format table, and reports: format name, file extension, category, plus the standard catalog header fields (version, catalog name, entry count) for any of the 33 catalog formats that share the magic+version+name+entryCount layout. Also suggests the matching --info-* flag so users who receive .w* files without context can route to the right inspector in one step. World/asset formats (WOM/WOB/WHM/WOT/WOW) are recognized by magic but the catalog-style header probe is skipped (their layouts differ). Returns exit 1 + 'unrecognized' message on non-Wowee files. Supports --json variant for tooling integration.
2026-05-09 19:16:26 -07:00
std::printf(" --info-magic <path> [--json]\n");
std::printf(" Auto-detect any .w* file by 4-byte magic; report format / version / catalog name / entry count + suggest --info-* flag\n");
feat(editor): add --summary-dir bulk content inventory Recursively walks a directory, identifies every file by 4-byte magic, and reports per-format file count, total entries, and bytes. Useful for content audits ("how many cinematics did this asset bundle ship?") and for tracking migration progress ("what fraction of zones still lack a holiday catalog?"). Also extracts the format-magic table out of cli_info_magic.cpp into a shared cli_format_table.{hpp,cpp} so --info-magic and --summary-dir reuse the same source of truth — adding a new format now updates one row in one file instead of two. Both flags use the standard catalog header (magic + version + name + entryCount) for catalog formats; asset/world formats are counted but report 0 entries since their headers differ. Supports --json variant for tooling integration.
2026-05-09 19:27:48 -07:00
std::printf(" --summary-dir <dir> [--json]\n");
std::printf(" Recursively walk a directory; report per-format file count, total entries, and bytes for every Wowee open format found\n");
feat(editor): add --rename-by-magic extension recovery flag Reads the 4-byte magic of a file, looks it up in the shared format table, and renames the file to use the correct .w* extension. Useful when files have lost their extensions (downloaded as 'data.bin', extracted from a tarball with mangled metadata, or copied via a tool that strips suffixes). Safe by default — refuses to overwrite an existing target; pass --force to allow overwrite. --dry-run prints the planned move without touching the filesystem. Files that already have the correct extension are a no-op. Unrecognized magic exits 1 with the bytes printed for diagnostic context. Reuses cli_format_table.cpp so any future format addition is picked up automatically.
2026-05-09 19:29:18 -07:00
std::printf(" --rename-by-magic <file> [--dry-run] [--force]\n");
std::printf(" Recover the correct .w* extension on a file by reading its 4-byte magic. --dry-run prints the planned move; --force overwrites\n");
feat(editor): add --bulk-rename-by-magic recursive recovery flag Walks a directory tree, identifies every file by 4-byte magic, and renames each one to use the correct .w* extension. Counterpart to single-file --rename-by-magic for the case where a whole asset bundle came in with mangled extensions (extracted from a tarball that lost suffixes, downloaded with CDN-rewritten names, dumped from a database BLOB column). Same safety semantics as the single-file flag: conflicts are skipped without --force, --dry-run prints the planned moves without touching the filesystem. Reports per-file PASS/FAIL/ CONFLICT and a final summary (renamed / skipped-conflict / already-correct / unrecognized counts). Exits 1 if any rename failed (e.g. permission errors) so it can be wired into CI as a gate.
2026-05-09 19:44:52 -07:00
std::printf(" --bulk-rename-by-magic <dir> [--dry-run] [--force]\n");
std::printf(" Apply --rename-by-magic recursively to every file in <dir>. Conflicts are skipped without --force; exits 1 if any rename failed\n");
feat(pipeline): add WANI (Wowee Animation) catalog 46th open format — replaces AnimationData.dbc plus the hard-coded animation-id tables in M2 model loaders. Defines named animations (Stand, Walk, Run, Cast, Death, MountIdle, Fly, ...) with fallback chains, behavior tier (default / mounted / sitting / aerial / swimming), and weapon-flag bitmasks that select the correct animation variant when the model wields 1H / 2H / dual / bow / rifle / wand / etc. Cross-references with prior formats — fallbackId resolves within the same WANI catalog (graceful degradation when the requested animation is absent: Run falls back to Walk, Attack2H falls back to Attack1H). 10 weapon-flag constants + 6 behavior flags (Looped, BlendableCycle, Interruptable, MovementSync, OneShot, PreserveAtEnd). 5 behavior tiers. CLI: --gen-animations (5 essentials), --gen-animations-combat (8 weapon-typed attacks + parry + channel), --gen-animations-movement (6 locomotion anims with tier transitions). Validator catches id-uniqueness, fallback-self-loop, looped-without-duration, mutually-exclusive Looped+OneShot flags, weaponFlags=0 warning, and unresolved fallback warnings. Also extends --list-formats and --info-magic with WANI.
2026-05-09 19:19:13 -07:00
std::printf(" --gen-animations <wani-base> [name]\n");
std::printf(" Emit .wani starter: 5 essential animations (Stand / Walk / Run / Death / AttackUnarmed) with fallback chains\n");
std::printf(" --gen-animations-combat <wani-base> [name]\n");
std::printf(" Emit .wani 8 combat anims (1H/2H/dual-wield/bow/rifle/thrown + parry + channel) with weapon-flag bitmasks\n");
std::printf(" --gen-animations-movement <wani-base> [name]\n");
std::printf(" Emit .wani 6 movement anims (Walk/Run/Sprint/Swim/Mount/Fly) with behavior-tier transitions (default/aerial/swim)\n");
std::printf(" --info-wani <wani-base> [--json]\n");
std::printf(" Print WANI entries (id / tier / flags / weapon mask / loop duration / fallback / name)\n");
std::printf(" --validate-wani <wani-base> [--json]\n");
std::printf(" Static checks: id-unique, name not empty, tier 0..4, fallback != self, loop+oneshot exclusivity, looped requires duration\n");
feat(editor): add WANI JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the animation catalog format shipped last batch. --export-wani-json emits all 8 scalar fields plus a dual int + name form for behaviorTier so hand-edits can use either representation. --import-wani-json accepts either form, falling back to the int when both are present, and defaults weaponFlags to kWeaponAny when omitted to preserve compatibility with hand-authored sidecars that forget to specify it. Verified byte-identical round-trip on all three preset emitters (starter / combat / movement). 724 documented CLI flags.
2026-05-09 19:20:22 -07:00
std::printf(" --export-wani-json <wani-base> [out.json]\n");
std::printf(" Export binary .wani to a human-editable JSON sidecar (defaults to <base>.wani.json)\n");
std::printf(" --import-wani-json <json-path> [out-base]\n");
std::printf(" Import a .wani.json sidecar back into binary .wani (accepts behaviorTier int OR name string)\n");
feat(pipeline): add WSVK (Wowee Spell Visual Kit) catalog 47th open format — replaces SpellVisualKit.dbc + SpellVisualEffectName.dbc plus the AzerothCore-style spell visual SQL data. Defines per-spell visual presentations: cast-bar effect model, projectile model + travel speed + arc gravity, impact effect model, hand effect on the caster, and the animations + sounds that fire at cast / channel / impact time. Cross-references with prior formats — castAnimId / impactAnimId / precastAnimId point at WANI.animationId, castSoundId / impactSoundId point at WSND.soundId. Spell catalogs (WSPL) will reference visualKitId here to bind "what mechanically happens" to "what plays visually." CLI: --gen-svk (3-kit Frostbolt/Fireball/HealingTouch starter showing projectile + AoE + heal patterns), --gen-svk-combat (5 melee/ranged with WANI animation refs), --gen-svk-utility (4 portal/hearth/mount/resurrect with no projectile), --info-wsvk, --validate-wsvk with --json variants. Validator catches id=0/duplicates, missing name, negative speeds/radii, projectile-model + speed coherence (model without speed = never travels; speed without model = invisible), and a no-effect catch-all (no models + no anims + no sounds).
2026-05-09 19:23:36 -07:00
std::printf(" --gen-svk <wsvk-base> [name]\n");
std::printf(" Emit .wsvk starter: 3 visual kits (Frostbolt / Fireball / HealingTouch) with projectile + impact + hand effects\n");
std::printf(" --gen-svk-combat <wsvk-base> [name]\n");
std::printf(" Emit .wsvk 5 combat visuals (sword/arrow/groundpound/parry/deflect) with WANI animation cross-refs\n");
std::printf(" --gen-svk-utility <wsvk-base> [name]\n");
std::printf(" Emit .wsvk 4 utility visuals (portal/hearthstone/mount-summon/resurrect) with no projectile\n");
std::printf(" --info-wsvk <wsvk-base> [--json]\n");
std::printf(" Print WSVK entries (id / cast+impact anim IDs / projectile speed+gravity / cast duration / AoE radius / sounds / name)\n");
std::printf(" --validate-wsvk <wsvk-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, no negative speeds/radii, projectile-model + speed coherence, no-effect warning\n");
feat(editor): add WSVK JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the spell visual kit catalog format shipped this batch. --export-wsvk-json emits all 12 scalar fields and 4 model-path strings. WSVK has no enum fields, so the JSON mapping is a straight-through dump with no name-form widening. --import-wsvk-json parses it back, defaulting unset fields to 0/empty. Verified byte-identical round-trip on all three preset emitters (starter / combat / utility). 731 documented CLI flags.
2026-05-09 19:24:37 -07:00
std::printf(" --export-wsvk-json <wsvk-base> [out.json]\n");
std::printf(" Export binary .wsvk to a human-editable JSON sidecar (defaults to <base>.wsvk.json)\n");
std::printf(" --import-wsvk-json <json-path> [out-base]\n");
std::printf(" Import a .wsvk.json sidecar back into binary .wsvk\n");
feat(pipeline): add WWUI (Wowee World-State UI) catalog 48th open format — replaces WorldStateUI.dbc plus the AzerothCore-style world_state SQL data. Defines on-screen UI elements that surface server-side world-state variables: BG scoreboards (flag captures, base controls), Wintergrasp tank counters, Eye of the Storm flag-carrier indicator, dungeon boss progress, world-event collection trackers. Each entry binds a server-side variableIndex to a UI panel kind (counter / timer / flag-icon / progress-bar / two-sided score / custom) gated by mapId+areaId, with optional alwaysVisible and hideWhenZero flags and a chosen panel position (top / bottom / top-left / top-right / center). Cross-references with prior formats — mapId points at WMS.mapId and areaId points at WMS.areaId. CLI: --gen-wsui (3-entry BG scoreboard starter for WSG/AB/ EotS), --gen-wsui-wintergrasp (4-entry full Wintergrasp UI), --gen-wsui-dungeon (3-entry boss/keys/treasure hunt UI), --info-wwui, --validate-wwui with --json variants. Validator catches id=0/duplicates, kind/position out of range, variableIndex=0 warning, alwaysVisible+hideWhenZero conflict warning, and (mapId, variableIndex) collision warning when two entries would read the same server slot on the same map. Also extends --list-formats and --info-magic with WWUI.
2026-05-09 19:32:15 -07:00
std::printf(" --gen-wsui <wwui-base> [name]\n");
std::printf(" Emit .wwui starter: 3 BG scoreboards (WSG flag captures, AB resources, EotS flag carrier)\n");
std::printf(" --gen-wsui-wintergrasp <wwui-base> [name]\n");
std::printf(" Emit .wwui 4 Wintergrasp UI (alliance+horde tank counts, time remaining, towers controlled)\n");
std::printf(" --gen-wsui-dungeon <wwui-base> [name]\n");
std::printf(" Emit .wwui 3 dungeon UI (boss progress bar, key fragments collected, treasure hunt counter)\n");
std::printf(" --info-wwui <wwui-base> [--json]\n");
std::printf(" Print WWUI entries (id / kind / panel position / always-visible / hide-when-zero / map+area / variableIndex / default / name)\n");
std::printf(" --validate-wwui <wwui-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, kind 0..5, position 0..4, alwaysVis+hideZero conflict, (mapId, varIdx) collision warning\n");
feat(editor): add WWUI JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the world-state UI catalog format shipped last batch. --export-wwui-json emits all 11 scalar fields plus dual int + name forms for displayKind and panelPosition so hand-edits can use either representation. --import-wwui-json accepts either form, falling back to the int when both are present, and defaults iconColorRGBA to 0xFFFFFFFF (opaque white) when omitted. Verified byte-identical round-trip on all three preset emitters (starter / wintergrasp / dungeon). 740 documented CLI flags.
2026-05-09 19:33:37 -07:00
std::printf(" --export-wwui-json <wwui-base> [out.json]\n");
std::printf(" Export binary .wwui to a human-editable JSON sidecar (defaults to <base>.wwui.json)\n");
std::printf(" --import-wwui-json <json-path> [out-base]\n");
std::printf(" Import a .wwui.json sidecar back into binary .wwui (accepts displayKind/panelPosition int OR name string)\n");
feat(pipeline): add WPCN (Wowee Player Condition) catalog 49th open format — replaces PlayerCondition.dbc plus the AzerothCore-style condition resolver. Defines reusable boolean checks that other catalogs reference by conditionId to gate gossip options, vendor items, quest availability, achievement criteria, spell trainer offerings. 16 condition kinds (Always, Race, Class, Level, Zone, Map, Reputation, AchievementWon, QuestComplete, QuestActive, SpellKnown, ItemEquipped, Faction, InCombat, Mounted, Resting), 8 comparison ops (==, !=, >, >=, <, <=, in-set, not-in-set), and 4 chain ops (none, and, or, not) — chain multiple conditions via chainNextId to express arbitrary boolean trees. Cross-references with prior formats — targetIdA is polymorphic by conditionKind: resolves to WCHC raceId/classId, WMS areaId/mapId, WFAC factionId, WACH achievementId, WQT questId, WSPL spellId, or WIT itemId. chainNextId resolves within the same WPCN catalog. CLI: --gen-pcn (3 single-check starters), --gen-pcn-quest-gates (4 cross-format quest gates with real WQT/WFAC/WACH/WMS IDs), --gen-pcn-composite (3 leaves + 3 chained roots showing AND/ OR/NOT). Validator catches id=0/duplicates, kind/op out of range, chain self-loop (infinite recursion), chainOp set without chainNextId (dangling chain), chainNextId set without chainOp (dead pointer warning), and unresolved chainNextId references.
2026-05-09 19:36:56 -07:00
std::printf(" --gen-pcn <wpcn-base> [name]\n");
std::printf(" Emit .wpcn starter: 3 single-check conditions (level>=60 / race=Human / class=Warrior)\n");
std::printf(" --gen-pcn-quest-gates <wpcn-base> [name]\n");
std::printf(" Emit .wpcn 4 quest-style gates (quest complete, reputation, achievement, zone presence) with cross-refs\n");
std::printf(" --gen-pcn-composite <wpcn-base> [name]\n");
std::printf(" Emit .wpcn 6 entries (3 leaves + 3 chained roots) exercising AND/OR/NOT chainOps for boolean trees\n");
std::printf(" --info-wpcn <wpcn-base> [--json]\n");
std::printf(" Print WPCN entries (id / kind / op / target IDs / int values / chainOp / chainNextId / name)\n");
std::printf(" --validate-wpcn <wpcn-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, kind 0..15, op 0..7, chainOp 0..3, chain self-loop, dangling chainNextId warning\n");
feat(editor): add WPCN JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the player condition catalog format shipped this batch. --export-wpcn-json emits all 11 scalar fields plus dual int + name forms for conditionKind / comparisonOp / chainOp so hand-edits can use either representation. --import-wpcn-json accepts either form, falling back to the int when both are present. Verified byte-identical round-trip on all three preset emitters (starter / quest-gates / composite — including chained conditions referencing other entries by chainNextId). 747 documented CLI flags.
2026-05-09 19:38:06 -07:00
std::printf(" --export-wpcn-json <wpcn-base> [out.json]\n");
std::printf(" Export binary .wpcn to a human-editable JSON sidecar (defaults to <base>.wpcn.json)\n");
std::printf(" --import-wpcn-json <json-path> [out-base]\n");
std::printf(" Import a .wpcn.json sidecar back into binary .wpcn (accepts conditionKind/comparisonOp/chainOp int OR name string)\n");
feat(pipeline): add WTSK (Wowee Trade Skill / Recipe) catalog New open format — replaces SkillLineAbility.dbc plus the recipe portions of SkillLine.dbc plus the AzerothCore trade_skill SQL tables. Closes the crafting gap left by WSKL (which carries skill lines but not the recipes that bind to them). 14 professions (Blacksmithing, Tailoring, Engineering, Alchemy, Enchanting, Leatherworking, Jewelcrafting, Inscription, Mining, Skinning, Herbalism, Cooking, FirstAid, Fishing). Each recipe has 4 skill-up bracket thresholds (orange / yellow / green / gray) for skill-up probability, a craft spell cross-ref (WSPL), produced item cross-ref (WIT) with min/max quantity range, an optional tool item, and up to 4 reagent slots (itemId + count). Cross-references with prior formats — craftSpellId points at WSPL.spellId, producedItemId / toolItemId / reagent[].itemId all point at WIT.itemId, and skillId points at WSKL.skillId. CLI: --gen-tsk (3-recipe entry-tier starter), --gen-tsk- blacksmithing (5-recipe progression rough sharpening through truesilver champion), --gen-tsk-alchemy (5-recipe progression minor healing through flask of titans), --info-wtsk, --validate-wtsk with --json variants. Validator catches id=0/duplicates, profession out of range, missing craft spell or produced item, monotonic-bracket check (must be orange <= yellow <= green <= gray), reagent itemId-without-count mismatch, and free-recipe warning (no reagents and no tool). Format graph now exposes 49 distinct binary formats. CLI flag count: 747 → 752.
2026-05-09 19:41:49 -07:00
std::printf(" --gen-tsk <wtsk-base> [name]\n");
std::printf(" Emit .wtsk starter: 3 entry-tier recipes (Coarse Sharpening Stone / Linen Bandage / Minor Healing Potion)\n");
std::printf(" --gen-tsk-blacksmithing <wtsk-base> [name]\n");
std::printf(" Emit .wtsk 5-recipe Blacksmithing progression (rough sharpening → truesilver champion plate)\n");
std::printf(" --gen-tsk-alchemy <wtsk-base> [name]\n");
std::printf(" Emit .wtsk 5-recipe Alchemy progression (minor healing → flask of titans) with reagent slots\n");
std::printf(" --info-wtsk <wtsk-base> [--json]\n");
std::printf(" Print WTSK entries (id / profession / 4 skill brackets / craft spell / produced item / qty / tool / reagent count / name)\n");
std::printf(" --validate-wtsk <wtsk-base> [--json]\n");
std::printf(" Static checks: id>0+unique, name not empty, profession 0..13, craft spell + produced item required, monotonic skill brackets\n");
feat(editor): add WTSK JSON round-trip (export/import sidecar) Closes the JSON round-trip gap on the trade skill recipe catalog format shipped last batch. --export-wtsk-json emits all 14 scalar fields plus a dual int + name form for profession, plus a nested reagents[] array — only non-empty slots are emitted to keep hand-edits compact. --import-wtsk-json zeroes the reagent slots before parsing (so a 2-element reagents array correctly clears slots 2 and 3) and accepts profession by either int or name. Verified byte-identical round-trip on all three preset emitters (starter / blacksmithing / alchemy — including recipes with 3 reagent slots populated). 754 documented CLI flags.
2026-05-09 19:43:16 -07:00
std::printf(" --export-wtsk-json <wtsk-base> [out.json]\n");
std::printf(" Export binary .wtsk to a human-editable JSON sidecar with nested reagents (defaults to <base>.wtsk.json)\n");
std::printf(" --import-wtsk-json <json-path> [out-base]\n");
std::printf(" Import a .wtsk.json sidecar back into binary .wtsk (accepts profession int OR name string, reagents array up to 4 slots)\n");
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
std::printf(" --gen-weather-temperate <wow-base> [zoneName]\n");
std::printf(" Emit .wow weather schedule: clear-dominant + occasional rain + fog (forest / grassland)\n");
std::printf(" --gen-weather-arctic <wow-base> [zoneName]\n");
std::printf(" Emit .wow weather schedule: snow-dominant + blizzard + fog (tundra / glacier)\n");
std::printf(" --gen-weather-desert <wow-base> [zoneName]\n");
std::printf(" Emit .wow weather schedule: clear-dominant + sandstorm (dunes / wasteland)\n");
std::printf(" --gen-weather-stormy <wow-base> [zoneName]\n");
std::printf(" Emit .wow weather schedule: heavy rain + storm + occasional clear (coastal / monsoon)\n");
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
std::printf(" --gen-zone-atmosphere <zoneDir> [--name <zoneName>] [--preset default|arctic|desert|stormy|cave]\n");
std::printf(" Convenience: drop both atmosphere.wol + atmosphere.wow into <zoneDir> using a paired light/weather preset\n");
refactor(editor): extract printUsage into cli_help.cpp Pulls the 597-line block of printf calls that emits the --help text out of main.cpp into its own translation unit. printUsage is the longest single function in main.cpp by far and was pure boilerplate (no logic, just a flat list of help lines). Function moved verbatim to wowee::editor::cli::printUsage; all 6 in-tree callers (--list-commands, --info-cli-stats, --info-cli-categories, --info-cli-help, --validate-cli-help, and the bare --help/-h handler) updated to the namespaced name. The CLI-meta commands continue to capture printUsage's stdout the same way, so behavior is identical (verified by re-running --validate-cli-help, --info-cli-stats, --list-commands). main.cpp drops 26,650 → 26,286 lines (-364 net; -597 from the removal, +233 from the include and namespace-prefixing the six call sites... wait, no, +6). Actually main.cpp net delta matches the body extraction.
2026-05-08 20:12:15 -07:00
std::printf(" --info-wot <wot-base> [--json]\n");
std::printf(" Print WOT/WHM terrain metadata (tile, chunks, height range) and exit\n");
std::printf(" --info-extract <dir> [--json]\n");
std::printf(" Walk extracted asset tree and report open-format coverage and exit\n");
std::printf(" --info-extract-tree <dir>\n");
std::printf(" Hierarchical view of an extracted asset tree grouped by top-level dir + format\n");
std::printf(" --info-extract-budget <dir> [--json]\n");
std::printf(" Per-extension byte breakdown of an extract dir (sized largest-first)\n");
std::printf(" --info-png <path> [--json]\n");
std::printf(" Print PNG header (width, height, channels, bit depth) and exit\n");
std::printf(" --info-blp <path> [--json]\n");
std::printf(" Print BLP texture header (format, compression, mips, dimensions) and exit\n");
std::printf(" --info-m2 <path> [--json]\n");
std::printf(" Print proprietary M2 model metadata (verts, bones, anims, particles)\n");
std::printf(" --info-wmo <path> [--json]\n");
std::printf(" Print proprietary WMO building metadata (groups, portals, doodads)\n");
std::printf(" --info-adt <path> [--json]\n");
std::printf(" Print proprietary ADT terrain metadata (chunks, placements, textures)\n");
std::printf(" --info-jsondbc <path> [--json]\n");
std::printf(" Print JSON DBC sidecar metadata (records, fields, source) and exit\n");
std::printf(" --list-missing-sidecars <dir> [--json]\n");
std::printf(" List proprietary files lacking open-format sidecars (one per line)\n");
std::printf(" --info-zone <dir|json> [--json]\n");
std::printf(" Print zone.json fields (manifest, tiles, audio, flags) and exit\n");
std::printf(" --info-zone-overview <zoneDir> [--json]\n");
std::printf(" One-line compact zone summary (tiles, biome, counts, audio status)\n");
std::printf(" --info-project-overview <projectDir> [--json]\n");
std::printf(" One-line summary per zone in a project (single-page health check)\n");
std::printf(" --copy-project <fromDir> <toDir>\n");
std::printf(" Recursively copy a project tree (every zone subdir + manifests)\n");
std::printf(" --info-creatures <p> [--json]\n");
std::printf(" Print creatures.json summary (counts, behaviors) and exit\n");
std::printf(" --info-creatures-by-faction <p> [--json]\n");
std::printf(" Histogram of creature counts grouped by faction id\n");
std::printf(" --info-creatures-by-level <p> [--json]\n");
std::printf(" Distribution of creature levels (min/max/avg + per-level counts)\n");
std::printf(" --info-objects-by-path <p> [--json]\n");
std::printf(" Histogram of object placements grouped by model path (most-used first)\n");
std::printf(" --info-objects-by-type <p> [--json]\n");
std::printf(" M2 vs WMO breakdown plus scale distribution (min/max/avg)\n");
std::printf(" --info-objects <p> [--json]\n");
std::printf(" Print objects.json summary (counts, types, scale range) and exit\n");
std::printf(" --info-quests <p> [--json]\n");
std::printf(" Print quests.json summary (counts, rewards, chain errors) and exit\n");
std::printf(" --info-quests-by-level <p> [--json]\n");
std::printf(" Distribution of required levels across quests (min/max/avg + bar chart)\n");
std::printf(" --info-quests-by-xp <p> [--json]\n");
std::printf(" Distribution of XP rewards (min/max/avg + per-bucket histogram)\n");
std::printf(" --list-creatures <p> [--json]\n");
std::printf(" List every creature with index, name, position, level (for --remove-creature)\n");
std::printf(" --list-objects <p> [--json]\n");
std::printf(" List every object with index, type, path, position\n");
std::printf(" --list-quests <p> [--json]\n");
std::printf(" List every quest with index, title, giver, XP\n");
std::printf(" --list-quest-objectives <p> <questIdx> [--json]\n");
std::printf(" List every objective on a quest (for --remove-quest-objective)\n");
std::printf(" --list-quest-rewards <p> <questIdx> [--json]\n");
std::printf(" List XP/coin/item rewards on a quest\n");
std::printf(" --info-quest-graph-stats <p> [--json]\n");
std::printf(" Analyze quest chain graph (roots, leaves, depths, cycles, orphans)\n");
std::printf(" --info-creature <p> <idx> [--json]\n");
std::printf(" Print every field for one creature spawn (stats, behavior, AI, flags)\n");
std::printf(" --info-quest <p> <idx> [--json]\n");
std::printf(" Print every field for one quest (objectives + reward + chain in one shot)\n");
std::printf(" --info-object <p> <idx> [--json]\n");
std::printf(" Print every field for one object placement (type, path, transform)\n");
std::printf(" --info-wcp <wcp-path> [--json]\n");
std::printf(" Print WCP archive metadata (name, files) and exit\n");
std::printf(" --info-pack-budget <wcp-path> [--json]\n");
std::printf(" Per-extension byte breakdown of a WCP archive (sized largest-first)\n");
std::printf(" --info-pack-tree <wcp-path>\n");
std::printf(" Render a tree view of a WCP's directory structure with byte sizes\n");
std::printf(" --list-wcp <wcp-path> Print every file inside a WCP archive (sorted by path) and exit\n");
std::printf(" --diff-wcp <a> <b> [--json]\n");
std::printf(" Compare two WCPs file-by-file; exit 0 if identical, 1 otherwise\n");
std::printf(" --diff-zone <a> <b> [--json]\n");
std::printf(" Compare two zone dirs (creatures/objects/quests/manifest); exit 0 if identical\n");
std::printf(" --diff-glb <a> <b> [--json]\n");
std::printf(" Compare two glTF 2.0 binaries structurally; exit 0 if identical\n");
std::printf(" --diff-wom <a-base> <b-base> [--json]\n");
std::printf(" Compare two WOM models (verts, indices, bones, anims, batches, bounds)\n");
std::printf(" --diff-wob <a-base> <b-base> [--json]\n");
std::printf(" Compare two WOB buildings (groups, portals, doodads, totals)\n");
std::printf(" --diff-whm <a-base> <b-base> [--json]\n");
std::printf(" Compare two WHM/WOT terrain pairs (chunks, height range, placements)\n");
std::printf(" --diff-woc <a> <b> [--json]\n");
std::printf(" Compare two WOC collision meshes (triangles, walkable/steep counts, tile)\n");
std::printf(" --diff-jsondbc <a> <b> [--json]\n");
std::printf(" Compare two JSON DBC sidecars (format/source/recordCount/fieldCount)\n");
std::printf(" --diff-extract <a> <b> [--json]\n");
std::printf(" Compare two extracted asset directories (per-extension file count + bytes)\n");
std::printf(" --diff-checksum <a> <b> [--json]\n");
std::printf(" Diff two SHA256SUMS files; report added/removed/changed entries\n");
std::printf(" --pack-wcp <zone> [dst] Pack a zone dir/name into a .wcp archive and exit\n");
std::printf(" --unpack-wcp <wcp> [dst] Extract a WCP archive (default dst=custom_zones/) and exit\n");
std::printf(" --list-commands Print every recognized --flag, one per line, and exit\n");
feat(editor): add --list-primitives focused introspection Filtered subset of --list-commands: just procedural primitive flags (--gen-mesh-* and --gen-texture-*). Walks the shared kArgRequired registry so it auto-tracks new primitives as they land — no parallel list to maintain. Useful when authoring content packs to discover what's available without scrolling through the full --help dump. Flags: --mesh — show only --gen-mesh-* (default: both) --texture — show only --gen-texture-* (default: both) --json — JSON output with meshCount/textureCount totals Currently surfaces 70 procedural mesh primitives and 62 procedural texture primitives. JSON form is well-suited for piping into sortable / searchable UIs (e.g. content-pack authoring tools).
2026-05-09 12:25:51 -07:00
std::printf(" --list-primitives [--mesh|--texture] [--json]\n");
std::printf(" Filtered list of just procedural primitive flags (--gen-mesh-*, --gen-texture-*)\n");
feat(editor): add --list-packs introspection + --gen-temple-pack Two related changes: • --list-packs walks kArgRequired and surfaces every flag matching --gen-*-pack (excluding --gen-mesh-* and --gen-texture-* which are individual primitives). Sister command to --list-primitives. Auto-tracks new packs as they're added — no parallel registry. • --gen-temple-pack composite — temple/shrine ritual hall (altar + shrine + brazier + pillar + statue + portal + podium). Fourth themed mesh pack after camp / blacksmith / village. list-packs now surfaces 9 composites including the pre- existing zone-* / project-starter packs that match the naming convention. All 7 temple-pack outputs validate clean.
2026-05-09 12:51:10 -07:00
std::printf(" --list-packs Print every --gen-*-pack composite flag (camp, blacksmith, village, temple…)\n");
refactor(editor): extract printUsage into cli_help.cpp Pulls the 597-line block of printf calls that emits the --help text out of main.cpp into its own translation unit. printUsage is the longest single function in main.cpp by far and was pure boilerplate (no logic, just a flat list of help lines). Function moved verbatim to wowee::editor::cli::printUsage; all 6 in-tree callers (--list-commands, --info-cli-stats, --info-cli-categories, --info-cli-help, --validate-cli-help, and the bare --help/-h handler) updated to the namespaced name. The CLI-meta commands continue to capture printUsage's stdout the same way, so behavior is identical (verified by re-running --validate-cli-help, --info-cli-stats, --list-commands). main.cpp drops 26,650 → 26,286 lines (-364 net; -597 from the removal, +233 from the include and namespace-prefixing the six call sites... wait, no, +6). Actually main.cpp net delta matches the body extraction.
2026-05-08 20:12:15 -07:00
std::printf(" --info-cli-stats [--json]\n");
std::printf(" Meta-stats on the CLI surface (command count by category prefix)\n");
std::printf(" --info-cli-categories\n");
std::printf(" Group every --flag by verb prefix (gen/info/list/...) for discovery\n");
std::printf(" --info-cli-help <pattern>\n");
std::printf(" Substring-search the help text and print matching command lines\n");
std::printf(" --validate-cli-help [--json]\n");
std::printf(" Self-check: every kArgRequired flag must appear in the help text\n");
std::printf(" --gen-completion <bash|zsh>\n");
std::printf(" Print a shell-completion script for wowee_editor (source it from your rc file)\n");
std::printf(" --version Show version and format info\n\n");
std::printf("Wowee World Editor v1.0.0 — by Kelsi Davis\n");
std::printf("Novel open formats: WOT/WHM/WOM/WOB/WOC/WCP + PNG/JSON\n");
}
} // namespace cli
} // namespace editor
} // namespace wowee
Reference in a new issue Copy permalink