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

3435 lines
167 KiB
C++
Raw Normal View History

feat(editor): add standalone world editor (rough/WIP) Standalone wowee_editor tool for creating custom WoW zones. This is a rough initial implementation — many features work but M2/WMO rendering still has issues (frame sync, texture layout transitions) and needs further polish. Terrain: - Create new blank terrain with 10 biome types (Grassland, Forest, Jungle, Desert, Barrens, Snow, Swamp, Rocky, Beach, Volcanic) - Load existing ADT tiles from extracted game data - Sculpt brushes: Raise, Lower, Smooth, Flatten, Level - Chunk edge stitching prevents seams between tiles - Undo/redo (100-deep stack, Ctrl+Z/Ctrl+Shift+Z) - Save to WoW ADT/WDT format Texture Painting: - Paint/Erase/Replace Base modes - Full tileset texture browser (1285 textures from manifest) - Per-zone directory filtering and search - Alpha map editing with 4-layer limit (auto-replaces weakest) Object Placement: - M2 and WMO model placement with full manifest browser (11k M2s, 2k WMOs) - M2Renderer + WMORenderer integrated (loads .skin files for WotLK) - Ghost preview follows cursor before placing - Ctrl+click selection, right-click context menu - Transform gizmo (Move/Rotate/Scale with axis constraints) - Position/rotation/scale editing in properties panel NPC/Monster System: - 631 creature presets scanned from manifest, categorized (Critters, Beasts, Humanoids, Undead, Demons, etc.) - Stats editor: level, health, mana, damage, armor, faction - Behavior: Stationary, Patrol, Wander, Scripted - Aggro/leash radius, respawn time, flags (hostile/vendor/etc.) - Save creature spawns to JSON Water: - Place water at configurable height per chunk - Liquid types: Water, Ocean, Magma, Slime - Rendered as translucent colored quads - Saved in ADT MH2O format Infrastructure: - Free-fly camera (WASD/QE, right-drag look, scroll speed) - 5-mode toolbar: Sculpt | Paint | Objects | Water | NPCs - Asset browser indexes full manifest on startup - Editor water/marker shaders (pos+color vertex format) - forceNoCull added to M2Renderer for editor use - AssetManifest::getEntries() and AssetManager::getManifest() exposed Known issues: - M2/WMO rendering may not display on first placement (frame index sync between update/render was misaligned — now fixed but untested end-to-end) - Validation layer errors on shutdown (resource cleanup ordering) - Object placement on steep terrain can miss raycast - No undo for texture painting or object placement yet
2026-05-05 03:47:03 -07:00
#include "editor_app.hpp"
refactor(editor): extract gen-audio-* handlers into cli_gen_audio.cpp main.cpp had grown past 28k lines, with each new procedural- generation command adding 100-200 lines to the inline if/else dispatch chain. This commit starts breaking that up by moving the four audio-related handlers (--gen-audio-tone, -noise, -sweep, --gen-zone-audio-pack) into their own translation unit. Pattern established here for future family extractions: - Family lives in cli_<family>.{hpp,cpp} - Single dispatch entry point: bool handle<Family>(int& i, int argc, char** argv, int& outRc) — true if matched (writes outRc), false to fall through. - main.cpp's argv loop calls each family's dispatcher first and returns its outRc on match, before the legacy in-line chain. Side-benefit: consolidated the duplicated 25-line WAV header writer + 5ms attack/release envelope into shared helpers (writeWavMono16, applyEdgeEnvelope) at the top of the new file. main.cpp drops from 28,943 → 28,329 lines (-614). Audio family is fully self-contained (~440 lines), behavior unchanged (verified by re-running tone/noise/sweep + zone-audio-pack).
2026-05-08 16:19:30 -07:00
#include "cli_gen_audio.hpp"
refactor(editor): extract zone-pack orchestrators into cli_zone_packs.cpp Continues the modularization started in 6c9ab6fa. Moves the four pack-orchestrator handlers (--gen-zone-texture-pack, -mesh-pack, -starter-pack, --gen-project-starter-pack) into their own file following the same handle<Family> pattern. Side cleanup: - Consolidated the duplicated --seed flag parser into a single parseSeedFlag helper - Consolidated the std::system + > /dev/null wrap into runSilently main.cpp drops 28,329 → 28,070 lines (-259). Pack family is fully self-contained (~260 lines), behavior unchanged (verified by re-running gen-zone-starter-pack and confirming 6 PNGs + 5 WOMs).
2026-05-08 16:46:14 -07:00
#include "cli_zone_packs.hpp"
refactor(editor): extract audit family into cli_audits.cpp Continues the modularization. Moves the four audit handlers (--validate-zone-pack, --validate-project-packs, --info-zone-deps, --info-project-deps) into their own file using the same handle<Family>(int& i, int argc, char** argv, int& outRc) pattern. Side-cleanup: the two project-scope audits had identical subprocess-fanout structure (enumerate zones → run per-zone command → tally PASS/FAIL → print summary). Consolidated that into a shared runPerZoneAudit helper. Saves ~80 lines of duplicated dispatch code. main.cpp drops 28,070 → 27,736 lines (-334). Audit family is fully self-contained (~330 lines), behavior unchanged (verified all 4 commands against existing test zones).
2026-05-08 17:12:10 -07:00
#include "cli_audits.hpp"
refactor(editor): extract README generators into cli_readmes.cpp Continues the modularization. Moves --gen-zone-readme and --gen-project-readme into their own translation unit using the established handle<Family> dispatch pattern. Consolidated the trailing --out flag parser into a single parseOutFlag helper (was duplicated between the two handlers). main.cpp drops 27,736 → 27,445 lines (-291). Behavior unchanged (verified by re-generating README and PROJECT.md, contents identical to pre-refactor output).
2026-05-08 17:36:10 -07:00
#include "cli_readmes.hpp"
refactor(editor): extract per-zone inventory into cli_zone_inventory.cpp Continues the modularization. Moves the four per-zone inventory handlers into their own file: --list-zone-meshes (WOM stats) --list-zone-audio (WAV header parse) --list-zone-textures (texture-ref histogram) --info-zone-summary (BOOTSTRAPPED/PARTIAL/EMPTY status) Each consumes a trailing --json flag the same way; consolidated that check into a consumeJsonFlag helper at the top. main.cpp drops 27,445 → 27,200 lines (-245). Per-zone inventory behavior unchanged (re-verified all 4 commands). A pre-existing duplicate --list-zone-meshes handler (the older detailed per-mesh listing, similar to the --list-project-meshes collision fixed in 976549fe) is now dead code in the in-line chain since the extracted module dispatches first. Will rename or remove that duplicate in a follow-up cleanup.
2026-05-08 18:24:01 -07:00
#include "cli_zone_inventory.hpp"
refactor(editor): extract project inventory into cli_project_inventory.cpp Pairs with the per-zone inventory module from c0f2ab75. Moves the five project-wide inventory handlers into their own file: --list-project-meshes (per-zone WOM aggregate) --list-project-meshes-detail (per-mesh sorted listing) --list-project-audio (per-zone WAV aggregate) --list-project-textures (per-zone + global texture refs) --info-project-summary (BOOTSTRAPPED/PARTIAL/EMPTY rollup) All five enumerate zones the same way; consolidated that into a shared enumerateZones() helper at file scope. main.cpp drops 27,200 → 26,650 lines (-550). Behavior unchanged across all 5 commands (verified against /tmp/proj_starter).
2026-05-08 18:47:06 -07:00
#include "cli_project_inventory.hpp"
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"
refactor(editor): extract 7 newer texture generators into cli_gen_texture.cpp Moves the Worley/cellular-noise-based texture handlers (--gen-texture-cobble, -marble, -metal, -leather, -sand, -snow, -lava) into their own translation unit. Each handler previously had its own ~33-line copy of the parseHex lambda; all 7 copies are replaced with a single shared parseHex helper at file scope. Older simpler generators (gradient/noise/radial/stripes/dots/ rings/checker/brick/wood/grass/fabric) still live in main.cpp and will be migrated in subsequent batches. main.cpp drops 26,286 → 25,494 lines (-792). Behavior unchanged across all 7 handlers (re-verified).
2026-05-08 20:59:02 -07:00
#include "cli_gen_texture.hpp"
refactor(editor): extract 12 composite mesh primitives into cli_gen_mesh.cpp Moves the recently-added composite-prop mesh handlers (rock, pillar, bridge, tower, house, fountain, statue, altar, portal, archway, barrel, chest) into their own translation unit. These 12 handlers were the most contiguous block of similar-shaped mesh code in main.cpp. Other mesh handlers (--gen-mesh dispatcher, fence, tree, grid, stairs, disc, tube, capsule, arch, pyramid, from-heightmap, textured) still live in main.cpp and may be migrated in subsequent batches. main.cpp drops 24,270 → 22,681 lines (-1,589). Behavior verified by re-running rock/chest/archway/fountain.
2026-05-08 22:19:41 -07:00
#include "cli_gen_mesh.hpp"
refactor(editor): extract mesh ⇄ heightmap I/O into cli_mesh_io.cpp Moves the three mesh-PNG bridge handlers (--displace-mesh, --gen-mesh-from-heightmap, --export-mesh-heightmap) out of main.cpp into their own translation unit. These three are distinct from the gen-mesh-* primitive generators in that they read or write external image files rather than synthesize geometry from parameters alone. main.cpp drops 21,061 → 20,741 lines (-320). Behavior verified by re-running gen-mesh-from-heightmap → validate-wom → and displace-mesh on a fresh plane.
2026-05-09 00:04:27 -07:00
#include "cli_mesh_io.hpp"
refactor(editor): extract 10 mesh edit ops into cli_mesh_edit.cpp Moves the WOM mesh editing/transform handlers out of main.cpp: --add-texture-to-mesh --scale-mesh --translate-mesh --strip-mesh --rotate-mesh --center-mesh --flip-mesh-normals --mirror-mesh --smooth-mesh-normals --merge-meshes These are the post-generation manipulators (load → mutate → save) distinct from the geometry generators in cli_gen_mesh.cpp and the heightmap I/O in cli_mesh_io.cpp. main.cpp drops 20,741 → 20,005 lines (-736). Behavior verified by piping a fresh cube through scale → translate → center.
2026-05-09 00:36:51 -07:00
#include "cli_mesh_edit.hpp"
refactor(editor): extract WOM info handlers into cli_wom_info.cpp Moves the WOM model inspection commands out of main.cpp: --info (bare WOM summary) --info-batches (per-batch material info) --info-textures (texture path list) --info-doodads (WOB doodad set / instance list) --info-attachments ⎫ combined handler with same M2 load + --info-particles ⎬ skin merge but different sub-array --info-sequences ⎭ iteration --info-bones (bone hierarchy) --export-bones-dot (Graphviz DOT output) main.cpp drops 20,005 → 19,446 lines (-559). Behavior verified by running --info, --info-batches, --info-textures on a fresh WOM. Build error during extraction (combined-or handler header spanned 4 lines, the transform script only stripped the first; also missing #include for WoweeBuildingLoader) caught by build and fixed before commit.
2026-05-09 01:18:09 -07:00
#include "cli_wom_info.hpp"
refactor(editor): extract format validation into cli_format_validate.cpp Moves the open-format validation + project-audit handlers out of main.cpp: --validate --validate-wom --validate-wob --validate-woc --validate-whm --validate-all --validate-project --validate-project-open-only --audit-project --bench-audit-project --bench-validate-project Also moves the four shared validate*Errors helpers (validateWom/ Wob/Woc/WhmErrors, ~365 lines) into the same module's anonymous namespace — they were file-scope helpers in main.cpp used only by these handlers, so co-locating eliminates the cross-TU coupling. main.cpp drops 19,446 → 18,396 lines (-1,050). Two build errors caught during extraction (wrong include path for the WHM loader header; missing #include for ContentPacker / std::set / std::map); all fixed before commit.
2026-05-09 01:57:37 -07:00
#include "cli_format_validate.hpp"
refactor(editor): extract batch convert handlers into cli_convert.cpp Moves the four bulk format-conversion handlers out of main.cpp: --convert-m2-batch (M2 → WOM) --convert-wmo-batch (WMO → WOB) --convert-blp-batch (BLP → PNG) --convert-dbc-batch (DBC → JSON) These all share the same pattern: walk srcDir recursively for files of the input extension and fan out to the single-file --convert-* counterpart via subprocess (preserving the existing per-file logic as the source of truth, no duplication). Single-file converters (--convert-m2, --convert-wmo, etc.) and the --migrate-* meta-commands still live in main.cpp; they're in dedicated argv-rescan loops that need a different extraction approach. main.cpp drops 18,396 → 18,198 lines (-198). Behavior verified by re-running --convert-blp-batch with a missing directory and confirming the same error message.
2026-05-09 02:25:05 -07:00
#include "cli_convert.hpp"
refactor(editor): extract format inspection handlers into cli_format_info.cpp Moves the proprietary-format inspection commands out of main.cpp into their own translation unit. Each reads a Blizzard-format file and prints its structure: --info-png --info-blp --info-m2 --info-wmo --info-adt --info-jsondbc main.cpp drops 18,198 → 17,766 lines (-432). Behavior verified by re-running --info-png on a generated noise texture.
2026-05-09 02:48:58 -07:00
#include "cli_format_info.hpp"
refactor(editor): extract WCP pack handlers into cli_pack.cpp Moves the six WoWee Content Pack (.wcp) handlers out of main.cpp: --list-wcp --info-wcp --info-pack-budget --info-pack-tree --pack-wcp --unpack-wcp All six defer to wowee::editor::ContentPacker for actual pack I/O; the handlers just parse args and format output, so the extraction has no behavioral impact on the pack format itself. main.cpp drops 17,766 → 17,505 lines (-261). Behavior verified by re-running --info-wcp on a missing file (same error message).
2026-05-09 03:12:09 -07:00
#include "cli_pack.hpp"
refactor(editor): extract creature/object/quest info into cli_content_info.cpp Moves 16 contiguous content-inspection handlers out of main.cpp: --info-creatures --info-creatures-by-faction --info-creatures-by-level --info-objects-by-path --info-objects-by-type --info-quests-by-level --info-quests-by-xp --list-creatures --list-objects --list-quests --list-quest-objectives --list-quest-rewards --info-quest-graph-stats --info-creature --info-quest --info-object All read JSON sidecars (creatures.json, objects.json, quests.json) via wowee::editor::{NpcSpawner, ObjectPlacer, QuestEditor} loaders. main.cpp drops 17,505 → 16,564 lines (-941). Behavior verified by running --info-creatures (correctly fails with same parse- error message on a non-zone path).
2026-05-09 03:33:40 -07:00
#include "cli_content_info.hpp"
refactor(editor): extract zone/project metadata info into cli_zone_info.cpp Moves the three zone & project metadata inspection handlers out of main.cpp: --info-zone (single zone.json print) --info-zone-overview (high-level zone digest) --info-project-overview (per-zone summary table for a project) All three load zone.json via wowee::editor::ZoneManifest. main.cpp drops 16,564 → 16,321 lines (-243). Behavior verified by re-running --info-zone + --info-project-overview against existing test zones.
2026-05-09 03:52:44 -07:00
#include "cli_zone_info.hpp"
refactor(editor): extract data-tree audit/migration into cli_data_tree.cpp Moves the seven proprietary-data-tree handlers out of main.cpp: --migrate-data-tree --bench-migrate-data-tree --list-data-tree-largest --export-data-tree-md --info-data-tree --strip-data-tree --audit-data-tree All operate on a Blizzard-format extracted Data tree (the .m2/ .skin/.wmo/.blp/.dbc files) — they audit, migrate, or strip proprietary-format files in support of the open-format migration story. Original placement spanned two sub-blocks (12546-12892 and 13093-13417 in main.cpp) interrupted by --gen-texture and --add-texture-to-zone in the middle. Extraction collapses both sub-blocks into one cohesive translation unit. main.cpp drops 16,321 → 15,653 lines (-668). Behavior verified by re-running --info-data-tree against a missing directory.
2026-05-09 04:14:32 -07:00
#include "cli_data_tree.hpp"
refactor(editor): extract 10 diff handlers into cli_diff.cpp Moves the file-comparison handlers out of main.cpp into their own translation unit: --diff-wcp --diff-zone --diff-glb --diff-wom --diff-wob --diff-whm --diff-woc --diff-jsondbc --diff-extract --diff-checksum main.cpp drops 15,653 → 14,732 lines (-921). One build error during extraction (missing #include for NpcSpawner / ObjectPlacer / QuestEditor used by --diff-zone) caught by build and fixed.
2026-05-09 04:35:08 -07:00
#include "cli_diff.hpp"
refactor(editor): extract 8 spawn/snap handlers into cli_spawn_audit.cpp Moves the NPC spawn / object placer audit + ground-snap handlers out of main.cpp: --snap-zone-to-ground --snap-project-to-ground --audit-zone-spawns --audit-project-spawns --list-zone-spawns --list-project-spawns --diff-zone-spawns --info-spawn All operate on creatures.json + objects.json sidecars and the WHM terrain heightfield via WoweeTerrainLoader. main.cpp drops 14,628 → 13,887 lines (-741). Behavior verified by re-running --audit-zone-spawns on a test zone (PASSED with 0 issues, same as before).
2026-05-09 05:05:22 -07:00
#include "cli_spawn_audit.hpp"
refactor(editor): extract 5 item read-only handlers into cli_items.cpp Moves the items.json read-only inspection handlers out of main.cpp: --list-items --info-item --validate-items --validate-project-items --info-project-items Item editing handlers (--add-item, --set-item, --remove-item, --add-quest-reward-item) stay in main.cpp since they share state with quest reward editing logic and would need a broader extraction. main.cpp drops 13,887 → 13,485 lines (-402). Behavior verified by re-running --list-items on a non-items zone (same error message).
2026-05-09 05:19:04 -07:00
#include "cli_items.hpp"
refactor(editor): extract data-tree inspection into cli_extract_info.cpp Moves the four extracted-Data-tree audit handlers out of main: --info-extract (per-extension counts + bytes) --info-extract-tree (per-directory rollup) --info-extract-budget (proprietary share + open-format gap) --list-missing-sidecars (find unconverted .m2/.wmo/.blp/.dbc) All four operate on a Blizzard-format extracted Data tree — they audit what's there and what's missing in the migration from proprietary formats to open ones. main.cpp drops 13,485 → 13,120 lines (-365). Behavior verified by re-running --info-extract on a test zone (same output).
2026-05-09 05:32:27 -07:00
#include "cli_extract_info.hpp"
refactor(editor): extract 9 export handlers + sha256 helper into cli_export.cpp Moves the report-export handlers (md / csv / html / sha256 / graphviz) for zone & project audits out of main.cpp: --export-zone-summary-md --export-zone-csv --export-zone-checksum --export-project-checksum --validate-project-checksum --export-zone-html --export-project-html --export-project-md --export-quest-graph Also moves the file-scope wowee_sha256 namespace (the SHA-256 implementation that the checksum exporters use) into the new module's anonymous namespace — it had no other callers in main.cpp so no cross-TU coupling needed. main.cpp drops 13,120 → 12,119 lines (-1,001). Build error during extraction (missing #include <unordered_set>) caught and fixed.
2026-05-09 05:45:00 -07:00
#include "cli_export.hpp"
refactor(editor): extract zone/project mesh-bake handlers into cli_bake.cpp Moves the 3D-export bake handlers out of main.cpp: --bake-zone-glb --bake-zone-stl --bake-zone-obj --bake-project-obj --bake-project-stl --bake-project-glb The STL + GLB project bakes share a combined dispatcher (one function with internal STL-vs-GLB branching) since they walk the same per-zone asset list and only differ in the output emission code. main.cpp drops 12,119 → 11,261 lines (-858). The combined-OR opener spanning multiple lines created a parse-error fragment in the extraction; caught + manually fixed before commit (same pattern as the WOM info attachments/particles/sequences extraction).
2026-05-09 05:57:25 -07:00
#include "cli_bake.hpp"
refactor(editor): extract --migrate-* handlers into cli_migrate.cpp Moves the four schema-migration handlers (--migrate-wom, --migrate-zone, --migrate-project, --migrate-jsondbc) out of main.cpp into a new cli_migrate.{hpp,cpp} module. Same behavior — they're idempotent in-place upgraders for older WOM revisions and JSON DBC sidecar schemas. main.cpp shrinks by 282 lines (11,261 → 10,979).
2026-05-09 06:13:41 -07:00
#include "cli_migrate.hpp"
refactor(editor): extract single-file --convert-* into cli_convert_single.cpp Moves the five single-file format converters (--convert-m2, --convert-wmo, --convert-dbc-json, --convert-json-dbc, --convert-blp-png) out of two dedicated post-loop blocks in main.cpp into a new cli_convert_single.{hpp,cpp} module. The batch wrappers in cli_convert.cpp keep working — they shell out to wowee_editor with these flags. main.cpp shrinks by ~335 lines (10,979 → 10,644). The two trailing for-loops were dead code after wiring the dispatcher into the main loop, so they're gone too.
2026-05-09 06:25:04 -07:00
#include "cli_convert_single.hpp"
refactor(editor): extract interop --validate-* into cli_validate_interop.cpp Moves the four structural validators for INTEROP file formats (--validate-stl, --validate-png, --validate-blp, --validate-jsondbc) out of main.cpp into a new cli_validate_interop.{hpp,cpp} module. These check files coming in/out of wowee from third-party tools, distinct from cli_format_validate.cpp which validates the native open formats (WOM, WOB, WOC, WHM). main.cpp shrinks by 524 lines (10,644 to 10,121). Each validator preserves its --json output mode for machine-readable reports.
2026-05-09 06:36:02 -07:00
#include "cli_validate_interop.hpp"
refactor(editor): extract GLB inspectors into cli_glb_inspect.cpp Moves all 4 GLB introspection handlers (--validate-glb / --info-glb shared, --info-glb-tree, --info-glb-bytes, --check-glb-bounds) out of main.cpp into a new cli_glb_inspect.{hpp,cpp} module. GLB is our open replacement for proprietary M2/WMO bake outputs, so these belong with the other open-format tooling. main.cpp shrinks by 657 lines (10,121 to 9,464). Every handler preserves its --json output mode for machine-readable reports.
2026-05-09 06:46:02 -07:00
#include "cli_glb_inspect.hpp"
refactor(editor): extract WOM <-> OBJ/GLB/STL into cli_wom_io.cpp Moves the four WOM interchange-format handlers (--export-obj, --export-glb, --export-stl, --import-stl) out of main.cpp into a new cli_wom_io.{hpp,cpp} module. WOM is our open M2 replacement; these are the bridge that lets it round-trip through every external 3D tool — Blender, Three.js, slicers, CAD packages — so the open format is actually useful. main.cpp shrinks by 467 lines (9,464 to 8,997). The five WOB and WHM exporters (--export-wob-glb, --export-whm-glb, etc.) remain inline for a follow-up extraction.
2026-05-09 06:55:00 -07:00
#include "cli_wom_io.hpp"
refactor(editor): extract WOB/WHM/WOC IO into cli_world_io.cpp Moves all six world-asset interchange handlers (--export-wob-glb, --export-wob-obj, --import-wob-obj, --export-whm-glb, --export-whm-obj, --export-woc-obj) out of main.cpp into a new cli_world_io.{hpp,cpp} module. WOB / WHM / WOC are our open replacements for proprietary WMO / ADT-heightmap / ADT-collision data; these are the bridge that lets the open formats round-trip through Blender, MeshLab, Three.js, and the rest of the standard 3D toolchain. main.cpp shrinks by 858 lines (8,997 to 8,140). The single-mesh --import-obj handler stays inline for now -- it shadow-mirrors cli_wom_io's --import-stl semantics and will move there next.
2026-05-09 07:03:14 -07:00
#include "cli_world_io.hpp"
refactor(editor): extract --info-{zone,project}-tree into cli_info_tree.cpp Moves the two tree-style content browser handlers (--info-zone-tree, --info-project-tree) out of main.cpp into a new cli_info_tree.{hpp,cpp} module. Both render Unix-`tree`-style hierarchical views — one drilling into a single zone (manifest, tiles, creatures, objects, quests, files) and one giving a bird's-eye view of every zone in a project with bake/viewer status. main.cpp shrinks by 201 lines (8,140 to 7,939). The remaining info-zone/-project-* pairs (bytes, extents, water, density, audio) form the next natural extraction batch.
2026-05-09 07:10:12 -07:00
#include "cli_info_tree.hpp"
refactor(editor): extract --info-{zone,project}-bytes into cli_info_bytes.cpp Moves the two disk-byte audit handlers (--info-zone-bytes, --info-project-bytes) out of main.cpp into a new cli_info_bytes.{hpp,cpp} module. Both categorize files by extension into open / proprietary / derived buckets — the project-wide variant is the headline metric for tracking the open-format migration's progress against the .m2/.wmo/ .blp/.dbc baseline. main.cpp shrinks by 244 lines (7,939 to 7,695). Both --json output modes preserved for machine-readable reports.
2026-05-09 07:16:27 -07:00
#include "cli_info_bytes.hpp"
refactor(editor): extract --info-{zone,project}-extents into cli_info_extents.cpp Moves the two spatial-bounds info handlers (--info-zone-extents, --info-project-extents) out of main.cpp into a new cli_info_extents.{hpp,cpp} module. Both compute world-space XYZ bounding boxes from manifest tile coords + per-chunk height samples; the project variant unions every zone's box into one. main.cpp shrinks by 232 lines (7,695 to 7,463). Both --json output modes preserved for camera-framing pipelines.
2026-05-09 07:22:06 -07:00
#include "cli_info_extents.hpp"
refactor(editor): extract --info-{zone,project}-water into cli_info_water.cpp Moves the two water-layer audit handlers (--info-zone-water, --info-project-water) out of main.cpp into a new cli_info_water.{hpp,cpp} module. Both aggregate liquid data (water/ocean/magma/slime) across MH2O chunks; the project variant rolls per-zone counts into a project-wide total with height range and per-type histogram. main.cpp shrinks by 209 lines (7,463 to 7,254). Both --json output modes preserved for capacity-planning pipelines.
2026-05-09 07:28:15 -07:00
#include "cli_info_water.hpp"
refactor(editor): extract --info-{zone,project}-density into cli_info_density.cpp Moves the two content-density audit handlers (--info-zone-density, --info-project-density) out of main.cpp into a new cli_info_density.{hpp,cpp} module. Both count creatures/objects/quests per tile to surface sparse zones (boring) and over-stuffed ones (frame-rate bombs); the project variant rolls per-zone numbers into a project-wide table with per-zone averages for content-pacing reviews. main.cpp shrinks by 201 lines (7,254 to 7,053). Both --json output modes preserved for balance-audit pipelines.
2026-05-09 07:33:40 -07:00
#include "cli_info_density.hpp"
refactor(editor): extract --info-{zone,project}-audio into cli_info_audio.cpp Moves the two audio-config audit handlers (--info-zone-audio, --info-project-audio) out of main.cpp into a new cli_info_audio.{hpp,cpp} module. Both surface the music / day-ambience / night-ambience / volume settings stored in zone.json so designers can spot zones still missing audio assignment before a release pass. main.cpp shrinks by 127 lines (7,053 to 6,926). Drops the dead `label` lambda inside info-project-audio that the unused-but-set-variable warning had been flagging. Both --json output modes preserved.
2026-05-09 07:38:36 -07:00
#include "cli_info_audio.hpp"
refactor(editor): extract WOB/WOT/WOC inspectors into cli_world_info.cpp Moves the three open-format world-asset inspectors (--info-wob, --info-wot, --info-woc) out of main.cpp into a new cli_world_info.{hpp,cpp} module. Each prints a quick structural summary (groups / portals / chunk counts / triangles / bounds) without paying the full deserialization cost a viewer would. main.cpp shrinks by 144 lines (6,926 to 6,786). The --copy-project handler that interleaved between --info-wob and --info-wot stays inline -- it isn't an inspector and belongs with project-mutation operations. All --json output modes preserved.
2026-05-09 07:44:57 -07:00
#include "cli_world_info.hpp"
refactor(editor): extract quest+objective handlers into cli_quest_objective.cpp Moves three contiguous quest mutation handlers (--add-quest, --add-quest-objective, --remove-quest-objective) out of main.cpp into a new cli_quest_objective.{hpp,cpp} module. All three operate on a zone's quests.json with the same QuestEditor load-edit-save flow; the objective add/remove pair includes auto-generated description text from type+name+count for tooltip-friendly defaults. main.cpp shrinks by 174 lines (6,603 to 6,429). Reward and clone-quest handlers stay inline for follow-up extractions.
2026-05-09 07:56:16 -07:00
#include "cli_quest_objective.hpp"
refactor(editor): extract quest-reward handlers into cli_quest_reward.cpp Moves the two quest-reward mutation handlers (--add-quest-reward-item, --set-quest-reward) out of main.cpp into a new cli_quest_reward.{hpp,cpp} module. Both operate on a quest's reward struct in zone.json: the first greedy-consumes multiple item paths in one invocation, the second uses order-independent flag/value pairs (--xp / --gold / --silver / --copper) with strict 'only changed fields are written' semantics so partial updates don't clobber unrelated fields. main.cpp shrinks by 114 lines (6,429 to 6,315).
2026-05-09 08:01:28 -07:00
#include "cli_quest_reward.hpp"
refactor(editor): extract clone-* duplicate handlers into cli_clone.cpp Moves the three clone-* handlers (--clone-quest, --clone-creature, --clone-object) out of main.cpp into a new cli_clone.{hpp,cpp} module. All three deep-copy by index, optionally rename, and (for creature/object) offset the new copy by 5 yards along X to prevent z-fighting with the original. Each resets the per-entity unique id so downstream systems that dedupe by id stay consistent. main.cpp shrinks by 184 lines (6,315 to 6,131).
2026-05-09 08:06:20 -07:00
#include "cli_clone.hpp"
refactor(editor): extract remove-* by-index handlers into cli_remove.cpp Moves the four bounds-checked remove-by-index handlers (--remove-creature, --remove-object, --remove-quest, --remove-item) out of main.cpp into a new cli_remove.{hpp,cpp} module. All four share the same load-erase-save pattern with index validation and a "what was removed" report for audit trails. The first three use their respective editor classes (NpcSpawner, ObjectPlacer, QuestEditor); --remove-item walks raw nlohmann::json since items.json doesn't have a dedicated editor class yet. main.cpp shrinks by 145 lines (6,131 to 5,986).
2026-05-09 08:11:50 -07:00
#include "cli_remove.hpp"
refactor(editor): extract add-* append handlers into cli_add.cpp Moves the three add-* coordinate-based append handlers (--add-object, --add-creature, --add-item) out of main.cpp into a new cli_add.{hpp,cpp} module. All three append a single entry to a zone's JSON file with optional positional args after the required ones. --add-item handles raw nlohmann::json (no dedicated editor class) and auto-assigns the smallest unused id when the user passes 0 / nothing. main.cpp shrinks by 198 lines (5,986 to 5,788).
2026-05-09 08:16:52 -07:00
#include "cli_add.hpp"
refactor(editor): extract random-* / gen-random-* into cli_random.cpp Moves the four random-population handlers (--random-populate-zone, --random-populate-items, --gen-random-zone, --gen-random-project) out of main.cpp into a new cli_random.{hpp,cpp} module. All four use the same seeded LCG so re-runs reproduce the same content; the gen-random-* pair shells out to scaffold-zone + random-populate-zone + random-populate-items so the simpler single-purpose handlers stay the source of truth. main.cpp shrinks by 439 lines (5,788 to 5,349). The inline word lexicons (creature names, object paths, item prefixes/nouns) move with random-populate-zone and -items into the new module.
2026-05-09 08:22:06 -07:00
#include "cli_random.hpp"
refactor(editor): extract item-export handlers into cli_items_export.cpp Moves the three item-export handlers (--export-zone-items-md, --export-project-items-md, --export-project-items-csv) out of main.cpp into a new cli_items_export.{hpp,cpp} module. All three render items.json data as human-readable Markdown / CSV reports for design docs, PR descriptions, GitHub Pages, and spreadsheet pivot-table workflows. main.cpp shrinks by 262 lines (5,349 to 5,087).
2026-05-09 08:26:52 -07:00
#include "cli_items_export.hpp"
refactor(editor): extract items.json mutation handlers into cli_items_mutate.cpp Moves the three items.json mutation handlers (--set-item, --copy-zone-items, --clone-item) out of main.cpp into a new cli_items_mutate.{hpp,cpp} module. All three operate on the same {"items": [...]} schema; --set-item supports both id-lookup ("123") and index-lookup ("#0") with strict "only changed fields are written" semantics, --copy-zone-items has replace and --merge modes, --clone-item auto-assigns the smallest unused id. main.cpp shrinks by 316 lines (5,087 to 4,771) and finally drops below 5K. items.json now has its full mutation surface in one focused module instead of scattered through the megafile.
2026-05-09 08:33:59 -07:00
#include "cli_items_mutate.hpp"
refactor(editor): extract zone-creation handlers into cli_zone_create.cpp Moves the two zone-creation handlers (--scaffold-zone, --mvp-zone) out of main.cpp into a new cli_zone_create.{hpp,cpp} module. Both kickstart a new authoring session by generating a new zone directory under custom_zones/ — empty for scaffold, populated with one of each content type (creature + object + quest with objective + reward) for mvp. Each goes terrain + manifest, then mvp adds the demo content positioned at the tile center. main.cpp shrinks by 155 lines (4,771 to 4,616).
2026-05-09 08:42:49 -07:00
#include "cli_zone_create.hpp"
refactor(editor): extract --add-tile / --remove-tile / --list-tiles into cli_tiles.cpp Moves the three per-tile zone-manifest handlers (--add-tile, --remove-tile, --list-tiles) out of main.cpp into a new cli_tiles.{hpp,cpp} module. Zones can span multiple ADT tiles; these manage that list — add creates a fresh blank WHM/WOT pair at the new tile, remove drops the entry + deletes WHM/WOT/WOC files, list prints the manifest with file-presence flags. main.cpp shrinks by 185 lines (4,616 to 4,431).
2026-05-09 08:47:32 -07:00
#include "cli_tiles.hpp"
refactor(editor): extract zone lifecycle handlers into cli_zone_mgmt.cpp Moves the four zone-level lifecycle handlers (--copy-zone, --rename-zone, --remove-zone, --clear-zone-content) out of main.cpp into a new cli_zone_mgmt.{hpp,cpp} module. All slug- aware: copy + rename keep file names and manifest mapName in sync so the result is self-consistent; clear-content empties the per-feature JSONs without touching terrain. main.cpp shrinks by 321 lines (4,431 to 4,110).
2026-05-09 08:52:19 -07:00
#include "cli_zone_mgmt.hpp"
refactor(editor): extract --strip-zone / --strip-project into cli_strip.cpp Moves the two cleanup-pass handlers (--strip-zone, --strip-project) out of main.cpp into a new cli_strip.{hpp,cpp} module. Both remove derived outputs (.glb / .obj / .stl / .html / .dot / .csv / .png / ZONE.md / DEPS.md) leaving only source files. Useful before --pack-wcp so archives don't carry redundant exports, and before committing to git so derived blobs don't bloat history. Both honor --dry-run for safe previews. main.cpp shrinks by 164 lines (4,110 to 3,946).
2026-05-09 08:56:47 -07:00
#include "cli_strip.hpp"
refactor(editor): extract --repair-zone / --repair-project into cli_repair.cpp Moves the two manifest-drift fix handlers (--repair-zone, --repair-project) out of main.cpp into a new cli_repair.{hpp,cpp} module. Both auto-fix the common manifest-vs-disk inconsistencies that accumulate when zones are hand-edited or partially copied — adding orphan WHM tiles to the manifest, syncing the hasCreatures flag with the actual creatures.json content, and warning (not removing) for tiles in the manifest without backing files. Both honor --dry-run for safe previews. main.cpp shrinks by 155 lines (3,946 to 3,791).
2026-05-09 08:59:51 -07:00
#include "cli_repair.hpp"
refactor(editor): extract --gen-makefile / --gen-project-makefile into cli_makefile.cpp Moves the two Makefile-generation handlers (--gen-makefile, --gen-project-makefile) out of main.cpp into a new cli_makefile.{hpp,cpp} module. Both emit GNU make recipes that rebuild every derived output (.glb / .obj / .stl / .html / .csv / .md) from sources via wowee_editor flags, with proper dependency tracking so make can skip already-up-to-date outputs. Designers can `make -j$(nproc)` to rebuild all zones in parallel after a content edit. main.cpp shrinks by 167 lines (3,791 to 3,624).
2026-05-09 09:04:44 -07:00
#include "cli_makefile.hpp"
refactor(editor): extract --list-zones / --zone-stats into cli_zone_list.cpp Moves the two zone discovery / aggregation handlers (--list-zones, --zone-stats) out of main.cpp into a new cli_zone_list.{hpp,cpp} module. The first quickly enumerates zones across the standard locations (custom_zones, output); the second walks a project dir computing tile / creature / quest / per-format byte totals with a per-zone breakdown table — useful for content-pack release notes and capacity planning. main.cpp shrinks by 191 lines (3,624 to 3,433). Both --json output modes preserved.
2026-05-09 09:09:06 -07:00
#include "cli_zone_list.hpp"
feat(editor): --validate <zoneDir> CLI scores zone open-format completeness New CLI option that runs ContentPacker::validateZone on a zone directory and prints the open-format score (0-7) with per-file breakdown including magic-byte validity. Exits 0 if 7/7, 1 otherwise — useful for CI checks on exported zones.
2026-05-06 03:09:56 -07:00
#include "content_pack.hpp"
feat(editor): add --info-creatures CLI for creature.json summary Mirrors the existing --info-wom/wob/woc/wot/wcp inspectors. Reports total spawn count, hostile/questgiver/vendor/trainer flag counts, behavior breakdown (stationary/wander/patrol), and unique displayId count. Useful for triaging zone NPC content from the command line.
2026-05-06 07:14:42 -07:00
#include "npc_spawner.hpp"
feat(editor): add --info-objects CLI for objects.json summary Mirrors --info-creatures and the other format inspectors. Reports total placement count, M2/WMO breakdown, unique source paths, and scale range. Useful for spotting empty zones, accidental scale extremes, or duplicated placements before packing.
2026-05-06 07:15:40 -07:00
#include "object_placer.hpp"
feat(editor): add --info-quests CLI for quests.json summary Completes the --info-* family. Reports total/chained quest counts, reward/item counts, total XP awarded, objective-type breakdown (kill/collect/talk), and any quest-chain validation errors. Lets zone authors spot broken chains, missing rewards, and lopsided XP balance from the command line.
2026-05-06 07:16:27 -07:00
#include "quest_editor.hpp"
feat(editor): add --scaffold-zone CLI for empty zone bootstrap Creates custom_zones/<slug>/ with a flat-terrain WHM, default WOT, and minimal zone.json — score 3/7 on --validate, ready to open in the GUI for further authoring. Saves the round-trip of launching the GUI just to make a starter directory.
2026-05-06 08:17:33 -07:00
#include "wowee_terrain.hpp"
#include "zone_manifest.hpp"
#include "terrain_editor.hpp"
#include "terrain_biomes.hpp"
#include <filesystem>
feat(editor): add --export-obj for WOM -> Wavefront OBJ conversion WOM is our open M2 replacement, but it's still a custom binary format no DCC tool understands out of the box. OBJ is the universally supported text format that opens directly in Blender, MeshLab, ZBrush, Maya — basically every 3D tool ever made: wowee_editor --export-obj Tree # writes Tree.obj wowee_editor --export-obj Tree out.obj # custom output path This closes the loop for content authors: asset_extract -> WOM (open binary) -> OBJ (universal text) -> edit in Blender -> back to WOM via a future --import-obj. Layout details that matter for downstream tools: - 1-based face indices (OBJ standard) - UV V flipped (1.0 - v) so texturing matches between Vulkan top-left and Blender bottom-left conventions - Per-batch groups when WOM3 batches exist, named with the texture basename so material assignment carries through - Single 'mesh' group for WOM1/WOM2 models - Header comment preserves provenance (source, version, counts) Verified on a synthesized 5-vert pyramid (4 base + apex, 6 tris): output OBJ has 5 v / 5 vt / 5 vn entries, 6 f lines, opens cleanly in MeshLab. Build green, ctest 31/31.
2026-05-06 12:05:41 -07:00
#include <fstream>
feat(editor): add --gen-zone-readme auto-generated manifest Writes README.md to a zone (or to --out path) with a Markdown asset table covering textures (PNG bytes), meshes (verts/tris/ bones/batches/bytes), and audio (sample rate + duration). Reads zone.json for the friendly map name and biome. Saves the manual README maintenance every time content changes.
2026-05-08 10:58:28 -07:00
#include <iomanip>
feat(editor): add --import-obj to round-trip Wavefront OBJ back into WOM Closes the open-format authoring loop: asset_extract # M2 -> WOM (open binary) --export-obj # WOM -> OBJ (universal text) ... edit in Blender / MeshLab / ZBrush / Maya ... --import-obj # OBJ -> WOM (back to engine format) The same WOM file ships in custom zones, gets validated by --validate-wom, and renders identically through the existing pipeline — no proprietary M2 ever needs to touch the authoring path. Parser handles: - v / vt / vn pools, deduped on (pos, uv, normal) triples so the resulting WOM vertex buffer stays compact - 1-based AND negative (relative) face indices - f tokens in v, v/t, v//n, and v/t/n forms - Triangles, quads, and convex n-gons (fan-triangulated) - CRLF line endings - Reverses --export-obj's V flip (1.0 - v) so UVs round-trip exactly - Auto-computes boundMin/Max/Radius from positions (renderer culls by these — wrong values make the model disappear) - Output WOM is WOM1 (static); bones/anims/material flags don't exist in OBJ and stay empty by design Verified end-to-end: WOM -> OBJ -> WOM -> validate-wom yields a 5-vert, 6-tri pyramid back identical to the input. Bounds, vertex count, index count, and name all preserved.
2026-05-06 12:07:55 -07:00
#include <sstream>
feat(editor): CLI batch convert mode (--convert-m2) for M2→WOM conversion - wowee_editor --convert-m2 <path> --data <datadir> converts a single M2 model to WOM open format without launching the GUI - Output goes to output/models/ with same path structure - Useful for batch scripts to convert entire asset directories - Example: wowee_editor --data Data --convert-m2 creature\\bear\\bear.m2
2026-05-05 10:50:36 -07:00
#include "pipeline/wowee_model.hpp"
feat: complete client integration for all 6 open formats - Wire WOB buildings into WMO render pipeline (loads→converts→renders) - Implement JSON DBC loading in DBCFile::loadJSON() with nlohmann/json - Wire JSON DBC override into AssetManager (custom_zones/output scan) - Add WMO→WOB conversion with full geometry (fromWMO) - Replace placeholder WOB export with real WMO→WOB conversion in editor - Add --convert-wmo CLI flag for batch WMO→WOB conversion - Store discovered custom zones on Renderer with getCustomZones() accessor - Add isCustomZone_ member to TerrainManager All 6 Blizzard format replacements now fully load in the client: ADT→WOT/WHM, WDT→zone.json, BLP→PNG, DBC→JSON, M2→WOM, WMO→WOB
2026-05-05 12:41:19 -07:00
#include "pipeline/wowee_building.hpp"
feat(editor): --info-woc CLI prints collision mesh metadata Completes the --info* CLI family. Reports tile coords, triangle count, walkable/steep classification breakdown, and world-space bounds — useful for verifying that collision exports cover the expected area.
2026-05-06 03:17:10 -07:00
#include "pipeline/wowee_collision.hpp"
feat(editor): add --info-wot CLI for inspecting terrain metadata Mirrors the existing --info-wom/--info-wob/--info-woc/--info-wcp inspectors. Reports the tile coord, populated chunks, layer count, water count, texture/doodad/WMO counts, and computed height range across all chunks. Useful for triaging zones from the command line without opening the GUI.
2026-05-06 06:58:34 -07:00
#include "pipeline/wowee_terrain_loader.hpp"
feat: complete client integration for all 6 open formats - Wire WOB buildings into WMO render pipeline (loads→converts→renders) - Implement JSON DBC loading in DBCFile::loadJSON() with nlohmann/json - Wire JSON DBC override into AssetManager (custom_zones/output scan) - Add WMO→WOB conversion with full geometry (fromWMO) - Replace placeholder WOB export with real WMO→WOB conversion in editor - Add --convert-wmo CLI flag for batch WMO→WOB conversion - Store discovered custom zones on Renderer with getCustomZones() accessor - Add isCustomZone_ member to TerrainManager All 6 Blizzard format replacements now fully load in the client: ADT→WOT/WHM, WDT→zone.json, BLP→PNG, DBC→JSON, M2→WOM, WMO→WOB
2026-05-05 12:41:19 -07:00
#include "pipeline/wmo_loader.hpp"
feat(editor): add --info-m2 and --info-wmo proprietary inspectors Round out the format-inspector lineup. The wowee open formats had inspectors (--info-wom, --info-wob); these are the proprietary counterparts that pair with --convert-m2 / --convert-wmo so users can verify what the conversion preserves vs drops: wowee_editor --info-m2 Character/Human/Male/HumanMale.m2 wowee_editor --info-wmo World/wmo/Stormwind/Stormwind.wmo --info-m2 reports verts/tris, bones, sequences (animations), batches, textures, materials, attachments, particles, ribbons, collision tris, and bound radius. Auto-merges <base>00.skin if present (WotLK+ M2s store geometry there) so vertex/index counts match what gets rendered. --info-wmo reports group count + portals + lights + doodads + materials + textures + total verts/tris across loaded groups. Auto-merges matching <base>_NNN.wmo group files; pre-resizes the groups vector so loadGroup populates the right slots. Verified against real WoW assets: nexusraid_skya.m2: v264, 20917 verts, 22940 tris, 44 bones, 1 sequence, 44 batches, 28 textures, 42 materials. ed_zd_ziggurat.wmo: v17, 1 group (1 loaded), 8 materials, 7 textures, 4609 verts, 3650 tris from the group file. Bug caught during testing: initial snprintf used an 8-byte buffer for '_NNN.wmo' (which is 8 chars + NUL = 9), silently truncating to '_000.wm' and failing every group lookup. Bumped to 16 bytes with a comment so the trap doesn't get re-stepped.
2026-05-06 12:51:40 -07:00
#include "pipeline/m2_loader.hpp"
feat(editor): add --info-adt proprietary terrain inspector Completes the proprietary-format inspector lineup. Pairs naturally with --info-wot / --info-whm (the open WOT/WHM equivalents) so users can verify the conversion preserves chunk counts, doodad placements, and WMO references: wowee_editor --info-adt World/Maps/Azeroth/Azeroth_32_48.adt ADT: ... version : 18 file bytes : 450192 coord : (0, 0) chunks loaded : 256/256 height range : [-0.00, 0.00] hole chunks : 0 (with cave/gap masks) water chunks : 0 textures : 0 doodad names : 0 (0 placements) wmo names : 1 (1 placements) Reports loaded chunk count (out of fixed 256), height min/max across all loaded chunks (with NaN guard so corrupted heights don't poison the range), hole chunks (cave/gap masks), water chunks, texture and doodad/WMO name table sizes, and placement counts. Verified on a real WoW ADT (ahnqirajtemple_29_46.adt, 450KB): correctly reports 256/256 chunks loaded, 1 WMO name + 1 placement. JSON mode emits structured output for CI scripts. The format-inspector lineup is now complete: Proprietary: BLP / DBC / M2 / WMO / ADT Open: PNG / JSON DBC / WOM / WOB / WOC / WOT/WHM / WCP Every format on both sides of the open-format bridge has an inspector.
2026-05-06 12:55:31 -07:00
#include "pipeline/adt_loader.hpp"
feat(editor): CLI batch convert mode (--convert-m2) for M2→WOM conversion - wowee_editor --convert-m2 <path> --data <datadir> converts a single M2 model to WOM open format without launching the GUI - Output goes to output/models/ with same path structure - Useful for batch scripts to convert entire asset directories - Example: wowee_editor --data Data --convert-m2 creature\\bear\\bear.m2
2026-05-05 10:50:36 -07:00
#include "pipeline/asset_manager.hpp"
feat(editor): --list-zones CLI flag to discover custom zones without GUI
2026-05-05 12:18:31 -07:00
#include "pipeline/custom_zone_discovery.hpp"
feat(editor): add standalone world editor (rough/WIP) Standalone wowee_editor tool for creating custom WoW zones. This is a rough initial implementation — many features work but M2/WMO rendering still has issues (frame sync, texture layout transitions) and needs further polish. Terrain: - Create new blank terrain with 10 biome types (Grassland, Forest, Jungle, Desert, Barrens, Snow, Swamp, Rocky, Beach, Volcanic) - Load existing ADT tiles from extracted game data - Sculpt brushes: Raise, Lower, Smooth, Flatten, Level - Chunk edge stitching prevents seams between tiles - Undo/redo (100-deep stack, Ctrl+Z/Ctrl+Shift+Z) - Save to WoW ADT/WDT format Texture Painting: - Paint/Erase/Replace Base modes - Full tileset texture browser (1285 textures from manifest) - Per-zone directory filtering and search - Alpha map editing with 4-layer limit (auto-replaces weakest) Object Placement: - M2 and WMO model placement with full manifest browser (11k M2s, 2k WMOs) - M2Renderer + WMORenderer integrated (loads .skin files for WotLK) - Ghost preview follows cursor before placing - Ctrl+click selection, right-click context menu - Transform gizmo (Move/Rotate/Scale with axis constraints) - Position/rotation/scale editing in properties panel NPC/Monster System: - 631 creature presets scanned from manifest, categorized (Critters, Beasts, Humanoids, Undead, Demons, etc.) - Stats editor: level, health, mana, damage, armor, faction - Behavior: Stationary, Patrol, Wander, Scripted - Aggro/leash radius, respawn time, flags (hostile/vendor/etc.) - Save creature spawns to JSON Water: - Place water at configurable height per chunk - Liquid types: Water, Ocean, Magma, Slime - Rendered as translucent colored quads - Saved in ADT MH2O format Infrastructure: - Free-fly camera (WASD/QE, right-drag look, scroll speed) - 5-mode toolbar: Sculpt | Paint | Objects | Water | NPCs - Asset browser indexes full manifest on startup - Editor water/marker shaders (pos+color vertex format) - forceNoCull added to M2Renderer for editor use - AssetManifest::getEntries() and AssetManager::getManifest() exposed Known issues: - M2/WMO rendering may not display on first placement (frame index sync between update/render was misaligned — now fixed but untested end-to-end) - Validation layer errors on shutdown (resource cleanup ordering) - Object placement on steep terrain can miss raycast - No undo for texture painting or object placement yet
2026-05-05 03:47:03 -07:00
#include "core/logger.hpp"
#include <string>
fix(editor): CLI output visible on stdout (was silent LOG_INFO) --help, --version, and --list-zones now print to stdout via printf instead of LOG_INFO which writes to log file only. Users running CLI commands would see no output at all — critical first-impression bug for new users. Also updated --version format list to include WOC.
2026-05-05 16:54:03 -07:00
#include <cstdio>
feat(editor): add standalone world editor (rough/WIP) Standalone wowee_editor tool for creating custom WoW zones. This is a rough initial implementation — many features work but M2/WMO rendering still has issues (frame sync, texture layout transitions) and needs further polish. Terrain: - Create new blank terrain with 10 biome types (Grassland, Forest, Jungle, Desert, Barrens, Snow, Swamp, Rocky, Beach, Volcanic) - Load existing ADT tiles from extracted game data - Sculpt brushes: Raise, Lower, Smooth, Flatten, Level - Chunk edge stitching prevents seams between tiles - Undo/redo (100-deep stack, Ctrl+Z/Ctrl+Shift+Z) - Save to WoW ADT/WDT format Texture Painting: - Paint/Erase/Replace Base modes - Full tileset texture browser (1285 textures from manifest) - Per-zone directory filtering and search - Alpha map editing with 4-layer limit (auto-replaces weakest) Object Placement: - M2 and WMO model placement with full manifest browser (11k M2s, 2k WMOs) - M2Renderer + WMORenderer integrated (loads .skin files for WotLK) - Ghost preview follows cursor before placing - Ctrl+click selection, right-click context menu - Transform gizmo (Move/Rotate/Scale with axis constraints) - Position/rotation/scale editing in properties panel NPC/Monster System: - 631 creature presets scanned from manifest, categorized (Critters, Beasts, Humanoids, Undead, Demons, etc.) - Stats editor: level, health, mana, damage, armor, faction - Behavior: Stationary, Patrol, Wander, Scripted - Aggro/leash radius, respawn time, flags (hostile/vendor/etc.) - Save creature spawns to JSON Water: - Place water at configurable height per chunk - Liquid types: Water, Ocean, Magma, Slime - Rendered as translucent colored quads - Saved in ADT MH2O format Infrastructure: - Free-fly camera (WASD/QE, right-drag look, scroll speed) - 5-mode toolbar: Sculpt | Paint | Objects | Water | NPCs - Asset browser indexes full manifest on startup - Editor water/marker shaders (pos+color vertex format) - forceNoCull added to M2Renderer for editor use - AssetManifest::getEntries() and AssetManager::getManifest() exposed Known issues: - M2/WMO rendering may not display on first placement (frame index sync between update/render was misaligned — now fixed but untested end-to-end) - Validation layer errors on shutdown (resource cleanup ordering) - Object placement on steep terrain can miss raycast - No undo for texture painting or object placement yet
2026-05-05 03:47:03 -07:00
#include <cstring>
feat(editor): --info-wcp CLI prints content pack metadata Reports name/author/description/version/format/mapId, total file count, per-category breakdown (terrain/model/building/texture/data), and total on-disk bytes. Useful for inspecting third-party WCPs before importing or for sanity-checking your own exports.
2026-05-06 04:36:40 -07:00
#include <unordered_map>
feat(editor): add --check-zone-refs cross-reference validator Catches dangling references that --validate (which only checks open-format file presence) doesn't: wowee_editor --check-zone-refs custom_zones/MyZone Zone refs: custom_zones/MyZone objects checked : 12 (2 missing) quests checked : 5 (1 bad NPC refs) FAILED — 3 issue(s): - object[3] missing: World/Doodad/Tree.m2 - object[7] missing: World/Building/Inn.wmo - quest[1] 'Hunt' giver 999 not in creatures.json Two checks: 1. Every objects.json model path resolves on disk in any of the conventional roots (zone-local, output/, custom_zones/, Data/), trying both the open (.wom/.wob) and proprietary (.m2/.wmo) variants, with a case-fold fallback for case-sensitive Linux filesystems where extracted assets are usually lowercased. 2. Every quest's questGiverNpcId / turnInNpcId references a creature in creatures.json (when the zone has any). Filter: only flag IDs < 100000 since production wires upstream NPCs with 6-digit IDs that legitimately reference outside content. Errors capped at 30 listed (with full counts in the summary) so a misconfigured zone with 500 broken refs doesn't drown the output. Exit 1 on any issue so CI can gate. Verified: zone with 1 creature, 2 dead model refs, 1 bad NPC giver — all 3 issues reported with precise indices and exit 1.
2026-05-06 13:27:18 -07:00
#include <unordered_set>
feat(editor): add --list-zone-deps for asset packaging audit Enumerates every external model path a zone references — both directly placed (objects.json) and indirectly via WOB doodad placements. Useful when packaging a content pack to confirm every asset will ship: wowee_editor --list-zone-deps custom_zones/MyZone Zone deps: custom_zones/MyZone WOBs scanned : 3 unique paths total : 12 Direct M2 placements (5 unique): World/Generic/Lamp.m2 World/Generic/Tree.m2 ×8 ... Direct WMO placements (2 unique): World/StaticObject/Stormwind/HumanInn.wmo WOB doodad M2 refs (5 unique): World/Furniture/Chair.wom World/Furniture/Table.wom ... Aggregation: - Counts duplicates so frequently-used assets show '×N' instead of cluttering the list with N identical lines. - Walks WOBs in the zone dir recursively (catches buildings/ subdir). - Also recurses into WOBs referenced by direct WMO placements so transitive doodad deps surface — matches the runtime's actual load chain. - Sorted output (std::map) so diffs across versions are stable. JSON mode emits per-category arrays for programmatic consumption (e.g. piping into a script that checks each path exists in Data/). Verified on a synthesized zone with 3 M2 placements (one duplicated) + 1 WMO placement + no WOBs: 3 unique total, Tree.m2 correctly deduped with ×2 count, JSON arrays well-formed.
2026-05-06 13:24:27 -07:00
#include <map>
feat(editor): add --list-commands and --gen-completion for shell ergonomics The CLI surface is now 103 commands. Tab completion is no longer a nice-to-have: source <(wowee_editor --gen-completion bash) # one-time setup wowee_editor --info-<TAB> # all info-* offered Two complementary commands: --list-commands: parses printUsage's own output to extract every '--flag' it documents, dedupes, sorts. Auto-tracks new commands as they're added (no parallel list to maintain). --gen-completion bash|zsh: emits a completion script that re-execs --list-commands at completion time, so newly-added flags light up without regenerating the script. Bash version uses compgen with per-session caching in ; zsh version uses the _arguments + compdef framework. Both completion scripts also fall back to file-path completion in arg slots (the common case for --info-/--validate-/--export- commands that take a path). Verified: - --list-commands: 103 unique flags emitted alphabetically - --gen-completion bash: well-formed script using full binary path for the cached --list-commands invocation - --gen-completion zsh: same shape, _arguments-based - Unknown shell: clear error + exit 1
2026-05-06 13:59:54 -07:00
#include <set>
#include <cctype>
#include <cstdio>
feat(editor): add --bench-validate-project for validation timing analysis Times --validate-project per zone. Useful for catching unusually slow zones (huge WHM/WOC pairs, lots of WOM batches) and tracking validation overhead growth across releases: wowee_editor --bench-validate-project custom_zones Bench validate: custom_zones zones : 12 total : 4731.20 ms per zone : avg=394.27 min=87.42 max=2103.55 ms slowest : Stranglethorn (2103.55 ms) Per-zone timings: zone ms files ms/file AshenForest 87.42 8 10.928 BoneOasis 245.10 17 14.418 Stranglethorn 2103.55 94 22.378 ... Reports total + avg/min/max per zone + slowest zone callout. Per- zone table with ms/file ratio surfaces formats that scale poorly ('this zone has only 5 files but takes 2 seconds — one is a 100MB WHM that's slow to load'). Useful for: - Pre-commit profiling: 'did my validator change make Stranglethorn 3× slower?' - CI cycle time budgeting - Catching pathological inputs (a 10000-creature creatures.json that blows up validation cost) JSON mode emits per-zone records + aggregate stats for dashboards. Verified on a 2-zone project: per-zone timings make sense (Forest with .woc takes 5× longer than Desert without).
2026-05-06 18:03:55 -07:00
#include <chrono>
feat(editor): add --info-pack-tree for WCP directory hierarchy view Tree view of a WCP archive's contents with per-file byte sizes. --list-wcp shows the flat sorted file list; this gives the hierarchical view that's easier to read for archives with subdirectories: wowee_editor --info-pack-tree custom_zones/MyZone.wcp custom_zones/MyZone.wcp (47 files, 2348.21 KB) ├─ Forest_28_30.whm (150540 bytes) ├─ Forest_28_30.wot (26685 bytes) ├─ buildings/ │ ├─ inn.wob (45120 bytes) │ └─ tavern.wob (38104 bytes) ├─ creatures.json (694 bytes) ├─ data/ │ ├─ Spell.json (15032 bytes) │ └─ Item.json (8194 bytes) ├─ objects.json (234 bytes) └─ zone.json (500 bytes) Recursive renderer with UTF-8 box-drawing connectors. Files show their byte size; directories show the subtree subtotal aggregated from children. Children sorted alphabetically (std::map). Pairs with --info-pack-budget (per-extension byte breakdown) and --list-wcp (flat sorted list) — three lenses on the same archive: hierarchy / extension cost / flat search. Verified on a 6-file mvp-zone WCP: tree correctly shows top-level files (no subdirs in mvp-zone output) with byte sizes and total 175 KB summary.
2026-05-06 19:17:42 -07:00
#include <functional>
#include <memory>
feat(editor): add --list-wcp CLI to print every file in a WCP archive --info-wcp gives counts and totals; --list-wcp gives the full file listing sorted by path. Useful for spotting missing texture/model entries before unpacking and shipping a zone.
2026-05-06 07:30:26 -07:00
#include <algorithm>
feat(editor): --info-extract --json for machine-readable coverage output Adds an optional --json flag that emits a structured nlohmann JSON object instead of the human-readable text. Schema: { "dir": "...", "totalBytes": N, "proprietaryBytes": N, "openBytes": N, "overallCoverage": 100.0, "blp_png": { "proprietary": N, "sidecar": N, "coverage": % }, "dbc_json": { ... }, "m2_wom": { ... }, "wmo_wob": { ... }, "adt_whm": { ... } } Lets CI scripts gate on coverage: cov=$(wowee_editor --info-extract Data --json | jq .overallCoverage) if [ "$cov" != "100" ]; then asset_extract --upgrade-extract Data; fi
2026-05-06 11:07:11 -07:00
#include <nlohmann/json.hpp>
feat(editor): add --convert-blp-png standalone texture converter Companion to --convert-dbc-json and --convert-json-dbc. Refresh one PNG sidecar without re-running asset_extract --emit-open across the whole tree: wowee_editor --convert-blp-png Texture.blp # -> Texture.png wowee_editor --convert-blp-png Texture.blp out.png # custom path Same code path as the asset_extract emitter (BLPLoader::load + stbi_write_png), with the same dimension/buffer guards (rejects 0x0 or >8192x8192, rejects images where data is shorter than width*height*4). Verified on a real WoW BLP (Data/interface/pvp-banner-emblem-1.blp, 128x128 RGBA): converted cleanly, --info-png on the result reports '128 x 128 / 8-bit / rgba (4 channels) / 24136 file bytes' (PNG zlib compression on a sparse banner texture).
2026-05-06 12:38:14 -07:00
#include "stb_image_write.h"
feat(editor): add --gen-mesh-from-heightmap for PNG → 3D terrain Converts a grayscale PNG into a heightmap mesh. Each pixel becomes one vertex; brightness becomes Y. Mesh is centered on the XZ plane with X spanning [-W*scaleXZ/2, +W*scaleXZ/2] and Z spanning the same for H. Defaults: scaleXZ=0.1 (a 64×64 PNG covers a 6.4×6.4 yard patch), scaleY=2.0 (full white pixels rise 2 yards above black). Capped at 512×512 source images to keep vertex count bounded (the cap raises to 262K verts for the largest legal input). Normals are computed from finite differences against the height field, giving smooth shading across the surface. Single batch + one empty texture slot ready for downstream binding via --add-texture-to-mesh. Pairs naturally with --gen-texture-noise (synthetic terrain) or any artist-painted heightmap exported from Photoshop / GIMP. Adds stb_image.h include — implementation is already linked via the existing tools/editor/stb_image_impl.cpp. Verified: 64×64 noise heightmap → 4096 verts (= 64²) + 7938 tris (= 2×63²), 6.4×6.4 span, height range 0..1.99; 1024×1024 input rejected with size-cap error. Brings command count to 228.
2026-05-07 08:19:37 -07:00
#include "stb_image.h" // implementation in stb_image_impl.cpp
feat(editor): add standalone world editor (rough/WIP) Standalone wowee_editor tool for creating custom WoW zones. This is a rough initial implementation — many features work but M2/WMO rendering still has issues (frame sync, texture layout transitions) and needs further polish. Terrain: - Create new blank terrain with 10 biome types (Grassland, Forest, Jungle, Desert, Barrens, Snow, Swamp, Rocky, Beach, Volcanic) - Load existing ADT tiles from extracted game data - Sculpt brushes: Raise, Lower, Smooth, Flatten, Level - Chunk edge stitching prevents seams between tiles - Undo/redo (100-deep stack, Ctrl+Z/Ctrl+Shift+Z) - Save to WoW ADT/WDT format Texture Painting: - Paint/Erase/Replace Base modes - Full tileset texture browser (1285 textures from manifest) - Per-zone directory filtering and search - Alpha map editing with 4-layer limit (auto-replaces weakest) Object Placement: - M2 and WMO model placement with full manifest browser (11k M2s, 2k WMOs) - M2Renderer + WMORenderer integrated (loads .skin files for WotLK) - Ghost preview follows cursor before placing - Ctrl+click selection, right-click context menu - Transform gizmo (Move/Rotate/Scale with axis constraints) - Position/rotation/scale editing in properties panel NPC/Monster System: - 631 creature presets scanned from manifest, categorized (Critters, Beasts, Humanoids, Undead, Demons, etc.) - Stats editor: level, health, mana, damage, armor, faction - Behavior: Stationary, Patrol, Wander, Scripted - Aggro/leash radius, respawn time, flags (hostile/vendor/etc.) - Save creature spawns to JSON Water: - Place water at configurable height per chunk - Liquid types: Water, Ocean, Magma, Slime - Rendered as translucent colored quads - Saved in ADT MH2O format Infrastructure: - Free-fly camera (WASD/QE, right-drag look, scroll speed) - 5-mode toolbar: Sculpt | Paint | Objects | Water | NPCs - Asset browser indexes full manifest on startup - Editor water/marker shaders (pos+color vertex format) - forceNoCull added to M2Renderer for editor use - AssetManifest::getEntries() and AssetManager::getManifest() exposed Known issues: - M2/WMO rendering may not display on first placement (frame index sync between update/render was misaligned — now fixed but untested end-to-end) - Validation layer errors on shutdown (resource cleanup ordering) - Object placement on steep terrain can miss raycast - No undo for texture painting or object placement yet
2026-05-05 03:47:03 -07:00
feat(editor): add --validate-all + extract validator helpers Walks a directory recursively and runs the deep validators on every .wom and .wob it finds. Single CI gate for an entire zone tree: wowee_editor --validate-all custom_zones/MyZone --json Reports per-file failures (capped at first 20 to keep output bounded) plus aggregate counts so you know which file to drill into with --validate-wom or --validate-wob individually. Refactor: pulled the validation bodies out of --validate-wom and --validate-wob into static helpers (validateWomErrors / validateWobErrors) returning vector<string>. The per-file commands now share the same logic as --validate-all — fix one, fix all three. ~200 lines of duplicate validation code consolidated. Verified end-to-end: seeded /tmp dir with 2 WOMs (1 with DAG bone violation) + 1 valid WOB, --validate-all reports 'WOM: 2 total, 1 failed' / 'WOB: 1 total, 0 failed' with the bad file's full path and error printed below. JSON mode emits per-file failure list for CI.
2026-05-06 11:54:54 -07:00
// ─── Open-format consistency checks ─────────────────────────────
// Both validators are called from the per-file CLI commands AND
// from --validate-all which walks a zone dir. Returning a vector
// of error strings (empty == passed) keeps callers simple.
feat(editor): add --export-zone-checksum for SHA-256 integrity manifests Emits a SHA-256 manifest of every source file in a zone in the standard sha256sum format. Lets users verify zone integrity after download/transfer using the standard system tool — no custom verifier needed: wowee_editor --export-zone-checksum custom_zones/MyZone 3298c35a... Z_30_30.whm f81e3d37... Z_30_30.wot 6a49519f... creatures.json 4625e30b... zone.json sha256sum -c custom_zones/MyZone/SHA256SUMS Z_30_30.whm: OK Z_30_30.wot: OK ... Source-only by design — derived outputs (.glb/.obj/.stl/.html/.png/ ZONE.md/DEPS.md/quests.dot/SHA256SUMS itself/Makefile) are excluded since they're regeneratable and would invalidate the checksum on every rebuild. Includes a self-contained 90-LoC SHA-256 (FIPS 180-4 / RFC 6234) in an internal namespace — no OpenSSL/Crypto++ dependency added. Streaming hash (16KB chunks) so it scales to giant terrain WHMs without holding the whole file in memory. Verified end-to-end: scaffolded zone with 1 creature → checksum manifest of 4 source files (zone.json, creatures.json, .whm, .wot) in standard format → sha256sum -c reports all 4 OK.
2026-05-06 15:51:50 -07:00
// Minimal SHA-256 implementation (FIPS 180-4) used by --export-zone-checksum
// to produce hashes that interoperate with `sha256sum -c`. Not exposed beyond
// this file — about 90 LoC, no external deps. See RFC 6234 for the algorithm.
feat(editor): add --validate-woc + --validate-whm and roll into validate-all Round out the per-format validator suite. Open-format zone validation now covers all four binary formats: --validate-wom Tree --validate-wob House --validate-woc terrain.woc --validate-whm Zone_28_30 --validate-all custom_zones/Zone1 # runs everything WOC checks: finite vertex coords on every triangle, no degenerate triangles (two verts identical), known flag bits only (0x0F mask), tile coords within WoW grid (< 64), bounds.min <= bounds.max. WHM/WOT checks: finite heights across all 145 verts/chunk, finite chunk position vectors, tile coord in [0, 64), reasonable height envelope ([-10000, 10000] is a generous outer bound — beyond that suggests units confusion), placements have finite positions and nameId within doodadNames/wmoNames table size. validate-all now reports all four format counts (WOM/WOB/WOC/WHM) and aggregates errors. Verified end-to-end: a fresh scaffolded zone with --build-woc yields 256/256 chunks loaded, 32768 walkable triangles, validate-all PASSED. Synthesized WOC with 0xFF flags correctly fails with 'unknown flag bits 0xFF' and exit 1.
2026-05-06 11:58:20 -07:00
feat(editor): add standalone world editor (rough/WIP) Standalone wowee_editor tool for creating custom WoW zones. This is a rough initial implementation — many features work but M2/WMO rendering still has issues (frame sync, texture layout transitions) and needs further polish. Terrain: - Create new blank terrain with 10 biome types (Grassland, Forest, Jungle, Desert, Barrens, Snow, Swamp, Rocky, Beach, Volcanic) - Load existing ADT tiles from extracted game data - Sculpt brushes: Raise, Lower, Smooth, Flatten, Level - Chunk edge stitching prevents seams between tiles - Undo/redo (100-deep stack, Ctrl+Z/Ctrl+Shift+Z) - Save to WoW ADT/WDT format Texture Painting: - Paint/Erase/Replace Base modes - Full tileset texture browser (1285 textures from manifest) - Per-zone directory filtering and search - Alpha map editing with 4-layer limit (auto-replaces weakest) Object Placement: - M2 and WMO model placement with full manifest browser (11k M2s, 2k WMOs) - M2Renderer + WMORenderer integrated (loads .skin files for WotLK) - Ghost preview follows cursor before placing - Ctrl+click selection, right-click context menu - Transform gizmo (Move/Rotate/Scale with axis constraints) - Position/rotation/scale editing in properties panel NPC/Monster System: - 631 creature presets scanned from manifest, categorized (Critters, Beasts, Humanoids, Undead, Demons, etc.) - Stats editor: level, health, mana, damage, armor, faction - Behavior: Stationary, Patrol, Wander, Scripted - Aggro/leash radius, respawn time, flags (hostile/vendor/etc.) - Save creature spawns to JSON Water: - Place water at configurable height per chunk - Liquid types: Water, Ocean, Magma, Slime - Rendered as translucent colored quads - Saved in ADT MH2O format Infrastructure: - Free-fly camera (WASD/QE, right-drag look, scroll speed) - 5-mode toolbar: Sculpt | Paint | Objects | Water | NPCs - Asset browser indexes full manifest on startup - Editor water/marker shaders (pos+color vertex format) - forceNoCull added to M2Renderer for editor use - AssetManifest::getEntries() and AssetManager::getManifest() exposed Known issues: - M2/WMO rendering may not display on first placement (frame index sync between update/render was misaligned — now fixed but untested end-to-end) - Validation layer errors on shutdown (resource cleanup ordering) - Object placement on steep terrain can miss raycast - No undo for texture painting or object placement yet
2026-05-05 03:47:03 -07:00
int main(int argc, char* argv[]) {
std::string dataPath;
std::string adtMap;
int adtX = -1, adtY = -1;
fix(cli): error on non-GUI options that are missing their argument Previously '--info-wcp' (no path) silently dropped into the GUI because the option-parse loop's i+1<argc guard hid the typo. Pre- scan and bail out with a helpful message before trying to start the editor, so users get fast feedback on bad invocations.
2026-05-06 08:08:05 -07:00
// Detect non-GUI options that are missing their argument and bail out
// with a helpful message instead of silently dropping into the GUI.
static const char* kArgRequired[] = {
feat(editor): add --info-textures and --info-doodads detailed inspectors Two more drill-down inspectors that complement --info-batches: wowee_editor --info-textures HumanMale.wom WOM textures: HumanMale.wom (3 textures) idx blp png path 0 y y Character/Human/Male/HumanMaleHair.blp 1 y - Character/Human/Male/HumanMaleBody.blp 2 - - Character/Human/Male/HumanMaleEye.blp wowee_editor --info-doodads Stormwind.wob WOB doodads: Stormwind.wob (3 placements) idx scale pos (x, y, z) rot (x, y, z) model 0 1.50 ( 1.0, 0.0, 1.0) ( 0.0, 90.0, 0.0) Furniture/Chair.wom ... --info-textures: cross-checks each referenced texture against both the proprietary BLP and the open PNG sidecar on disk (each lookup tries the literal path AND falls back to Data/<lowercased path> since WoW assets are case-sensitive on Linux but designers usually type Mixed Case). The y/- columns let you spot which textures are missing before --pack-wcp would fail at runtime. --info-doodads: model path + position + rotation + scale per instance. Companion to --info-textures (GPU resources) — this tracks scene composition. Both have --json mode that emits per-entry records with index for programmatic consumption. Verified on synthesized model with 3 texture refs + building with 3 doodads; all fields render correctly.
2026-05-06 13:19:45 -07:00
"--data", "--info", "--info-batches", "--info-textures", "--info-doodads",
feat(editor): add --info-attachments / --info-particles / --info-sequences Three M2 sub-inspectors covering data fields the proprietary M2 format carries that the open WOM doesn't yet (or carries differently). Useful for understanding what gets lost when running --convert-m2 vs what ships with the open conversion: wowee_editor --info-attachments Character/Human/HumanMale.m2 M2 attachments: ... (15) idx id bone pos (x, y, z) 0 0 5 ( 0.00, 0.50, 1.20) # head 1 1 27 ( 0.10, -0.20, 0.30) # right hand ... wowee_editor --info-particles Spells/Fireball.m2 particles: 8, ribbons: 2 Particles: idx id bone tex blend type pos (x, y, z) ... Ribbons: idx id bone tex mat pos (x, y, z) ... wowee_editor --info-sequences Creature/Wolf/Wolf.m2 M2 sequences: ... (12) idx id var duration flags speed blend 0 0 0 1733 32 0.00 150 # Stand 4 4 0 950 0 1.50 150 # Walk 5 5 0 625 0 3.20 150 # Run ... Three commands share one entry point — they all need the same M2Loader::load + skin-merge dance, then differ only in which sub- array they iterate. Reduces duplicate boilerplate. JSON mode emits per-entry records with index for programmatic consumption. Why these matter: M2 carries scene-graph metadata (where to mount weapons, where particles spawn, which animation is which) that gameplay code reads at runtime. Surfacing it in a CLI lets designers verify content without spinning up the renderer.
2026-05-06 13:34:23 -07:00
"--info-attachments", "--info-particles", "--info-sequences",
feat(editor): add --list-zone-meshes inventory command Companion to --list-zone-textures. Walks every WOM under a zone dir and reports per-mesh size, vertex/triangle counts, bone/anim/batch counts, and texture-ref counts. Both human- readable table and --json output supported. Useful for "how heavy is this zone" budgeting and verifying that bootstrapping orchestrators (gen-zone-mesh-pack, gen-zone- starter-pack) produced what they claim.
2026-05-08 01:01:18 -07:00
"--info-bones", "--export-bones-dot",
feat(editor): add --list-zone-audio inventory command Inventories every WAV under <zoneDir>/audio/ with stats parsed straight from the RIFF/WAVE header: sample rate, channel count, bit depth, duration. Both human-readable table and --json output supported. Completes the per-zone asset accounting trio alongside --list-zone-meshes and --list-zone-textures.
2026-05-08 02:38:55 -07:00
"--list-zone-meshes", "--list-zone-audio", "--list-zone-textures",
feat(editor): add --list-project-audio inventory command Project-wide companion to --list-zone-audio. Walks every zone in <projectDir> and reports per-zone WAV count + bytes + total duration, plus a project grand total. Reuses the RIFF/WAVE header parse from list-zone-audio. Completes the project-scope inventory trio alongside --list-project-meshes and --list-project-textures.
2026-05-08 06:10:18 -07:00
"--list-project-meshes", "--list-project-audio",
"--list-project-textures",
feat(editor): add --info-project-models-total for cross-zone WOM/WOB rollup Project-wide companion to --info-zone-models-total. Walks every zone in <projectDir>, sums verts/tris/bones/anims/batches per WOM and groups/ verts/tris/doodads/portals per WOB, then prints a per-zone breakdown table plus a TOTAL row. Both human (table) and --json output modes. Useful for capacity planning across an entire content project — e.g. "how many bones across all my creatures" or "total triangles per frame if every model loaded simultaneously." Verified on the 2-zone migration test project: per-zone counts match --info-zone-models-total output, totals row aggregates correctly, JSON form parses cleanly. Brings command count to 170.
2026-05-06 20:25:00 -07:00
"--info-zone-models-total", "--info-project-models-total",
fix(editor): un-shadow zone mesh detail view as -detail variant Mirrors the --list-project-meshes-detail rename from 976549fe. After the c0f2ab75 inventory extraction, the older per-mesh sorted-by-tris listing was shadowed by the per-zone aggregate that now lives in cli_zone_inventory.cpp. Renames the older handler to --list-zone-meshes-detail (and updates its help text + kArgRequired entry) so both views coexist: --list-zone-meshes — per-zone aggregate (extracted) --list-zone-meshes-detail — sorted-by-tris listing Removes the last duplicate-flag dead code from main.cpp.
2026-05-08 19:28:18 -07:00
"--list-zone-meshes-detail", "--list-project-meshes-detail", "--info-mesh",
feat(editor): add --info-mesh-storage-budget byte-category breakdown Estimated bytes-per-category breakdown for a single WOM. Numbers are based on the in-memory struct sizes (vertex 40B, index 4B, bone 22B, batch 16B, anim keyframe 44B, plus texture path strings) — not the actual on-disk encoding (which has framing overhead) — but the relative shares are accurate and help users decide where shrinking efforts pay off. Surfaces actionable tips when a category dominates: animations > vertices → suggest --strip-mesh --anims with the saved KB; bones non-trivial → suggest --bones for static placement; vertices dominate → suggest a lower-poly variant. Verified on procedural cube: 960B vertices (85%) + 144B indices (13%) + 16B batches + 8B textures, total 1128 estimated vs 1184 on-disk (~5% framing overhead). Tip correctly fires for vertex-dominated mesh. Brings command count to 231.
2026-05-07 09:00:47 -07:00
"--info-mesh-storage-budget",
feat(editor): add --info-textures and --info-doodads detailed inspectors Two more drill-down inspectors that complement --info-batches: wowee_editor --info-textures HumanMale.wom WOM textures: HumanMale.wom (3 textures) idx blp png path 0 y y Character/Human/Male/HumanMaleHair.blp 1 y - Character/Human/Male/HumanMaleBody.blp 2 - - Character/Human/Male/HumanMaleEye.blp wowee_editor --info-doodads Stormwind.wob WOB doodads: Stormwind.wob (3 placements) idx scale pos (x, y, z) rot (x, y, z) model 0 1.50 ( 1.0, 0.0, 1.0) ( 0.0, 90.0, 0.0) Furniture/Chair.wom ... --info-textures: cross-checks each referenced texture against both the proprietary BLP and the open PNG sidecar on disk (each lookup tries the literal path AND falls back to Data/<lowercased path> since WoW assets are case-sensitive on Linux but designers usually type Mixed Case). The y/- columns let you spot which textures are missing before --pack-wcp would fail at runtime. --info-doodads: model path + position + rotation + scale per instance. Companion to --info-textures (GPU resources) — this tracks scene composition. Both have --json mode that emits per-entry records with index for programmatic consumption. Verified on synthesized model with 3 texture refs + building with 3 doodads; all fields render correctly.
2026-05-06 13:19:45 -07:00
"--info-wob", "--info-woc", "--info-wot",
fix(cli): error on non-GUI options that are missing their argument Previously '--info-wcp' (no path) silently dropped into the GUI because the option-parse loop's i+1<argc guard hid the typo. Pre- scan and bail out with a helpful message before trying to start the editor, so users get fast feedback on bad invocations.
2026-05-06 08:08:05 -07:00
"--info-creatures", "--info-objects", "--info-quests",
feat(editor): add --info-extract-budget for sortable extract-dir byte breakdown Companion to --info-pack-budget (which operates on .wcp archives). Per-extension byte breakdown of an extract dir, sorted largest-first. Answers 'where did my 31 GB extract go?' with a flat sortable table: wowee_editor --info-extract-budget /home/k/Desktop/wowee/Data Extract budget: /home/k/Desktop/wowee/Data total: 284613 file(s), 31482.11 MB ext count bytes MB share .adt 11213 11985924414 11430.7 36.3% .wav 39396 8107038542 7731.5 24.6% .blp 133742 4990640480 4759.4 15.1% .m2 48466 2568180656 2449.2 7.8% .wmo 16526 2286454107 2180.5 6.9% .mp3 1222 1976864519 1885.3 6.0% ... Caps to top 30 extensions with the rest rolled into '(other)' so big extracts (this one has 30+ format types) don't drown the output. Pairs with --info-extract-tree (hierarchical view) and --info-extract (sidecar coverage) — three lenses on an extract directory: structure, formats, byte costs. Verified on a real 31GB Data/ extract: ADT files dominate at 36% (11GB), with WAV audio second at 25% (8GB).
2026-05-06 18:33:29 -07:00
"--info-extract", "--info-extract-tree", "--info-extract-budget",
"--list-missing-sidecars",
feat(editor): add --info-pack-budget for per-extension WCP byte breakdown Where --info-wcp shows file counts per category, this drills into per-extension byte costs so users can spot what's bloating an archive before shipping: wowee_editor --info-pack-budget custom_zones/MyZone.wcp WCP budget: custom_zones/MyZone.wcp total: 47 file(s), 2.34 MB ext count bytes KB share .whm 4 1683456 1644.0 70.3% .wob 3 451200 440.6 18.8% .wom 12 163840 160.0 6.8% .json 8 85120 83.1 3.6% .woc 1 12672 12.4 0.5% Sorted by bytes descending so the heaviest contributors surface first. Useful for: - Spotting accidental .glb/.obj inclusion in shipping packs (`--pack-wcp` should run after `--strip-zone` to keep derived outputs out) - Capacity budgeting when targeting a max-pack-size - Comparing pre/post compression ratios Pairs with --info-wcp (counts), --list-wcp (full file list), --diff-wcp (compare two packs), --info-pack-budget (this one, byte costs). Verified on a freshly-mvp-zone packed WCP: 6 files / 0.17 MB correctly broken down (whm 84%, wot 14.9%, json 1.1%).
2026-05-06 17:38:28 -07:00
"--info-png", "--info-jsondbc", "--info-blp", "--info-pack-budget",
feat(editor): add --info-pack-tree for WCP directory hierarchy view Tree view of a WCP archive's contents with per-file byte sizes. --list-wcp shows the flat sorted file list; this gives the hierarchical view that's easier to read for archives with subdirectories: wowee_editor --info-pack-tree custom_zones/MyZone.wcp custom_zones/MyZone.wcp (47 files, 2348.21 KB) ├─ Forest_28_30.whm (150540 bytes) ├─ Forest_28_30.wot (26685 bytes) ├─ buildings/ │ ├─ inn.wob (45120 bytes) │ └─ tavern.wob (38104 bytes) ├─ creatures.json (694 bytes) ├─ data/ │ ├─ Spell.json (15032 bytes) │ └─ Item.json (8194 bytes) ├─ objects.json (234 bytes) └─ zone.json (500 bytes) Recursive renderer with UTF-8 box-drawing connectors. Files show their byte size; directories show the subtree subtotal aggregated from children. Children sorted alphabetically (std::map). Pairs with --info-pack-budget (per-extension byte breakdown) and --list-wcp (flat sorted list) — three lenses on the same archive: hierarchy / extension cost / flat search. Verified on a 6-file mvp-zone WCP: tree correctly shows top-level files (no subdirs in mvp-zone output) with byte sizes and total 175 KB summary.
2026-05-06 19:17:42 -07:00
"--info-pack-tree",
feat(editor): add --info-adt proprietary terrain inspector Completes the proprietary-format inspector lineup. Pairs naturally with --info-wot / --info-whm (the open WOT/WHM equivalents) so users can verify the conversion preserves chunk counts, doodad placements, and WMO references: wowee_editor --info-adt World/Maps/Azeroth/Azeroth_32_48.adt ADT: ... version : 18 file bytes : 450192 coord : (0, 0) chunks loaded : 256/256 height range : [-0.00, 0.00] hole chunks : 0 (with cave/gap masks) water chunks : 0 textures : 0 doodad names : 0 (0 placements) wmo names : 1 (1 placements) Reports loaded chunk count (out of fixed 256), height min/max across all loaded chunks (with NaN guard so corrupted heights don't poison the range), hole chunks (cave/gap masks), water chunks, texture and doodad/WMO name table sizes, and placement counts. Verified on a real WoW ADT (ahnqirajtemple_29_46.adt, 450KB): correctly reports 256/256 chunks loaded, 1 WMO name + 1 placement. JSON mode emits structured output for CI scripts. The format-inspector lineup is now complete: Proprietary: BLP / DBC / M2 / WMO / ADT Open: PNG / JSON DBC / WOM / WOB / WOC / WOT/WHM / WCP Every format on both sides of the open-format bridge has an inspector.
2026-05-06 12:55:31 -07:00
"--info-m2", "--info-wmo", "--info-adt",
feat(editor): add --info-project-overview project-wide health check Project-wide companion to --info-zone-overview. Single-page table with one row per zone showing biome / tile count / creature / object / quest / item counts and audio yes-or-no, plus aggregate totals across the project. Useful for "what's in this project" at-a-glance reviews and CI artifacts that need a compact status snapshot. Cheap content counts via direct JSON parse (same approach as --info-zone-overview) so even a 100-zone project takes milliseconds. Verified on 3-zone gen-random-project run: per-zone rows show identical counts (5c/2o/3i each), totals row aggregates correctly to 15c/6o/9i.
2026-05-07 19:13:11 -07:00
"--info-zone", "--info-zone-overview", "--info-project-overview",
feat(editor): add --copy-project recursive project tree copy Recursively copies an entire project tree (every zone subdir + manifests + content files). Refuses to overwrite an existing destination so a typo doesn't silently merge into the wrong project — user must delete the destination first if intentional. Reports zone count, total file count, and total byte count of what was copied. Useful for forking a project for experimentation, or for creating snapshot backups before risky bulk operations like --strip-data-tree or --remove-project-orphans. Verified: 2-zone gen-random-project source → copy-project → "zones: 2, files: 12, total bytes: 395989" reported correctly, existing destination correctly rejected.
2026-05-07 19:31:09 -07:00
"--copy-project", "--info-wcp", "--list-wcp",
feat(editor): add --list-{creatures,objects,quests} for indexed enumeration Verbose enumeration of every entry, complementing the existing --info-* (summary counts) and unblocking --remove-* (which takes a 0-based index). wowee_editor --list-creatures custom_zones/Z/creatures.json creatures.json: custom_zones/Z/creatures.json (2 total) idx name lvl display pos (x, y, z) 0 Wolf 7 11430 (100.0, 200.0, 50.0) 1 Black Bear 12 11445 (110.0, 210.0, 55.0) The 'idx' column is exactly what --remove-creature/object/quest takes, closing the workflow loop: wowee_editor --list-creatures $Z/creatures.json | grep -i 'wolf' | awk '{print $1}' | xargs -I{} wowee_editor --remove-creature $Z {} Each command has matching --json mode that emits per-entry records with index, key fields, and position. Verified on a synthesized zone with 2 creatures + 2 objects + 2 quests; tables align, indices match, JSON is well-formed and round-trips through jq cleanly.
2026-05-06 12:03:55 -07:00
"--list-creatures", "--list-objects", "--list-quests",
feat(editor): add --list-quest-objectives and --list-quest-rewards --list-quests shows the quest roster but doesn't drill into objectives or item rewards (--info-quests just counts). These complete the detail picture and unblock --remove-quest-objective by exposing the 0-based objIdx the user needs: wowee_editor --list-quest-objectives custom_zones/Z/quests.json 0 Quest 0 ('Hunt'): 3 objective(s) idx type count target description 0 kill 5 Wolf Slay 5 Wolf 1 collect 3 Pelt Collect 3 Pelt 2 talk 1 Mayor Talk to Mayor wowee_editor --list-quest-rewards custom_zones/Z/quests.json 0 Quest 0 ('Hunt') rewards: xp : 999 coin : 5g 30s 99c items : 2 [0] Item:Sword [1] Item:Shield Both have --json mode for CI/scripting. Range-check questIdx and exit 1 on out-of-range with a precise message. Verified: scaffolded zone, added quest with 3 objectives + 2 items + full coin reward; both listings show the right data, JSON output is well-formed and enumerable.
2026-05-06 12:42:17 -07:00
"--list-quest-objectives", "--list-quest-rewards",
feat(editor): add --info-object completing the single-entity inspector trio Symmetric to --info-creature and --info-quest. Every PlacedObject field for one entry: wowee_editor --info-object $Z/objects.json 3 Object [3] type : wmo path : World/StaticObject/Stormwind/HumanInn.wmo nameId : 3497721408 uniqueId : 4 position : (-8412.300, 633.200, 110.500) rotation : (0.00, 90.00, 0.00) deg scale : 1.000 Useful when debugging a misplaced object — quickly see the exact position/rotation/scale + uniqueId + nameId without having to grep through objects.json or run --list-objects through awk. JSON mode emits the structured record. Inspector lineup is now symmetric across all three content types: --info-{creatures,objects,quests} aggregate counts --list-{creatures,objects,quests} per-entry table --info-{creature,object,quest} single-entry deep dive
2026-05-06 14:22:08 -07:00
"--info-creature", "--info-quest", "--info-object",
feat(editor): add --info-quest-graph-stats for chain topology analysis Where --export-quest-graph visualizes the quest dependency graph, this quantifies it. Useful for spotting authoring issues (orphan quests that only appear as one-offs, broken chains via cycles) and getting a sense of quest density: wowee_editor --info-quest-graph-stats $Z/quests.json Quest graph: $Z/quests.json total quests : 4 roots : 2 (no inbound chain — entry points) leaves : 2 (no outbound chain — terminal) orphans : 1 (root AND leaf — one-shot) cycles : 0 max depth : 3 avg depth : 2.00 (chain length per root) Definitions: roots = quests no other quest chains TO (player entry points) leaves = quests with no nextQuestId or nextQuestId pointing to a missing quest (terminal — chain ends here) orphans = root AND leaf (one-shot quests with no neighbors) cycles = number of roots whose forward walk hits a node twice maxDepth = longest path from any root forward through the chain avgDepth = mean path length across all roots Cycle-guarded forward walk uses a visited-set per root, so the cycle count is bounded even on intentionally-broken inputs. Exit 1 if cycles > 0 so CI can gate before shipping a broken chain. JSON mode emits all six stats for dashboard consumption. Verified on 4-quest zone (Q1→Q2→Q3 chain + Loner orphan): correctly reports 2 roots, 2 leaves, 1 orphan, 0 cycles, max depth 3, avg depth 2.00.
2026-05-06 16:17:30 -07:00
"--info-quest-graph-stats",
feat(editor): add --info-creatures-by-faction + --info-creatures-by-level Two analytics commands for combat-balance work. Where --info-creatures gives totals + behavior counts, these give the distributions: wowee_editor --info-creatures-by-faction $Z/creatures.json Creatures by faction: ... (47 total) faction count share 7 12 25.5% 14 29 61.7% 35 6 12.8% (factions: 7=human, 14=monster, 35=neutral, etc.) wowee_editor --info-creatures-by-level $Z/creatures.json Creatures by level: ... (47 total) range : 5 to 32 (avg 14.2) level count bar 5 4 ████████████████████████████████████████ 6 3 ██████████████████████████████ ... 30 1 ██████████ Faction histogram catches single-faction zones (one giant melee) and mixed-faction tuning issues. Level histogram catches difficulty-curve problems (cluster at 5, gap, cluster at 30) and outlier spawns (level-60 boss accidentally placed in starter area). ASCII bar chart for level distribution since gameplay tuning is visual — '60% of mobs are levels 8-12 with a long tail' is more intuitive as a bar than as numbers. Bars scale to longest bin so small zones still get usable visualization. JSON mode emits per-faction / per-level records for dashboards. Verified on a 4-creature seed (3×faction-14 + 1×faction-35; levels 7/8/12/30): faction percentages and level range/avg both correct.
2026-05-06 17:13:44 -07:00
"--info-creatures-by-faction", "--info-creatures-by-level",
feat(editor): add --info-objects-by-path + --info-objects-by-type analytics Object-side counterparts to --info-creatures-by-faction/-level. Two analytics commands for placement audits: wowee_editor --info-objects-by-path $Z/objects.json Objects by path: ... (47 total, 12 unique) count share path 18 38.3% World/Generic/Tree.m2 9 19.1% World/Generic/Lamp.m2 4 8.5% World/Building/Inn.wmo ... wowee_editor --info-objects-by-type $Z/objects.json Objects by type: ... M2 : 38 (scale 0.80-2.50, avg 1.12) WMO : 9 (scale 1.00-1.00, avg 1.00) --info-objects-by-path: most-used model paths first. Catches 'this looks repetitive, diversify the doodads' design feedback and surfaces texture-budget hot spots (one model used 50× pulls its textures into the working set 50×). --info-objects-by-type: M2 vs WMO split + per-type scale stats. Catches scale outliers ('this WMO is at 0.001 scale, did you mean 1.0?') and gives composition sense (mostly props vs mostly buildings). JSON modes emit per-path / per-type records for dashboards. Verified on a 4-object seed (3 M2 + 1 WMO with mixed scales): correctly reports Tree.m2 used 2× (50%), M2 scale range 0.80-1.50 avg 1.10.
2026-05-06 17:46:51 -07:00
"--info-objects-by-path", "--info-objects-by-type",
feat(editor): add --info-quests-by-level + --info-quests-by-xp analytics Quest-side analytics paralleling --info-creatures-by-faction/-level. Two distribution views for difficulty-curve and reward-pacing analysis: wowee_editor --info-quests-by-level $Z/quests.json Quests by required level: ... (47 total) range : 1 to 60 (avg 22.4) level count bar 1 8 ████████████████████████████████████████ 5 6 ██████████████████████████████ ... 60 1 █████ wowee_editor --info-quests-by-xp $Z/quests.json Quests by XP reward: ... (47 total) range : 100 to 5000 (avg 1462, 0 with 0 XP) bucket (≥XP) count bar 0 8 ████████████████████████████████████████ 250 6 ██████████████████████████████ 500 4 ████████████████████ 5000 1 █████ (bucket size: 250 XP) --by-level: catches difficulty-curve gaps (every quest level 1 → no mid-game; cluster at 60 → no early game) and outliers (level-30 quest dropped into a starter zone). --by-xp: bucket size auto-grows with the max XP value so the histogram stays readable for both starter zones (10-100 XP per bin) and endgame (5000+ XP per bin). Surfaces no-reward quests explicitly so designers spot ones they forgot to fill in. JSON modes emit per-bucket records for dashboards. Verified on a 4-quest seed (xp 100/250/500/5000): bucket-size correctly auto- selected as 250 XP, range and avg match.
2026-05-06 18:20:37 -07:00
"--info-quests-by-level", "--info-quests-by-xp",
feat(editor): add --info-extract CLI for extraction coverage report Walks an extracted asset tree and reports per-format counts plus how many proprietary files have a wowee open-format sidecar. Lets users (or CI) see at a glance whether asset_extract was run with --emit-open and how complete the open-format coverage is: BLP textures : 12340 (12340 PNG sidecar = 100.0% open) DBC tables : 240 (240 JSON sidecar = 100.0% open) M2 models : 8500 (0 WOM sidecar = 0.0% open) ... overall open-format coverage: 41.2% (run `asset_extract --emit-open` to fill missing sidecars) Skips _NNN group sub-files when counting WMOs (only the root WMO ships with a WOB sidecar). The headless CLI is now at 22 commands.
2026-05-06 10:50:17 -07:00
"--unpack-wcp", "--pack-wcp",
feat(editor): add --validate-woc + --validate-whm and roll into validate-all Round out the per-format validator suite. Open-format zone validation now covers all four binary formats: --validate-wom Tree --validate-wob House --validate-woc terrain.woc --validate-whm Zone_28_30 --validate-all custom_zones/Zone1 # runs everything WOC checks: finite vertex coords on every triangle, no degenerate triangles (two verts identical), known flag bits only (0x0F mask), tile coords within WoW grid (< 64), bounds.min <= bounds.max. WHM/WOT checks: finite heights across all 145 verts/chunk, finite chunk position vectors, tile coord in [0, 64), reasonable height envelope ([-10000, 10000] is a generous outer bound — beyond that suggests units confusion), placements have finite positions and nameId within doodadNames/wmoNames table size. validate-all now reports all four format counts (WOM/WOB/WOC/WHM) and aggregates errors. Verified end-to-end: a fresh scaffolded zone with --build-woc yields 256/256 chunks loaded, 32768 walkable triangles, validate-all PASSED. Synthesized WOC with 0xFF flags correctly fails with 'unknown flag bits 0xFF' and exit 1.
2026-05-06 11:58:20 -07:00
"--validate", "--validate-wom", "--validate-wob", "--validate-woc",
feat(editor): add --validate-project for whole-project validation gate Multi-zone wrapper around --validate-all. Walks every zone in a project and runs the per-format validators (WOM/WOB/WOC/WHM). Aggregates pass/fail per zone with file-level breakdown: wowee_editor --validate-project custom_zones validate-project: custom_zones zones : 12 (1 failed) zone files failed errors status AshenForest 47 0 0 PASS BoneOasis 31 0 0 PASS CrystalCaverns 28 2 14 FAIL ... 1 zone(s) failed validation Designed for CI gates before --pack-wcp (or before tagging a release): one command checks the whole project's binary integrity, exits 1 if anything's broken with a clear breakdown of which zone went wrong. Pairs with --validate-all (single-zone, all formats) and the per-format validators (--validate-wom etc.). Three levels of granularity now: --validate-{wom,wob,woc,whm} single file --validate-all single zone (or any dir) --validate-project entire project JSON mode emits per-zone records (totalFiles + failedFiles + totalErrors) for dashboard consumption. Verified on a 2-zone project with one tile having .woc built and one without — both zones PASS, exit 0.
2026-05-06 17:21:57 -07:00
"--validate-whm", "--validate-all", "--validate-project",
feat(editor): add --bench-audit-project per-step perf breakdown Times each --audit-project sub-step end-to-end so users can see where the slow checks are. Useful for tuning a CI pipeline: drop the slowest check from a fast-feedback pre-commit hook, run the full audit on push. Reports wall-clock per step, share of total, and pass/fail status for each. Status column means the check ran cleanly even on a zone with content issues — bench timings are about runtime, not correctness. On a small test zone, items-schema and spawn-placement dominate the share (~25% each) since they involve loading content + sampling terrain. Format/open-only/refs/content are sub-10ms each.
2026-05-07 21:40:49 -07:00
"--validate-project-open-only", "--audit-project", "--bench-audit-project",
feat(editor): add --bench-bake-project for terrain-load timing analysis Companion to --bench-validate-project. Times the WHM/WOT load step (the dominant cost in --bake-zone-glb/obj/stl) per zone. The actual write side adds ~constant cost proportional to vertex count, so load time is a strong proxy for bake cost: wowee_editor --bench-bake-project custom_zones Bench bake (load-only): custom_zones zones : 12 total : 4731.20 ms (terrain load) per zone : avg=394.27 min=87.42 max=2103.55 ms slowest : Stranglethorn (2103.55 ms) Per-zone: zone ms tiles chunks ms/tile AshenForest 87.42 1 256 87.42 BoneOasis 245.10 4 1024 61.27 Stranglethorn 2103.55 9 2304 233.73 Useful for tracking 'has my latest geometry change made baking 3× slower?' across releases. Per-tile timing surfaces zones with high-variance chunk loads (e.g. dense doodad placements that inflate ADT load time). Pairs with --bench-validate-project (validation timing). Both use std::chrono::steady_clock for monotonic measurement; JSON modes emit per-zone records for CI dashboard consumption. Verified on a 2-zone project (Forest 2 tiles + Desert 1 tile): correctly reports per-zone timings + ms/tile ratio.
2026-05-06 18:50:20 -07:00
"--bench-validate-project", "--bench-bake-project",
feat(editor): add --list-data-tree-largest for migration prioritization Top-N largest proprietary files (.m2/.wmo/.blp/.dbc) in <srcDir>. Helps users decide what to migrate first when sequencing the work across a large extracted Data tree — convert the heaviest files first to free the most disk space soonest. Each row annotates whether an open sidecar already exists ("migrate") or is still pending ("pending"), so the heavy hitters that are already migrated are visible at a glance. Default N = 20 (one terminal page); pass an explicit N for a different cutoff. Header reports total proprietary bytes plus the share captured by the top-N rows so users know how much of the work the displayed list represents. Verified: 3-file mixed tree (100/50/10 KB) → ranked descending by size, .m2 (with sidecar) shows "migrate", others show "pending", total/shown bytes match. Brings command count to 192.
2026-05-07 00:33:34 -07:00
"--bench-migrate-data-tree", "--list-data-tree-largest",
feat(editor): add --gen-mesh-textured one-shot mesh+texture composer Pairs --gen-mesh and --gen-texture into a single call, then patches the resulting WOM so its texturePaths[0] points at the freshly- written PNG sidecar. Output is a textured model that renders out of the box — no need to chain three commands by hand and remember the relative-path conventions. Layout: <wom-base>.wom — mesh with texturePaths[0] = "<base>.png" <wom-base>.png — 256x256 texture (color or pattern spec) The PNG path stored in the WOM is just the leaf — the runtime resolves textures relative to the model file's own directory, so the bound model is portable as long as the .wom and .png ship together. Verified end-to-end: textured cube emits both files, --info-batches shows "check.png" in the texture column for batch 0 (proving the binding is permanent in the saved WOM, not just in memory). Brings command count to 202.
2026-05-07 02:32:43 -07:00
"--export-data-tree-md", "--gen-texture", "--gen-mesh", "--gen-mesh-textured",
feat(editor): add --add-texture-to-zone for importing existing PNGs Imports an existing PNG into a zone directory. Companion to --gen-texture (procedural placeholder) for the "I have an artist- painted texture, get it into my project" workflow. Optional <renameTo> argument lets the user store the PNG under a project- specific name. Safety: - Refuses non-.png input with a hint to use --convert-blp-png first (so .blp/.tga don't get silently shoved into a tree that won't render them) - Auto-appends .png to renameTo if user supplied just a stem - Idempotent re-runs: byte-identical destination → no-op exit 0 - Different-content destination → refuses to overwrite, exit 1 Closing line suggests --add-texture-to-mesh as the next step so the user has the full workflow in front of them. Verified all five paths: plain copy, rename+auto-ext, idempotent re-run (no-op exit 0), conflict (different bytes, exit 1), wrong extension (.blp, exit 1). Brings command count to 208.
2026-05-07 04:00:21 -07:00
"--add-texture-to-mesh", "--add-texture-to-zone",
feat(editor): add --gen-mesh-disc circular flat plane primitive Flat circular disc on XY centered at origin. Center vertex + ring of <segments>+1 vertices (extra one to break the UV seam), indexed as a fan. Useful for magic circles, coin meshes, lily pads, top caps for cylinders the user wants without making a full cylinder, table tops, etc. UV mapping is centered (0.5, 0.5) at the disc's center and unit-circle-aligned at the rim, so radial textures (like the new --gen-texture-rings) align correctly. Args: <wom-base> [radius] [segments] Defaults: radius 1.0, segments 32. Hard-capped at 1024 segments. Verified: radius 0.5 / segments 24 produces 26 verts / 24 tris.
2026-05-07 17:27:33 -07:00
"--gen-mesh-stairs", "--gen-mesh-grid", "--gen-mesh-disc",
feat(editor): add --gen-mesh-arch doorway/portal frame Builds a doorway arch from two rectangular columns (one on each side of the opening) plus a semicircular curved band across the top. Total height = openingHeight + archRadius (where archRadius = openingWidth/2). Aligned so the inside of the opening is centered on the Y axis. Args: <wom-base> [openingW] [openingH] [thickness] [depth] [segments] Defaults: 1.0 / 1.5 / 0.2 / 0.3 / 12. Curve segments hard-capped at 256. Useful for cave entrances, gates, portal frames, dungeon thresholds. The 12th procedural primitive (joining cube/plane/ sphere/cylinder/torus/cone/ramp/grid/disc/tube/capsule). Verified: 1.0×1.5 opening with 12 segments produces 96 verts / 48 tris, bounds Z spans 0..2.0 (= 1.5 + 0.5 arch radius).
2026-05-07 19:50:00 -07:00
"--gen-mesh-tube", "--gen-mesh-capsule", "--gen-mesh-arch",
feat(editor): add --gen-mesh-tree composite tree primitive Procedural tree: cylindrical trunk (12 segments) + UV-sphere foliage (12 segs × 8 stacks). Foliage centered above the trunk with a slight overlap so the trunk pokes into the bottom of the canopy. Useful for ambient zone decoration, distant tree placeholders, magic-grove props. The 15th procedural primitive — composite of cylinder + sphere with everything in a single batch so it ships as one mesh. Args: <wom-base> [trunkRadius] [trunkHeight] [foliageRadius] Defaults: 0.1 / 2.0 / 0.7 (3.2y total height — small/medium tree). Pairs naturally with --add-texture-to-mesh for the bark+leaf textures, or just one composite texture since this is a single- batch mesh. Verified: defaults produce 143 verts / 216 tris.
2026-05-07 22:19:51 -07:00
"--gen-mesh-pyramid", "--gen-mesh-fence", "--gen-mesh-tree",
feat(editor): add --gen-mesh-bridge plank bridge primitive Procedural plank bridge: deck of N axis-aligned planks running along the length with small gaps between, optional side rails (top rail + 3 posts each side). Length runs along +X, width along Z. Pass railHeight=0 to skip rails for a simpler footbridge. Defaults: length=6, width=2, planks=6, railHeight=1. Useful for river crossings, dungeon catwalks, scenic overlooks. Brings the procedural mesh primitive set to 18.
2026-05-08 03:29:03 -07:00
"--gen-mesh-rock", "--gen-mesh-pillar", "--gen-mesh-bridge",
feat(editor): add --gen-mesh-fountain basin + spout primitive Procedural fountain: low cylindrical basin with a narrower spout column rising from its center. Solid (not hollow) for simplicity but still reads as a fountain because of the spout silhouette. Cylinder helper builds side ring + top/bottom caps so basin and spout share the same construction. Defaults: basin r=1.5 h=0.5, spout r=0.2 h=1.5. Useful for town squares, plazas, garden centerpieces. Brings the procedural mesh primitive set to 21.
2026-05-08 09:29:02 -07:00
"--gen-mesh-tower", "--gen-mesh-house", "--gen-mesh-fountain",
feat(editor): add --gen-mesh-portal doorway frame primitive Procedural doorway: two vertical post boxes plus a horizontal lintel box across the top. Posts run along the Z axis (so width spans Z), the opening faces +X. Pass lintelHeight=0 to skip the lintel for two free-standing posts. Defaults: 2.5w × 4h, post thickness 0.4, lintel 0.5. Useful for entrances, gates, magical portals, ruins, walls. Brings the procedural mesh primitive set to 24.
2026-05-08 14:42:56 -07:00
"--gen-mesh-statue", "--gen-mesh-altar", "--gen-mesh-portal",
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
"--gen-mesh-archway", "--gen-mesh-barrel", "--gen-mesh-chest",
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
"--gen-mesh-anvil", "--gen-mesh-mushroom", "--gen-mesh-cart",
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
"--gen-mesh-banner", "--gen-mesh-grave", "--gen-mesh-bench",
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
"--gen-mesh-shrine", "--gen-mesh-totem", "--gen-mesh-cage",
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
"--gen-mesh-throne", "--gen-mesh-coffin", "--gen-mesh-bookshelf",
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
"--gen-mesh-table", "--gen-mesh-lamppost", "--gen-mesh-bed",
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
"--gen-mesh-ladder", "--gen-mesh-well", "--gen-mesh-signpost",
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
"--gen-mesh-mailbox", "--gen-mesh-tombstone", "--gen-mesh-crate",
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
"--gen-mesh-stool", "--gen-mesh-cauldron", "--gen-mesh-gate",
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
"--gen-mesh-beehive",
feat(editor): add --gen-mesh-disc circular flat plane primitive Flat circular disc on XY centered at origin. Center vertex + ring of <segments>+1 vertices (extra one to break the UV seam), indexed as a fan. Useful for magic circles, coin meshes, lily pads, top caps for cylinders the user wants without making a full cylinder, table tops, etc. UV mapping is centered (0.5, 0.5) at the disc's center and unit-circle-aligned at the rim, so radial textures (like the new --gen-texture-rings) align correctly. Args: <wom-base> [radius] [segments] Defaults: radius 1.0, segments 32. Hard-capped at 1024 segments. Verified: radius 0.5 / segments 24 produces 26 verts / 24 tris.
2026-05-07 17:27:33 -07:00
"--gen-texture-gradient",
feat(editor): add --export-mesh-heightmap, inverse of gen-mesh-from-heightmap Extracts a grayscale heightmap PNG from a row-major W×H heightmap mesh. Y values are normalized to 0..255 using the mesh bounds so the output PNG uses the full dynamic range. User supplies W and H explicitly: arbitrary meshes aren't necessarily heightmap-shaped, and taking the dimensions as args avoids guessing wrong on a mesh with vertex count W*H but a different layout. Round-trips with --gen-mesh-from-heightmap modulo the 1-byte quantization step. Verified: noise PNG (32×32) → heightmap mesh → exported PNG (32×32) chain executes cleanly, height 0..1.984 mapped to 0..255 grayscale, both PNGs share the same dimensions. Brings command count to 230.
2026-05-07 08:46:50 -07:00
"--gen-mesh-from-heightmap", "--export-mesh-heightmap",
feat(editor): add --displace-mesh for heightmap displacement on existing meshes Offsets each vertex along its current normal by heightmap brightness × scale. UVs determine where each vertex samples the heightmap; sampling uses bilinear filtering with UV-wrap so repeating UVs tile correctly. Pairs naturally with --gen-mesh-grid: gen a flat grid, then --displace-mesh with a noise PNG to create procedural terrain. Or use it on a sphere to make a bumpy planet, on a cylinder for tree- bark deformation, etc. Output reports the actual delta range produced so the user can gauge the scale. A hint suggests running --smooth-mesh-normals afterward since the post-displacement shading would otherwise follow the original (now-stale) flat normals. Verified pipeline: --gen-mesh-grid (32×32, 1089 verts) → --gen- texture-noise → --displace-mesh (scale 2) → bounds X/Y stay ±5 while Z spans 0..1.93.
2026-05-07 16:53:36 -07:00
"--displace-mesh",
feat(editor): add --strip-mesh for shrinking animated meshes to static-only Drops bones and/or animations from a WOM in place. Use case: a model imported with full skeleton + anims that will only ever be placed as static decoration — there's no point shipping the bone data, and stripping it shrinks the file substantially. Flags: --bones drop bones AND animations (anims reference bones, so keeping anims with no bones is meaningless). Vertex skinning weights reset to identity-on-bone-0 so a renderer that expects them doesn't read stale indices. --anims drop only animations (keep bones for posed-but-static use) --all shorthand for --bones Default (no flags) refuses with exit 1 so the user explicitly opts in to destruction. Unknown flags also fail. Reports before/after counts and byte delta so the user sees what they saved. Verified: no-flags refuses; --all on already-static cube reports 0→0 / +0 bytes correctly; --foo rejected. Brings command count to 217.
2026-05-07 06:09:46 -07:00
"--scale-mesh", "--translate-mesh", "--strip-mesh",
feat(editor): add --gen-texture-noise-color two-color noise blends Same value-noise function as --gen-texture-noise but interpolated between two RGB endpoints rather than emitted as grayscale. Useful for terrain detail (grass+dirt mottle), magic fog, marble veining, or any "natural variation" pass that shouldn't be desaturated. Args: <out.png> <colorAHex> <colorBHex> [seed] [W H] Defaults: seed 1, 256x256. 11th procedural texture pattern (joining solid, BW checker, color checker, grid, vertical/horizontal/radial gradients, grayscale noise, stripes, dots, rings).
2026-05-07 21:22:33 -07:00
"--gen-texture-noise", "--gen-texture-noise-color", "--rotate-mesh",
feat(editor): add --mirror-mesh for axis mirroring with winding flip Mirrors every vertex position and normal across the chosen axis (x, y, or z). Negating just one position component reverses face winding (the triangle's signed area flips), so the second and third index of every triangle is also swapped to keep front-faces forward and lighting correct. Bone pivots mirror too. Useful for "I have a left arm, mirror it for the right arm" content reuse — the open-format mesh ecosystem can build symmetric content from one half-asset without artist round-trips. Verified: cube translated to (+5,0,0) mirrored across X → bounds correctly land at (-5.5,-0.5,-0.5)..(-4.5,0.5,0.5); 24 vertices touched / 12 triangles flipped reported; bad axis 'w' rejected exit 1. Brings command count to 225.
2026-05-07 07:39:05 -07:00
"--center-mesh", "--flip-mesh-normals", "--mirror-mesh",
feat(editor): add --smooth-mesh-normals for area-weighted normal recompute Recomputes per-vertex normals as the area-weighted average of incident face normals. The cross-product magnitude is twice the triangle area, so larger faces contribute more to the local direction — gives a clean smooth-shaded result on curved surfaces. Use cases: - Imported geometry has no normals (--import-obj leaves them zero or face-flat). - Custom transforms have desynced normals from positions. - Faceted-by-construction meshes (cube, stairs) need a smooth re-shade for stylistic reasons. Degenerate verts (unreferenced or with sum that cancels to zero — e.g., the two poles of a UV sphere) fall back to (0,1,0) rather than leaving NaN; reported separately so the user sees how many. Verified: sphere → 219 of 221 normalized + 2 degenerate poles handled cleanly; minimal triangle → 3/3 normalized. Brings command count to 229 (kArgRequired 210).
2026-05-07 08:33:20 -07:00
"--smooth-mesh-normals",
feat(editor): add --merge-meshes for combining two WOMs into one Concatenates two WOMs into a single output. Vertex buffer is the two inputs spliced; the second mesh's indices are offset by the first mesh's vertex count; texture slots from both are appended; batches from the second mesh have their indexStart shifted by the first's index count and their textureIndex shifted by the first's texture-slot count. Single-batch / no-batch inputs are auto-promoted to one synthetic batch each so the merged output is always a well-formed v3. Bones/animations are NOT merged — that requires skeleton retargeting which is out of scope. If either input has bones, the merged output is treated as static (bones cleared, weights reset to identity-on- bone-0) so renderers don't read mismatched indices. Verified: cube (24v/12t/1 batch) + sphere translated to +X (221v/ 384t/1 batch) → combined (245v/396t/2 batches/2 textures), bounds union (-0.5..3.5 in X), clean v3 reload via --info-mesh. Brings command count to 226.
2026-05-07 07:52:17 -07:00
"--merge-meshes",
feat(editor): add --gen-texture-dots polka-dot pattern Solid background with circular dots arranged on a regular grid. Useful for fabric/clothing textures, game-board patterns, mushroom caps, and decorative tiling. Args: <out.png> <bgHex> <dotHex> [radius] [spacing] [W H] Defaults: radius 8, spacing 32, 256x256. Adds the 8th procedural texture pattern (joining solid, checker, grid, vertical/horizontal/radial gradients, noise, stripes). Verified: 128x128 white-bg / red-dot at radius 12 + spacing 48 writes successfully.
2026-05-07 16:03:51 -07:00
"--gen-texture-radial", "--gen-texture-stripes", "--gen-texture-dots",
feat(editor): add --gen-texture-brick wall pattern command Procedural brick wall texture with offset rows + mortar lines. Each row alternates by half a brick width, mortar gap appears between rows and within each row. Useful for walls, chimneys, paths, and medieval-zone props. Defaults: brickW=64 brickH=24 mortarPx=4 W=H=256. Brings procedural texture pattern set to 12 commands.
2026-05-07 22:39:07 -07:00
"--gen-texture-rings", "--gen-texture-checker", "--gen-texture-brick",
feat(editor): add --gen-texture-fabric woven warp/weft pattern Procedural fabric: alternating warp (vertical) and weft (horizontal) threads on a checkerboard cell grid, with each thread shaded brighter at center and darker at edges so the weave reads as 3D yarn rather than flat checker squares. Defaults: thread=4px, W=H=256. Useful for banners, tapestries, clothing, sails. Brings the procedural texture pattern set to 15.
2026-05-08 04:47:51 -07:00
"--gen-texture-wood", "--gen-texture-grass", "--gen-texture-fabric",
feat(editor): add --gen-texture-metal brushed-metal pattern Per-pixel white noise heavily blurred along one axis (long brush strokes) and lightly along the other (thin variation across strokes), then contrast-stretched and applied as a multiplicative tint on the base color. Result: long thin streaks of varying brightness — the visual signature of brushed steel/aluminum/iron. Defaults: horizontal orientation, seed=1. Useful for armor, weapons, machinery, sci-fi panels. Brings the procedural texture pattern set to 18.
2026-05-08 12:31:54 -07:00
"--gen-texture-cobble", "--gen-texture-marble", "--gen-texture-metal",
feat(editor): add --gen-texture-snow with sparkle pass Cool-white base with low-frequency cosine luminance variation (soft uneven powdery look) plus per-pixel jitter, then a sparkle pass scatters bright single-pixel highlights at the configured density (the "ice crystals catching light" effect). Defaults: density=0.005 (~0.5% of pixels sparkle), seed=1. Useful for winter zones, snowy mountains, ice caves, frozen wastes. Brings the procedural texture pattern set to 21.
2026-05-08 19:07:41 -07:00
"--gen-texture-leather", "--gen-texture-sand", "--gen-texture-snow",
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
"--gen-texture-lava", "--gen-texture-tile", "--gen-texture-bark",
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
"--gen-texture-clouds", "--gen-texture-stars", "--gen-texture-vines",
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
"--gen-texture-mosaic", "--gen-texture-rust", "--gen-texture-circuit",
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
"--gen-texture-coral", "--gen-texture-flame", "--gen-texture-tartan",
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
"--gen-texture-argyle", "--gen-texture-herringbone",
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
"--gen-texture-scales", "--gen-texture-stained-glass",
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
"--gen-texture-shingles", "--gen-texture-frost",
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
"--gen-texture-parquet", "--gen-texture-bubbles",
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
"--gen-texture-spider-web", "--gen-texture-gingham",
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
"--gen-texture-lattice", "--gen-texture-honeycomb",
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
"--gen-texture-cracked",
feat(editor): add --info-glb-bytes for per-section GLB byte breakdown Drills into a .glb's byte composition. Pairs with --info-glb (counts) and --info-glb-tree (structure) — three lenses on the same file: wowee_editor --info-glb-bytes custom_zones/Z/Z.glb GLB bytes: custom_zones/Z/Z.glb total: 891736 bytes (0.85 MB) Sections: header : 12 bytes 0.00% JSON hdr : 8 bytes 0.00% JSON : 828 bytes 0.09% BIN hdr : 8 bytes 0.00% BIN : 890880 bytes 99.90% BufferViews: idx target bytes MB share-of-bin 0 vertex 248832 0.24 27.93% 1 vertex 248832 0.24 27.93% 2 index 393216 0.38 44.14% By attribute: INDICES 393216 bytes (44.14% of BIN) NORMAL 248832 bytes (27.93% of BIN) POSITION 248832 bytes (27.93% of BIN) Three breakdowns: - Section costs (header + JSON chunk + BIN chunk + their headers) - Per-bufferView with target hints (vertex / index / other) - Per-attribute (POSITION/NORMAL/TEXCOORD_0/INDICES/etc.) bucketed by walking accessors referenced from primitives Catches asymmetric BIN allocation ('why is INDICES 44% of my .glb?') and helps tune vertex layout decisions (drop normals if synthesized, quantize positions if precision allows). Verified on a single-tile zone bake: header+JSON is 0.1% of total, BIN is 99.9%, attribute breakdown shows POSITION/NORMAL each 28% and INDICES 44%.
2026-05-06 18:41:55 -07:00
"--validate-glb", "--info-glb", "--info-glb-tree", "--info-glb-bytes",
feat(editor): add --validate-stl for STL structural sanity check Pairs with --export-stl / --import-stl / --bake-zone-stl. Catches the corruption modes that crash slicer mesh analyzers: wowee_editor --validate-stl Tree.stl STL: Tree.stl solid name : Tree facets : 6 vertices : 18 PASSED wowee_editor --validate-stl truncated.stl STL: truncated.stl solid name : Truncated facets : 1 vertices : 2 FAILED — 3 error(s): - missing 'endsolid' footer - 1 unclosed 'facet' (missing 'endfacet') - vertex count 2 != 3 * facet count 1 Checks: - 'solid' header present - 'endsolid' footer present - Every 'facet' has matching 'endfacet' (no leaks) - Every facet has exactly 3 vertices - Total vertex count = 3 × facet count - All facet normals + vertex coords are finite (no NaN/inf) - 'facet normal' has 'normal' subtoken + 3 floats - 'vertex' has 3 floats Errors capped (30 listed) so a giant corrupt file with consistent breakage doesn't drown the report. Exit 1 on any error so CI can gate. Format-validator lineup is now complete: Open binary: WOM / WOB / WOC / WHM / GLB Open text: JSON DBC / STL Every shippable open format has a CLI validator.
2026-05-06 14:10:07 -07:00
"--validate-jsondbc", "--check-glb-bounds", "--validate-stl",
feat(editor): add --validate-blp for proprietary BLP structural check Companion to --validate-png — validates BLP textures without paying the DXT decompress cost. Useful for spot-checking thousands of BLPs in an extract dir: wowee_editor --validate-blp Texture.blp BLP: Texture.blp magic : BLP2 size : 128 x 128 valid mips : 8 file bytes : 23044 PASSED Checks (header-only, no pixel decode): - 4-byte magic is 'BLP1' or 'BLP2' - Width/height non-zero and within 8192 (texture exporter cap) - mipOffsets[16] / mipSizes[16] tables: each non-zero pair refers to a byte range within the file; mismatched (off=0 with size!=0 or vice versa) flagged - Stops at first zero offset (BLP convention for unused slots) Per-version layout differences (BLP1 has compression+alphaBits as uint32; BLP2 has compression/alphaDepth/alphaEncoding/hasMips as uint8) handled inline. Verified on real BLP (pvp-banner-emblem-1.blp): 8 valid mips, PASSED. Non-BLP file (manifest.json starting with '{'): correctly flags 'magic is {' error and exits 1. Format-validator lineup is now exhaustive across both proprietary and open formats: Proprietary: BLP / DBC (via --convert-dbc-json round-trip) Open binary: WOM / WOB / WOC / WHM / GLB Open text: JSON DBC / STL / PNG (BLP sidecar)
2026-05-06 15:07:46 -07:00
"--validate-png", "--validate-blp",
feat(editor): add --info-project-tree for multi-zone project overview Project-level tree view: every zone with quick counts + bake/viewer artifact status. --info-zone-tree drills into one zone; this gives the bird's-eye view across the whole project: wowee_editor --info-project-tree custom_zones custom_zones/ (2 zones, 2 tiles, 1 creatures, 1 objects, 1 quests) ├─ Empty/ (tiles=1, creat=0, obj=0, quest=0) │ ├─ name : Empty │ ├─ mapName : Empty │ ├─ artifacts : (none) │ └─ status : empty (only terrain) └─ Forest/ (tiles=1, creat=1, obj=1, quest=1) ├─ name : Forest ├─ mapName : Forest ├─ artifacts : .glb └─ status : populated Per-zone summary line shows counts; sub-tree shows display name, map slug, which derived artifacts have been baked (.glb / .obj / .stl / .html / ZONE.md), and a populated/empty status. Project-header line aggregates totals across all zones for the 'how big is my project?' answer in one glance. Pairs with --info-tilemap (spatial coverage) and --zone-stats (quantitative aggregate) — three different lenses on the project: spatial, quantitative, and structural.
2026-05-06 16:57:26 -07:00
"--zone-summary", "--info-zone-tree", "--info-project-tree",
feat(editor): add --info-project-bytes with open-vs-proprietary split Project-wide byte audit. Walks every zone in <projectDir>, re-uses the --info-zone-bytes categorization, and emits a per-zone breakdown table plus aggregated category totals. The headline is the open-vs-proprietary size split — surfaces how much disk a project still spends on .m2/.wmo/ .blp/.dbc payloads vs the open WOM/WOB/PNG/JSON replacements. Useful as a migration progress metric: an "open share" of 100% means the project no longer ships any proprietary Blizzard assets at rest. Verified: 2-zone test project shows 1246B open, 0B proprietary, 100% open share (the expected state after WOM-only authoring). JSON form emits the same numbers structured. Brings command count to 172.
2026-05-06 20:44:43 -07:00
"--info-zone-bytes", "--info-project-bytes",
feat(editor): add --info-project-extents for combined spatial bbox Project-wide companion to --info-zone-extents. Walks every zone in <projectDir>, computes each zone's tile XY range and Z height range, then unions them into a project-wide world bounding box. Per-zone breakdown table shows each zone's disjoint world ranges so overlap issues are visible at a glance. Useful for sizing the world map overview, sanity-checking that zones don't overlap (project-union should equal sum of per-zone areas for disjoint layouts), and understanding total project area in both yards and meters. Verified on 2-zone test project: each zone correctly resolves to one 533x533yd tile, project union is 1066x533yd (the two tiles arranged horizontally), Z range matches manifest baseHeight + heightmap delta. Brings command count to 178.
2026-05-06 21:55:27 -07:00
"--info-zone-extents", "--info-project-extents",
feat(editor): add --info-project-water for cross-zone water rollup Project-wide companion to --info-zone-water. Walks every zone in <projectDir>, sums water chunks/layers and liquid type counts per zone, and emits a per-zone breakdown table plus project-wide totals broken down by liquid type (water/ocean/magma/slime). Useful for "do my coastal zones actually carry ocean data" sanity checks and for budget planning when many zones share liquid types (e.g. an archipelago where every zone has 256 water chunks per tile). Brings command count to 179.
2026-05-06 22:06:22 -07:00
"--info-zone-water", "--info-project-water",
feat(editor): add --info-project-density for cross-zone content rollup Project-wide companion to --info-zone-density. Walks every zone in <projectDir>, sums creatures/objects/quests, and emits a per-zone breakdown table with per-tile averages plus project-wide totals. Helps spot zones that are abnormally sparse (5 mobs across 16 tiles, "why is this zone so empty?") or stuffed (200 mobs in 1 tile, frame- rate bomb), and surfaces the project's overall content footprint. Brings command count to 180 — 180 distinct CLI flags now.
2026-05-06 22:17:39 -07:00
"--info-zone-density", "--info-project-density",
feat(editor): add --export-quest-graph for Graphviz quest-chain visualization Visualizing quest chains in plain text rapidly becomes unreadable past ~10 quests. This emits a DOT file that renders to a labeled DAG you can paste into a wiki or PR description: wowee_editor --export-quest-graph custom_zones/MyZone dot -Tpng custom_zones/MyZone/quests.dot -o quests.png Node coloring conveys completion-readiness at a glance: - lightgreen: has objectives + reward (will complete in-game) - lightyellow: has objectives but no reward (uncommon) - lightgray: no objectives (won't complete — common authoring bug) - mistyrose dashed: synthetic node for a quest ID referenced by nextQuestId but missing from quests.json (broken chain) Edges: - solid black: valid chain link - dashed red labeled 'missing': dangling nextQuestId Labels include quest ID, title (DOT-escaped for safety), required level, and XP reward — enough context that the graph stands alone without needing to cross-reference quests.json. Verified on a 3-quest zone with chain 1->2->3->999 (last broken): DOT output has 3 colored nodes (lightgreen for the 2 quests with objectives, lightgray for the third), 2 solid edges, 1 dashed-red edge to a synthetic mistyrose <missing> node.
2026-05-06 13:29:23 -07:00
"--export-zone-summary-md", "--export-quest-graph",
feat(editor): add --export-project-html for multi-zone web index Generates an index.html linking to every zone's HTML viewer in a project. Pairs with --export-zone-html (per-zone) and --bake-zone-glb (terrain bake). Designed for github-pages / static-hosting style 'all my zones' showcase: wowee_editor --export-project-html custom_zones # -> custom_zones/index.html Each zone gets a card showing: - Display name (or mapName fallback) - Counts: tiles · creatures · objects · quests (singular/plural agreement) - 'Open viewer →' link if HTML exists - Helpful nudge if HTML missing ('No HTML viewer (run --export-zone-html)') - Or 'No .glb (run --bake-zone-glb)' if not even baked yet Self-contained CSS (dark theme matching --export-zone-html), no external dependencies. Responsive grid layout (300px-min cards auto-flowing across viewport). Verified on a 2-zone project (Forest with .glb+.html + Desert without): index lists both, Forest gets a working link, Desert gets the 'run --bake-zone-glb' hint.
2026-05-06 15:04:43 -07:00
"--export-zone-csv", "--export-zone-html", "--export-project-html",
feat(editor): add --export-project-checksum with project fingerprint Project-wide companion to --export-zone-checksum. Walks every zone in <projectDir>, hashes every source file, and emits PROJECT_SHA256SUMS in the standard sha256sum format with paths kept relative to projectDir (so entries look like "<hex> <zone>/<file>"). Also computes a single SHA-256 fingerprint over the manifest body — a one-line identity for the whole project, useful for CI release gates and reproducibility. Verified: external 'sha256sum -c PROJECT_SHA256SUMS' passes all 9 entries on a 2-zone test project, and standalone 'sha256sum PROJECT_SHA256SUMS' matches the emitted fingerprint byte-for-byte. Adds wowee_sha256::hex(buf, len) helper. Brings command count to 169.
2026-05-06 20:15:45 -07:00
"--export-project-md", "--export-zone-checksum", "--export-project-checksum",
feat(editor): add --validate-project-checksum for cross-platform verification Closes the emit/verify loop for --export-project-checksum natively, so Windows runners and CI containers without coreutils' sha256sum can still validate PROJECT_SHA256SUMS. Re-hashes every file listed in the manifest, reports ok/missing/mismatched counts, and exits 1 on any failure with a per-file failure list. Verified all three paths: success (9 ok / exit 0), missing file (1 missing / exit 1), mismatched hash (2 mismatched / exit 1). Brings command count to 171.
2026-05-06 20:34:45 -07:00
"--validate-project-checksum",
feat(editor): add --mvp-zone for one-command demo zone setup Quick-start: scaffold a zone AND populate one of each content type (1 creature, 1 object, 1 quest with objective + XP reward) in a single command. Goes from empty filesystem to 'something to look at' without 7 chained --add-* commands: wowee_editor --mvp-zone 'Demo Land' 30 30 Created demo zone: custom_zones/Demo_Land tile : (30, 30) contents : 1 creature, 1 object, 1 quest (with objective + reward) next : wowee_editor --info-zone-tree custom_zones/Demo_Land Demo Land/ ├─ Manifest ... ├─ Tiles (1) — (30, 30) ├─ Creatures (1) — lvl 5 Demo Wolf ├─ Objects (1) — m2 World/Generic/Tree.m2 ├─ Quests (1) — [1] Welcome to Demo Land (lvl 1, 100 XP) │ └─ kill ×1 Demo Wolf Demo content is positioned roughly at tile center (533.33-yard intervals from origin tile 32/32). Quest references the demo creature's auto-id so --check-zone-refs passes immediately. Use cases: - Smoke-testing the bake/validate pipeline - Screenshot bait for docs / blog posts - Editor onboarding (open a zone in the GUI to see the format) - CI sanity check (does our editor still produce a viewable zone?) Verified end-to-end: --mvp-zone 'Demo Land' → --info-zone-tree shows all 4 sections populated correctly, file list matches expected 6 files.
2026-05-06 16:25:23 -07:00
"--scaffold-zone", "--mvp-zone", "--add-tile", "--remove-tile", "--list-tiles",
feat(editor): add --for-each-tile for per-tile batch operations Per-tile batch runner. Pairs with --for-each-zone (project-level tile iteration is too coarse for tile-level commands like --build-woc, --validate-whm, --info-whm). wowee_editor --for-each-tile custom_zones/MyZone -- \ wowee_editor --build-woc {} [custom_zones/MyZone/MyZone_30_30 (30, 30)] WOC built: custom_zones/MyZone/MyZone_30_30.woc (32768 triangles, ...) [custom_zones/MyZone/MyZone_31_30 (31, 30)] WOC built: custom_zones/MyZone/MyZone_31_30.woc (32768 triangles, ...) for-each-tile: 2 tiles, 0 failed The {} substitution receives the tile-base path (zoneDir/mapName_TX_TY) which is the form most tile-level commands accept. Sorts tiles by (tx, ty) so output ordering is deterministic. Use cases: - Build WOC for every tile in one shot after editing terrain - Validate WHM headers across all tiles - Export per-tile previews via --export-whm-obj - Per-tile data dump via --info-whm Same shell-escaping + cmd-substitution machinery as --for-each-zone (safe against names with spaces and quotes). Returns failed-run count as exit code (capped at 255). Verified on a 2-tile zone running --build-woc per tile: both tiles built correctly, exit 0.
2026-05-06 18:11:54 -07:00
"--for-each-zone", "--for-each-tile", "--zone-stats", "--info-tilemap",
feat(editor): add --remove-project-orphans for pre-pack cleanup Destructive companion to --list-project-orphans. Reuses the same reference-collection + orphan-detection logic, then deletes the resulting .wom/.wob files. Honors --dry-run for safe previews. Completes the list/remove cycle for unreferenced model files: run --list-project-orphans to audit, then --remove-project-orphans --dry-run to confirm, then drop --dry-run to actually clean. Useful right before --pack-wcp so the archive doesn't carry dead weight. Verified: dry-run preserves files (3 reported, all still present); real run on a copy removes all 3 with no failures, freeing 1.2 KB. Brings command count to 182.
2026-05-06 22:42:29 -07:00
"--list-zone-deps", "--list-project-orphans", "--remove-project-orphans",
feat(editor): add --list-project-orphans to find unreferenced models Inverse of --list-zone-deps. Walks every zone in <projectDir>, collects the set of .wom/.wob files on disk plus the set of paths actually referenced by objects.json placements + WOB doodad lists, and reports any model files in the first set but not the second. Useful pre-pack cleanup — orphans bloat .wcp archives without contributing to gameplay. The output table shows zone + path + bytes so users can decide which to delete. Comparison normalizes paths by stripping extensions and matching both the full relative path and the leaf basename, so unqualified refs in objects.json (e.g. just "cube_a" without ".wom") still resolve. Verified: empty objects.json → 3 orphans across 2 zones; after --add-object cube_a → only 2 orphans remain (cube_a correctly removed from the list). Brings command count to 181.
2026-05-06 22:30:10 -07:00
"--check-zone-refs", "--check-zone-content",
feat(editor): add --check-project-refs for project-wide reference validation Project-level cross-reference checker. Walks every zone and runs the same model-path / NPC-id checks --check-zone-refs does, with per-zone breakdown: wowee_editor --check-project-refs custom_zones check-project-refs: custom_zones zones : 12 (2 failed) total missing: 5 zone obj_chk obj_miss q_chk q_miss status AshenForest 12 0 4 0 PASS BoneOasis 17 2 6 0 FAIL Stranglethorn 34 1 8 2 FAIL ... 2 zone(s) have dangling refs Per-zone columns split objects vs quests so designers see at a glance whether the issue is missing models (asset bundle drift) or NPC IDs (creature definitions out of sync with quest references). Pairs with --check-project-content (data quality) and --validate-project (binary integrity). Together the three give a complete pre-ship validation gate: --validate-project binary structure --check-project-content field plausibility --check-project-refs cross-references resolve Verified on a 2-zone project: Forest mvp-zone has 1 unresolved object placement (no Tree.m2 on disk in test cwd), Bad zone has 1 missing object → 2 zones FAIL, exit 1.
2026-05-06 19:44:28 -07:00
"--check-project-content", "--check-project-refs",
feat(editor): add --export-zone-spawn-png for top-down spawn-position maps Renders a top-down PNG showing creature + object spawn positions colored by type. Bound by the zone's tile range so the image is properly framed at zone scale: wowee_editor --export-zone-spawn-png custom_zones/MyZone # -> custom_zones/MyZone/MyZone_spawns.png Layout: - Tile-grid lines at tile boundaries (subtle grey on dark grey) - Red 3×3 dots: creature spawns - Green 3×3 dots: M2 object placements - Blue 3×3 dots: WMO object placements - 256 px per tile (so a 4-tile zone is 512×512); cap at 4096 largest dim for huge multi-tile projects WoW coord -> image transform: +X world is north (up in image), +Y world is west (left in image). Same convention --info-tilemap uses, so the spawn map and the tilemap line up visually. Useful for design review ('does the spawn distribution match the encounter design?'), screenshot bait for blog posts, and instant visual validation of new content before opening the GUI. Verified on a 1-tile mvp-zone with 3 creatures + 1 object plotted: 256×256 RGB PNG, dots placed at expected positions, --info-png confirms the output is well-formed (8-bit RGB, 2184 bytes).
2026-05-06 18:59:44 -07:00
"--export-zone-deps-md", "--export-zone-spawn-png",
feat(editor): add --add-item, introducing zone items.json content type Introduces a new per-zone content file alongside creatures.json / objects.json / quests.json. Schema: {"items": [{id, name, quality, displayId, itemLevel, stackable}, ...]}. Inline JSON manipulation via nlohmann::json — items are simple records and don't yet need NpcSpawner-style infrastructure. ID assignment: pass 0 (or omit) to auto-pick the smallest unused positive integer so numbering stays contiguous. Explicit IDs are honored. Duplicate IDs rejected with exit 1 so collisions are visible. Quality is 0..6 (poor/common/uncommon/rare/epic/legendary/artifact) — summary line maps the number to the human name so users see what they wrote. Verified: auto-id sequential (1, 2) → explicit id (99) honored → duplicate id rejected with exit 1; JSON schema stable, quality labels correct, file auto-created on first call. Brings command count to 196.
2026-05-07 01:33:58 -07:00
"--add-creature", "--add-object", "--add-quest", "--add-item",
feat(editor): add --random-populate-items seeded loot generator Seeded random items.json populator. Pulls a quality-banded prefix ("Worn" → "Eternal" depending on rolled quality) plus a noun ("Sword", "Tome", "Cloak"...) for plausible names, then randomizes itemLevel and stack size around quality-appropriate baselines. Useful for playtest loot tables that need bulk content without hand-typing each entry. Reproducible from --seed; respects --max-quality so a "trash loot" pass won't accidentally drop artifacts. Verified on a fresh zone: 8 items rolled with the seed=5 produces a sensible spread (1 epic Tome, 1 epic Cuirass, 1 uncommon Bow, 5 common/poor) and unique IDs starting at 1. Brings command count to 233.
2026-05-07 11:57:55 -07:00
"--random-populate-zone", "--random-populate-items",
feat(editor): add --audit-zone-spawns to flag misplaced spawns Non-destructive companion to --snap-zone-to-ground. Loads the zone's terrain, samples the height under each creature + object, and flags any whose Z is more than <threshold> yards (default 5) off from the terrain. Useful for surveying placement issues before deciding whether to run --snap-zone-to-ground (which would silently rewrite every spawn). The flagged report shows kind / delta / spawnZ / terrainZ / name so the user can spot whether the spawn is buried, floating, or just out of bounds. Threshold configurable via --threshold N. Exit 1 if any issue is flagged so CI can gate on placement validity. Verified: zone with FloatyMurloc at Z=5000 (vs terrain Z=99.9) correctly flags it with +4900.1 delta; GroundedWolf at Z=100 is within threshold and not flagged.
2026-05-07 13:57:25 -07:00
"--info-zone-audio", "--snap-zone-to-ground", "--audit-zone-spawns",
feat(editor): add --snap-project-to-ground orchestrator Project-wide companion to --snap-zone-to-ground. Spawns the binary per-zone (only zones that actually have creatures.json or objects.json — pure-terrain zones are skipped to avoid noise), streams the per-zone output, then aggregates a summary. Useful after a project-wide terrain regen, or after batch-running --random-populate-zone across multiple zones — one command snaps all the spawns at once. Verified: 2-zone test where only z1 has populated content correctly selects z1 alone, snaps 3 creatures + 1 object, exits 0.
2026-05-07 13:42:19 -07:00
"--info-project-audio", "--snap-project-to-ground",
feat(editor): add --list-project-spawns cross-zone spawn listing Project-wide companion to --list-zone-spawns. Combines creatures + objects across every zone into one listing keyed by (zone, kind, name) with position + a per-kind extra column (level for creatures, scale for objects). Both human (table) and --json output. Useful for project-wide review and for piping into spreadsheets via --json — the zone column lets a pivot table group/filter by zone which the per-zone command can't.
2026-05-07 15:15:20 -07:00
"--audit-project-spawns", "--list-zone-spawns", "--list-project-spawns",
feat(editor): add --gen-zone-texture-pack orchestrator New zone-scope command that drops a 6-texture starter pack (grass, dirt, stone, brick, wood, water) into <zoneDir>/textures/ by fanning out to the procedural --gen-texture-* family. Saves users from sourcing proprietary art when bringing up a new zone — the entire pack is open PNG output from procedural generators. Adds to the gen-random-zone family of project orchestrators.
2026-05-07 23:18:00 -07:00
"--gen-random-zone", "--gen-random-project", "--gen-zone-texture-pack",
feat(editor): add --gen-project-starter-pack project bootstrap Project-wide bootstrap orchestrator. For every zone in <projectDir>, runs --gen-zone-starter-pack (textures + meshes) and --gen-zone-audio-pack (audio). Each zone gets a unique sub-seed offset from the base seed so per-zone content reads as distinct (rocks differ, wood grain differs). Pairs with --validate-project-packs as the inverse: bootstrap the entire project in one call, audit, ship.
2026-05-08 07:05:17 -07:00
"--gen-zone-mesh-pack", "--gen-zone-starter-pack",
"--gen-project-starter-pack", "--gen-audio-tone",
feat(editor): add --gen-audio-sweep frequency chirp synthesis Sine wave whose frequency glides from startHz to endHz across the duration. Two shape modes: linear: f(t) = f0 + (f1-f0)*t/T (integrated phase = quadratic) exp: f(t) = f0 * (f1/f0)^(t/T) (logarithmic glide) Same RIFF/PCM-16 mono envelope as gen-audio-tone with 5ms attack/release. Useful for sci-fi door whoosh, alert ramps, sliding pitch cues, and as a standard signal-engineering test signal — all hand-synthesized open-format WAV.
2026-05-08 06:37:50 -07:00
"--gen-audio-noise", "--gen-audio-sweep", "--gen-zone-audio-pack",
feat(editor): add --info-project-deps project-wide ref audit Project-wide companion to --info-zone-deps. Fans out the per-zone broken-reference audit across every zone via subprocess (defers to the canonical resolution logic so behavior stays consistent) and reports per-zone PASS/FAIL plus a project rollup. Exits non-zero if any zone has a broken texture reference — designed as a CI gate.
2026-05-08 15:16:00 -07:00
"--info-zone-summary", "--info-project-summary",
"--info-zone-deps", "--info-project-deps",
feat(editor): add --gen-project-readme auto-doc PROJECT.md Project-level companion to --gen-zone-readme. Writes PROJECT.md with a per-zone status table (BOOTSTRAPPED/PARTIAL/EMPTY plus biome and per-category counts) and a project-level rollup (total zones, assets, bytes). Pairs naturally with the per-zone README — running both gives self-documenting content at every level.
2026-05-08 12:00:28 -07:00
"--gen-zone-readme", "--gen-project-readme",
feat(editor): add --info-project-summary status table per zone Project-wide companion to --info-zone-summary. Walks every zone in <projectDir>, classifies each as BOOTSTRAPPED (textures + meshes + audio all non-empty), PARTIAL (some categories), or EMPTY (none), and shows per-category counts in a status table with a project total at the bottom. Quick "what shape is the whole project in" view that pairs naturally with --validate-project-packs (which actually loads and verifies every asset).
2026-05-08 09:58:29 -07:00
"--validate-zone-pack", "--validate-project-packs", "--info-spawn",
feat(editor): add --diff-zone-spawns for zone-to-zone comparison Compares two zones' creatures + objects with two-pointer match-by- (kind, name): paired entries with mismatched positions report as "moved" with the (dx, dy, dz) delta; entries that exist in only one zone are added/removed. Useful for "what did this branch change vs main" before merging, for confirming a copy-zone-items produced the expected result, and for cross-zone consistency reviews. Move threshold is 0.5y; smaller deltas count as "same" since typical drift from snap-zone-to-ground is sub-yard. Exit 1 if anything differs so CI can gate on cross-zone consistency. Verified: 2 different random-populated zones → reports 6 added / 5 removed / 1 moved / 0 same with the moved entry showing its position delta.
2026-05-07 21:04:14 -07:00
"--diff-zone-spawns",
feat(editor): add --export-zone-items-md markdown items report Renders items.json as a Markdown report grouped by quality, best first (Artifact → Legendary → Epic → Rare → Uncommon → Common → Poor). Header shows total count + zone name; quality breakdown table summarizes the distribution; per-quality sections list ID / name / itemLevel / displayId / stack with right-aligned numeric columns. Drops cleanly into design docs, PR descriptions, and GitHub Pages — one rendered page communicates the loot landscape better than scrolling through JSON. Used find()/iterators instead of operator[] in the per-quality loops so the bucket map doesn't grow phantom empty entries (caught by the "qualities (used)" line reporting 7 instead of the actual 3 in the first test run). Verified: 3-item zone (1 common / 1 uncommon / 1 legendary) → ITEMS.md sections appear in best-first order, quality count line reports 3 not 7. Brings command count to 210.
2026-05-07 04:45:25 -07:00
"--list-items", "--info-item", "--set-item", "--export-zone-items-md",
feat(editor): add --export-project-items-csv project-wide spreadsheet rollup Single CSV with every item across every zone in <projectDir>. The zone name is the first column so a pivot table can group by it; remaining columns mirror --export-zone-csv items output (index, id, name, quality, itemLevel, displayId, stackable). Saves running the per-zone CSV exporter N times and concatenating manually. Reuses the existing CSV-escape lambda so commas and quotes in names round-trip cleanly. Verified: 2-zone project (A: Sword, "Helm, with comma" / B: Crown) emits 3 rows with the comma'd name correctly double-quoted; zone column lets a downstream pivot group correctly. Brings command count to 224 (kArgRequired 205).
2026-05-07 07:26:00 -07:00
"--export-project-items-md", "--export-project-items-csv",
feat(editor): add --add-quest-reward-item and --set-quest-reward Closes the quest-authoring CLI: --add-quest creates a quest, then --add-quest-objective adds completion conditions, and now these add the rewards. wowee_editor --add-quest-reward-item $Z 0 'Item:Sword' 'Item:Shield' 'Item:Potion' wowee_editor --set-quest-reward $Z 0 --xp 999 --gold 5 --silver 30 --add-quest-reward-item greedy-consumes any trailing positional args that don't start with '-', so a whole loot table can be added in one invocation rather than N round-trips through load+save. --set-quest-reward updates only the fields explicitly passed (--xp / --gold / --silver / --copper) — avoids the round-trip-and-clobber footgun of a 'replace whole reward' command. Field flags are order-independent. At least one flag is required (else error). Both validate questIdx against quest count and bail with exit 1 on out-of-range / missing file / bad numeric value. Verified: scaffolded zone, added quest with default xp=100, batch- added 3 item rewards in one shot, then set xp=999/gold=5/silver=30 in one shot. --info-quests reports total XP=999, with-items=1.
2026-05-06 12:18:20 -07:00
"--add-quest-objective", "--add-quest-reward-item", "--set-quest-reward",
feat(editor): add --clone-creature symmetric to --clone-quest Designer workflow: archetype one 'patrol guard' with stats + faction + behavior + equipment dialed in, then stamp it across spawn points around a town: for x in 100 110 120 130; do wowee_editor --clone-creature $Z 0 "Guard $x" $x 200 50 done Defaults give safe behavior: - Position offset by (5, 0, 0) yards so the copy doesn't z-fight the original when no offset is passed. - Name appended with ' (copy)' if no newName given. - id reset (auto-assigned by NpcSpawner). - Patrol path NOT offset — patrol points are world-space waypoints, not relative to the spawn; cloning that vector unchanged matches designer intent. Re-author the path on the clone if needed. Verified: scaffolded zone, added Guard, cloned twice (default offset, custom name + 3D offset). list-creatures shows 3 spawns with correctly differentiated positions and names.
2026-05-06 12:57:31 -07:00
"--remove-quest-objective", "--clone-quest", "--clone-creature",
feat(editor): add --validate-project-items orchestrator Project-wide wrapper around --validate-items. Spawns the binary per-zone (only zones that have items.json) so each zone's full error report streams through, then aggregates a final tally. Exit 1 if any zone fails. Skips zones without items.json — those have nothing to validate and shouldn't count as failures. Handles the edge case where no zones in the project have items at all (returns "nothing to validate" exit 0). Verified: 3-zone project (2 valid + 1 with quality=99) → per-zone output streamed, summary "passed: 2 failed: 1", true exit code 1 when any zone fails. Brings command count to 211.
2026-05-07 04:57:03 -07:00
"--clone-item", "--validate-items", "--validate-project-items",
"--info-project-items",
feat(editor): add --clone-object completing the CRUD-clone trio Symmetric to --clone-creature and --clone-quest. Common workflow: place one tree just right (rotation, scale dialed in), then clone N copies along a path: for x in 100 110 120 130 140; do wowee_editor --clone-object $Z 0 $x 0 0 done Defaults match --clone-creature: 5-yard X offset prevents z-fighting. Rotation and scale carry over verbatim (so a tilted barrel stays tilted). uniqueId is reset so the new placement doesn't collide with the source's identifier in any downstream system that dedups by it. CRUD-clone surface is now complete: --clone-quest <zone> <questIdx> [newTitle] --clone-creature <zone> <idx> [newName] [dx dy dz] --clone-object <zone> <idx> [dx dy dz] Verified: scaffolded zone, added a tree at (100, 200, 50, scale=1.5). Cloned twice (default offset, custom offset). Result: 3 trees with correctly-shifted positions and preserved scale=1.50.
2026-05-06 13:10:25 -07:00
"--clone-object",
feat(editor): add --remove-item completing the items CRUD set Removes the entry at given 0-based index from <zoneDir>/items.json. Mirrors --remove-creature/--remove-object/--remove-quest semantics: bounds-checked, file rewrites on success, exit 1 on out-of-range or malformed JSON. Reports the removed item's name + id in the success line so the user has feedback on what they just dropped. Items CRUD set is now complete: --add-item / --list-items / --remove-item. Together they form the items.json half of the new content-creation direction (textures/meshes/items) the user asked for in the prior batch. Verified: 3-item zone → remove idx 1 ('Bread', id=2) leaves 2 items intact and renumbered; out-of-range index 99 fails with exit 1 and clear error. Brings command count to 198.
2026-05-07 01:52:43 -07:00
"--remove-creature", "--remove-object", "--remove-quest", "--remove-item",
feat(editor): add --copy-zone-items for cross-zone item reuse Copies items from one zone to another. Two modes: Default (replace): destination items.json becomes a verbatim copy of the source. Useful when zoneB is a fresh copy of zoneA's loot table. --merge: appends source items to existing destination items, but preserves the destination's existing IDs by re-id'ing source entries on collision. The destination's items take precedence; the source's entries get fresh IDs picked from the smallest unused positive integer. Verified: merge with id-1 collision (dest has Boot id=1; source has Sword id=1, Helm id=2) → Sword becomes id=2, then Helm becomes id=3 because 2 was just claimed; "re-ided: 2 (id collisions)" reported. Replace mode wholesale-overwrites as expected. Brings command count to 223.
2026-05-07 07:12:55 -07:00
"--copy-zone-items",
feat(editor): add --remove-zone for safe zone deletion Counterpart to --scaffold-zone / --copy-zone / --rename-zone — completes the zone-lifecycle CRUD. Defense-in-depth against accidental destruction: wowee_editor --remove-zone custom_zones/Doomed remove-zone: custom_zones/Doomed ('Doomed') would delete: 6 file(s), 174.9 KB re-run with --confirm to actually delete wowee_editor --remove-zone custom_zones/Doomed --confirm Removed custom_zones/Doomed ('Doomed') deleted: 7 filesystem entries, 174.9 KB freed Two-step safety: 1. Without --confirm: dry-run that lists what would be deleted (file count + total bytes + zone display name from manifest). 2. With --confirm: actually wipes the directory. Belt-and-suspenders refusal: even with --confirm, refuses to delete anything that doesn't have a zone.json at the top level. Catches typos like '--remove-zone .' that would otherwise nuke an entire project. Why not just 'rm -rf'? --remove-zone gives: - Per-zone display name in the confirmation - Byte-count audit before deletion - The non-zone-dir guard (rm doesn't know what a zone is) - Symmetric with the rest of the zone-lifecycle CLI Verified: dry-run lists 6 files / 175 KB; '. --confirm' correctly refused (no zone.json at top level); zone-dir --confirm wiped 7 fs entries with byte tally.
2026-05-06 19:26:10 -07:00
"--copy-zone", "--rename-zone", "--remove-zone",
feat(editor): add --strip-project for project-wide derived-output cleanup Wraps --strip-zone across every zone in <projectDir>. Removes derived outputs (.glb/.obj/.stl/.html/.dot/.csv/.png/ZONE.md/DEPS.md) at each zone's top level, leaving source files (zone.json + content JSONs + open binary formats) untouched. Per-zone breakdown table plus aggregate freed-bytes total. Honors --dry-run for safe previews. Useful before --pack-wcp to keep release archives lean, or before a git commit so derived blobs don't bloat history across many zones at once. Verified: dry-run shows "would-remove" totals matching the actual delete pass on the 2-zone test project (870.8 KB per zone, 1741.6 KB freed). Brings command count to 174.
2026-05-06 21:04:32 -07:00
"--clear-zone-content", "--strip-zone", "--strip-project",
feat(editor): add --repair-project for project-wide manifest self-healing Wraps --repair-zone across every zone in <projectDir>. Spawns the binary per-zone so each zone's full repair report streams through, with section markers between, then aggregates a final tally. Honors --dry-run. Calls fflush(stdout) before each child spawn so the parent's section header lands ahead of the child's stdout (separate buffers per process). Verified: clean project → 0 fixes / exit 0; project with an orphan tile file → "would add tile (5, 5) to manifest" / exit 0 (dry-run). Brings command count to 177.
2026-05-06 21:44:47 -07:00
"--repair-zone", "--repair-project",
"--gen-makefile", "--gen-project-makefile",
feat(editor): add --add-creature CLI for headless creature placement Appends a single creature spawn to a zone's creatures.json. First real authoring tool that doesn't need the GUI placement system — useful for batch-populating zones via shell script: for npc in goblin spider wolf; do wowee_editor --add-creature "$zone" "$npc" 100 200 50 done Args: <zoneDir> <name> <x> <y> <z> [displayId] [level] - displayId 0 → SQL exporter substitutes 11707 (generic humanoid) - level defaults to 1 - Coordinates are render-space (renderX=wowY, renderY=wowX) Loads any existing creatures.json first then appends, so multiple invocations build up the file. The standard NPC spawner caps (50k creatures) protect against runaway scripts.
2026-05-06 11:35:07 -07:00
"--build-woc", "--regen-collision", "--fix-zone",
feat(editor): add --import-wob-obj to round-trip OBJ back into WOB Closes the WOB <-> universal-format round trip, mirroring what --import-obj does for WOM. Workflow now works end-to-end for buildings: asset_extract # WMO -> WOB (open binary) --export-wob-obj # WOB -> OBJ (universal text) ... edit in Blender / MeshLab / Maya ... --import-wob-obj # OBJ -> WOB (back to engine format) --validate-wob # confirm consistency Mapping handles: - Each OBJ 'g name' starts a new WOB group; faces under it become that group's indices. Default 'imported' group catches faces before any 'g' directive (raw OBJ files from non-DCC sources). - Per-group dedupe table on (pos, uv, normal) triples — each WOB group has its own local vertex array, so the global OBJ index pool gets remapped per group. - '_outdoor' suffix stripped + isOutdoor flag set, mirroring --export-wob-obj's naming convention. - Doodad placements recovered from the # doodad ... comment lines --export-wob-obj writes; round-trip preserves them via re-parse. - UV V flipped back (1.0 - v) so the round trip is exact. - Per-group bounds + global bound radius computed from positions. Verified: WOB(2 groups, 7 verts, 3 tris, 1 doodad) -> OBJ -> WOB(2 groups, 7 verts, 3 tris, 1 doodad). validate-wob clean, info-wob shows the same counts. Materials and portals don't survive the OBJ trip (no semantic equivalent) — that's documented.
2026-05-06 12:20:37 -07:00
"--export-png", "--export-obj", "--import-obj",
"--export-wob-obj", "--import-wob-obj",
feat(editor): add --export-whm-obj for terrain heightmap visualization Completes the open-format -> universal-text bridge for the last binary geometry format. WHM was the missing one; designers now have OBJ exports for all four (WOM models, WOB buildings, WOC collision, WHM terrain). wowee_editor --export-whm-obj custom_zones/MyZone/MyZone_30_30 Mesh layout: - 9x9 outer vertex grid per chunk (skips the 8x8 inner verts the engine uses for 4-tri fans). That's 81 verts and 128 tris per chunk; full ADT = 20736 verts + 32768 tris. - One OBJ 'g chunk_X_Y' per MapChunk so designers can hide chunks individually in Blender (e.g. to inspect a single problem area). - Hole bits respected — cave-entrance quads correctly disappear. - Coords match WoweeCollisionBuilder's outer-grid layout exactly, so an --export-whm-obj and --export-woc-obj of the same source align spatially when overlaid in Blender. (Verified: first vertex of both is (1066.67, 1066.67, ~98.5) for a tile (30, 30) export.) - UVs are simply row/8, col/8 in [0,1] per chunk so a checker texture renders at the canonical scale for size reference. Verified: scaffolded zone -> WHM/WOT auto-built -> --export-whm-obj produces 256 chunks loaded, 20736 verts, 32768 faces, 256 'g' blocks. Counts exactly match the chunk × outer-grid math.
2026-05-06 12:27:46 -07:00
"--export-woc-obj", "--export-whm-obj",
feat(editor): add --export-whm-glb completing the .glb exporter trio Third and final glTF 2.0 binary exporter — terrain heightmaps now ship to the modern web 3D ecosystem alongside WOM models and WOB buildings: wowee_editor --export-whm-glb custom_zones/MyZone/MyZone_30_30 Mesh layout matches --export-whm-obj exactly (9x9 outer vertex grid per chunk, 8x8 quads -> 2 tris each, hole bits respected) so the .glb and .obj of the same source align spatially when overlaid. Per-chunk primitive scheme: - One global vertex pool (positions + normals interleaved by section). - One global index pool packed sequentially. - Each loaded chunk gets its own primitive sliced from the shared index bufferView via byteOffset. - Designers can hide chunks individually in three.js for area-by-area inspection of large terrains. v1 simplifications: - Normals synthesized as +Z (terrain Z-up). Real per-vertex normals with cross-chunk smoothing is a follow-up; viewers can compute their own from positions in the meantime. - No UVs (no per-chunk material yet — that depends on splat alpha layers which are a separate format problem). Verified on a 256-chunk scaffolded zone: 20736 verts, 32768 tris, 256 primitives. First chunk's primitive has 384 indices (128 tris × 3). Position accessor bounds match WoW coord system for tile (30, 30): min ~(533, 533), max ~(1067, 1067). Total .glb 929KB, all spec-compliant.
2026-05-06 13:17:37 -07:00
"--export-glb", "--export-wob-glb", "--export-whm-glb",
feat(editor): add --bake-zone-obj completing the bake-zone trio OBJ companion to --bake-zone-glb / --bake-zone-stl. Same multi-tile WHM aggregation, this time as Wavefront OBJ — opens directly in Blender / MeshLab / 3DS Max for hand-editing the terrain mesh: wowee_editor --bake-zone-obj custom_zones/MyZone # -> custom_zones/MyZone/MyZone.obj Baked custom_zones/MyZone -> custom_zones/MyZone/MyZone.obj 2 tile(s), 41472 verts, 65536 tris Each tile becomes its own 'g tile_TX_TY' block so designers can hide tiles independently in Blender. Single global vertex pool with per-tile vertex base indices for face emission (OBJ requires verts before faces, so we collect per-tile face indices in memory then emit them after all verts are streamed to disk). Hole bits respected (cave-entrance quads dropped). Coords match WoweeCollisionBuilder's outer-grid layout exactly so .obj/.glb/.stl of the same source align spatially when overlaid. Why three formats for full-zone export: glTF for on-screen 3D viewers, STL for fabrication, OBJ for DCC editing. Three different ecosystems, three different format sweet spots. Verified: 2-tile zone (Z + added tile) baked correctly. 41472 verts (2 × 20736), 65536 tris (2 × 32768), 2 'g' blocks (tile_30_30 + tile_31_30) — matches what --bake-zone-glb reports for the same input.
2026-05-06 14:07:22 -07:00
"--export-stl", "--import-stl",
"--bake-zone-glb", "--bake-zone-stl", "--bake-zone-obj",
feat(editor): add --bake-project-stl + --bake-project-glb completing the project trio Three project-bake formats now match the three zone-bake formats — full project terrain reachable from every universal-3D ecosystem: wowee_editor --bake-project-obj custom_zones # DCC tools wowee_editor --bake-project-stl custom_zones # 3D printing wowee_editor --bake-project-glb custom_zones # web viewers Shared per-zone walking pass collects vertex+index pools per zone, then the format-specific tail emits: STL → per-triangle 'facet normal'+'outer loop'+vertex×3 GLB → packed BIN chunk + JSON describing per-zone meshes GLB output gives one mesh+node per zone (named 'zone_NAME') so viewers can toggle zones independently — same pattern as --bake-zone-glb but at project scope. STL is single-solid since slicers don't have a useful concept of multi-part STL. Coords align across all three exporters and across zone vs project scope, so: - A zone .obj overlaid with its containing project .obj lines up - A project .glb opened in three.js shows zones at the same coords the renderer uses Verified on a 2-zone project (Forest + Desert): - project.stl: 2 zones, 2 tiles, 65536 facets - project.glb: 2 zones, 2 tiles, 41472 verts, 65536 tris, 1.78MB BIN - --validate-glb on project.glb: PASSED Bake granularity matrix complete: OBJ STL GLB single model --export-obj --export-stl --export-glb single zone --bake-zone-obj --bake-zone-stl --bake-zone-glb whole project --bake-project-obj --bake-project-stl --bake-project-glb
2026-05-06 16:08:44 -07:00
"--bake-project-obj", "--bake-project-stl", "--bake-project-glb",
feat(editor): add --convert-m2-batch for bulk M2→WOM migration Walks <srcDir> recursively for every .m2 file (case-insensitive, including subdirs) and re-invokes --convert-m2 per file via a child process so the existing single-file logic — AssetManager init, skin file resolution, fromM2() pipeline — is reused verbatim. Per-file [ok]/[FAIL] line streamed live; aggregate summary at the end. Designed to migrate an entire creature/world model dump in one go. This is the headline open-format conversion: every .m2 in a proprietary data tree gets turned into a .wom open-format model. Pair with the upcoming --convert-wmo-batch / --convert-blp-batch / --convert-dbc-batch to migrate a complete extracted Data tree. Verified discovery: 3 placeholder .m2 files (one in subdir, one .M2 uppercase) found correctly; .txt skipped; all fail conversion as expected for empty bytes; exit 1 on any failure. Brings command count to 183.
2026-05-06 22:55:39 -07:00
"--convert-m2", "--convert-m2-batch",
feat(editor): add --convert-wmo-batch for bulk WMO→WOB migration Sibling to --convert-m2-batch. Walks <srcDir> recursively for every .wmo file (case-insensitive) and re-invokes --convert-wmo per file via a child process so the existing root-WMO + group-loading logic is reused verbatim. Skips group files (e.g. Stormwind_001.wmo) since the root WMO converter already pulls those in transitively. Detection: stem ends in _NNN with NNN being three digits. Verified: 5 .wmo files → 2 root candidates, 3 group files correctly skipped, summary line accurate. Brings command count to 184.
2026-05-06 23:07:34 -07:00
"--convert-wmo", "--convert-wmo-batch",
feat(editor): add --convert-dbc-batch for bulk DBC→JSON migration Final commit in the four-format batch-converter set. Walks <srcDir> recursively for every .dbc file (case-insensitive) and re-invokes --convert-dbc-json per file, writing a .json sidecar next to each source. The batch converters now cover the full proprietary→open transition: --convert-m2-batch .m2 → .wom --convert-wmo-batch .wmo → .wob (skipping _NNN group files) --convert-blp-batch .blp → .png --convert-dbc-batch .dbc → .json Run all four against an extracted Data tree to migrate it end-to-end to the open format ecosystem. Verified: 3 .dbc files (case-insensitive, sub-dir) discovered; .json file in same tree skipped; exit 1 on failures. Brings command count to 186.
2026-05-06 23:31:38 -07:00
"--convert-dbc-json", "--convert-dbc-batch", "--convert-json-dbc",
feat(editor): add --convert-blp-batch for bulk BLP→PNG migration Walks <srcDir> recursively for every .blp file (case-insensitive) and re-invokes --convert-blp-png per file. The single-file converter writes the .png as a sidecar next to the source by default, so a batched run mirrors the standard "PNG sidecar everywhere" layout that the editor's open-format runtime expects. Verified discovery: 3 placeholder .blp files (lowercase, uppercase, sub-dir) found correctly; .png file in same tree skipped; all fail conversion as expected for empty bytes; exit 1 on failures. Brings command count to 185.
2026-05-06 23:19:38 -07:00
"--convert-blp-png", "--convert-blp-batch",
feat(editor): add --migrate-project for multi-zone WOM upgrades Wraps --migrate-zone across every zone under <projectDir>, so a single invocation upgrades legacy WOM1/WOM2 files to WOM3 with batches[] populated across an entire content project. Per-zone breakdown table shows scanned/upgraded/already-v3/failed counts for visibility. Verified end-to-end: scaffold 2 zones, drop 3 v1 cubes, run --migrate- project once → 3/3 upgraded; second run → 0 upgraded, 3 already-v3 (idempotent). Brings total command count to 168.
2026-05-06 20:05:51 -07:00
"--migrate-wom", "--migrate-zone", "--migrate-project",
feat(editor): add --strip-data-tree to delete migrated proprietary files Destructive cleanup that completes the data-tree migration workflow. Walks <srcDir>, finds every proprietary file (.m2/.wmo/.blp/.dbc) that already has a matching open sidecar at the same (parent, stem), and deletes the proprietary file. Files without sidecars are preserved (still need migration). Honors --dry-run for safe previews. Defaults to actually delete (matches --strip-zone convention). Recommended workflow: --info-data-tree see migration share --migrate-data-tree fill in missing sidecars --strip-data-tree --dry-run confirm kill list --strip-data-tree apply Verified: 11-file mixed tree → dry-run preserves all 11; apply removes exactly the 4 that have sidecars (foo.m2, castle.wmo, sky.blp, Spell.dbc); the 3 unmatched proprietary files (bar.m2, grass.blp, Item.dbc) are correctly kept. Brings command count to 189.
2026-05-07 00:05:54 -07:00
"--migrate-data-tree", "--info-data-tree", "--strip-data-tree",
feat(editor): add --audit-data-tree CI gate for migration completeness Non-destructive CI gate that exits 1 if any proprietary file (.m2/.wmo/.blp/.dbc) lacks a matching open sidecar at the same (parent, stem). The pre-strip safety check: don't run --strip-data- tree until this returns exit 0. Lists the missing sidecars (capped at 50) so the user can re-run --migrate-data-tree to fill the gaps. Per-extension breakdown identifies which converter to investigate if specific formats are underrepresented. Completes the data-tree workflow: --info-data-tree visibility --migrate-data-tree fill sidecars --audit-data-tree confirm 100% before stripping --strip-data-tree delete migrated proprietary originals Verified: empty tree → PASS exit 0; fully migrated → PASS exit 0; gaps (1 .m2 + 1 .blp lacking sidecars) → FAIL exit 1 with both files listed sorted, per-ext counts correct. Brings command count to 190.
2026-05-07 00:15:02 -07:00
"--audit-data-tree",
feat(editor): add --migrate-project for multi-zone WOM upgrades Wraps --migrate-zone across every zone under <projectDir>, so a single invocation upgrades legacy WOM1/WOM2 files to WOM3 with batches[] populated across an entire content project. Per-zone breakdown table shows scanned/upgraded/already-v3/failed counts for visibility. Verified end-to-end: scaffold 2 zones, drop 3 v1 cubes, run --migrate- project once → 3/3 upgraded; second run → 0 upgraded, 3 already-v3 (idempotent). Brings total command count to 168.
2026-05-06 20:05:51 -07:00
"--migrate-jsondbc",
fix(cli): error on non-GUI options that are missing their argument Previously '--info-wcp' (no path) silently dropped into the GUI because the option-parse loop's i+1<argc guard hid the typo. Pre- scan and bail out with a helpful message before trying to start the editor, so users get fast feedback on bad invocations.
2026-05-06 08:08:05 -07:00
};
for (int i = 1; i < argc; i++) {
for (const char* opt : kArgRequired) {
if (std::strcmp(argv[i], opt) == 0 && i + 1 >= argc) {
std::fprintf(stderr, "%s requires an argument\n", opt);
return 1;
}
}
if (std::strcmp(argv[i], "--adt") == 0 && i + 3 >= argc) {
std::fprintf(stderr, "--adt requires <map> <x> <y>\n");
return 1;
}
feat(editor): add --diff-zone for comparing two unpacked zone dirs The natural counterpart to --diff-wcp (which compares two .wcp archives) — operates on the unpacked side of the workflow. Shows exactly what changed across zone.json fields, creature roster, object placements, and quest list: wowee_editor --diff-zone custom_zones/Base custom_zones/Variant Diff: custom_zones/Base vs custom_zones/Variant manifest : 2 field diff(s) ~ mapName: 'Base' -> 'Variant' ~ displayName: 'Base' -> 'Variant' creatures : 2 vs 2 - Bear + Tiger quests : 1 vs 2 + Defeat the Tiger Pairs naturally with --copy-zone: template a base zone, fork a variant, then diff to see exactly what was customized. Useful for PR review when a designer modifies a zone — diff against the upstream version to scope the change. Comparison strategy: sorted set diff on stable identifying fields (creature.name, object.path, quest.title). This intentionally hides position/orientation changes since those are continuous and would flag every pixel-perfect tweak as a diff — content-level changes are the signal here. Exit 0 if identical, 1 otherwise (so CI can gate). JSON mode emits per-category onlyA/onlyB arrays + manifestDiffs list + totalDiffs count for programmatic consumption. Verified: diffed two zones forked from a common base (one with creature swap + new quest); reported 5 diffs across manifest + creatures + quests with exit 1. Same zone vs itself reports IDENTICAL with exit 0.
2026-05-06 12:10:22 -07:00
if (std::strcmp(argv[i], "--diff-zone") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--diff-zone requires <zoneA> <zoneB>\n");
return 1;
}
feat(editor): add --diff-glb completing the diff-* family Structural compare of two glTF 2.0 binaries. Completes the diff suite alongside --diff-wcp (archive-vs-archive) and --diff-zone (unpacked-zone-vs-zone): wowee_editor --diff-glb a.glb b.glb Diff: a.glb vs b.glb a b meshes : 1 2 DIFF primitives : 256 2 DIFF accessors : 258 4 DIFF bufferViews : 3 3 buffers : 1 1 BIN bytes : 890880 1781760 DIFF Reports per-category counts side-by-side with a 'DIFF' marker on mismatches. Compares structure (mesh/primitive/accessor counts + BIN chunk size), NOT byte-level — JSON key ordering can vary between tools so a byte diff would have false positives. JSON mode emits the per-field {a, b} pair plus totalDiffs + identical bool for CI consumption. Useful for confirming alternate export paths produce equivalent output (does --bake-zone-glb match concatenated --export-whm-glbs? does a tool refactor preserve the same shape?). Verified: same file vs itself reports IDENTICAL with exit 0. Single-tile WHM .glb (1 mesh, 256 primitives, 890KB BIN) vs 2-tile bake (2 meshes, 2 primitives, 1.7MB BIN): correctly flags 4 DIFFs with exit 1.
2026-05-06 13:57:25 -07:00
if (std::strcmp(argv[i], "--diff-glb") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--diff-glb requires <a.glb> <b.glb>\n");
return 1;
}
feat(editor): add --diff-wom completing the diff suite for models Structural compare of two WOM models. Useful for verifying that --migrate-wom or a round-trip through OBJ/glTF/STL preserved the right counts: wowee_editor --diff-wom orig back Diff: orig.wom vs back.wom a b version : 1 1 vertices : 5 5 indices : 18 18 triangles : 6 6 textures : 0 0 bones : 0 0 animations : 0 0 batches : 0 0 name : Pyramid Pyramid bounds : match IDENTICAL Compares sizes only (vertex / index / bone / animation / batch / texture counts) plus name and bounds. Bounds match-with-epsilon (0.01 unit slop, generous since positions are typically yards) so text-format round-trips that perturb the last bit don't false-flag. Pointwise vertex compare is intentionally not done — it would be O(n²) and brittle to tiny float diffs from format conversions. Diff family is now complete: --diff-wcp (archive vs archive) --diff-zone (unpacked zone dir vs zone dir) --diff-glb (glTF binary vs glTF binary) --diff-wom (WOM model vs WOM model) Verified: identical pair reports IDENTICAL exit 0; pair with 1 extra vertex + extra triangle + name change correctly reports 4 DIFFs (verts/indices/triangles/name) with exit 1.
2026-05-06 14:13:07 -07:00
if (std::strcmp(argv[i], "--diff-wom") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--diff-wom requires <a-base> <b-base>\n");
return 1;
}
feat(editor): add --diff-wob completing the binary-format diff suite Companion to --diff-wom for buildings. Same count-based shape so round-trips through OBJ/glTF can be validated without false positives from float perturbation: wowee_editor --diff-wob orig back Diff: orig.wob vs back.wob a b groups : 5 5 portals : 3 3 doodads : 12 12 materials : 8 8 groupTex : 7 7 totalVerts : 4609 4609 totalIdx : 10950 10950 name : Stormwind Stormwind boundRadius : match IDENTICAL Compares: groups, portals, doodads, aggregated materials count (per-group materials summed), aggregated group-texture count, total verts/indices across all groups, name, boundRadius (with 0.01 epsilon). Diff family is now complete across every binary format that ships in a content pack: --diff-wcp archive vs archive --diff-zone unpacked zone dir vs zone dir --diff-glb glTF binary vs glTF binary --diff-wom WOM model vs WOM model --diff-wob WOB building vs WOB building Verified: identical pair reports IDENTICAL exit 0; pair with extra group + extra doodad + name change reports 6 DIFFs with exit 1.
2026-05-06 14:25:40 -07:00
if (std::strcmp(argv[i], "--diff-wob") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--diff-wob requires <a-base> <b-base>\n");
return 1;
}
feat(editor): add --diff-whm and --diff-woc completing the open-format diff suite Last two missing entries in the diff family — terrain heightmap pairs and collision meshes: wowee_editor --diff-whm Z1/Z1_30_30 Z2/Z2_31_30 Diff: ... a b tile : ( 30, 30) ( 31, 30) DIFF loadedChunks : 256 256 doodadPlace : 0 0 wmoPlace : 0 0 heightRange : [-1.50,1.50] [-1.50,1.50] wowee_editor --diff-woc tile_a.woc tile_b.woc Diff: ... a b tile : ( 30, 30) ( 31, 30) DIFF triangles : 32768 32768 walkable : 32768 32768 steep : 0 0 --diff-whm: tile coord, loaded chunk count, doodad/WMO placement counts, texture/name table sizes, height range (min/max with float epsilon). Pointwise height compare intentionally not done — float perturbation from format round-trips would false-flag. --diff-woc: tile coord, total triangles, walkable + steep counts. Catches whether a --regen-collision pass actually changed something. Diff family is now exhaustively complete for every shippable open format: --diff-wcp archive vs archive --diff-zone unpacked zone dir vs zone dir --diff-glb glTF binary vs glTF binary --diff-wom WOM model vs WOM model --diff-wob WOB building vs WOB building --diff-whm WHM/WOT terrain pair vs pair --diff-woc WOC collision vs collision Verified: tile (30,30) vs (31,30) reports tile DIFF + identical counts (since both are flat scaffolds); same-vs-self reports IDENTICAL with exit 0.
2026-05-06 14:35:03 -07:00
if (std::strcmp(argv[i], "--diff-whm") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--diff-whm requires <a-base> <b-base>\n");
return 1;
}
if (std::strcmp(argv[i], "--diff-woc") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--diff-woc requires <a.woc> <b.woc>\n");
return 1;
}
feat(editor): add --diff-jsondbc completing the diff family for the last text format Diff family is now exhaustively complete across every shippable format: --diff-wcp archive --diff-zone unpacked zone dir --diff-glb glTF binary --diff-wom WOM model --diff-wob WOB building --diff-whm WHM/WOT terrain pair --diff-woc WOC collision --diff-jsondbc JSON DBC sidecar <- new Schema-level compare: - format tag - source filename - recordCount + fieldCount (header values) - actualRecs (records[] array length) Useful for catching schema regressions when a sidecar is regenerated by a different tool version, or for verifying a --migrate-jsondbc pass actually changed what it claimed. Verified: same file vs itself reports IDENTICAL exit 0; 2-record vs 3-record (with same format/source/fieldCount) reports 2 DIFFs (recordCount + actualRecs) with exit 1.
2026-05-06 14:41:32 -07:00
if (std::strcmp(argv[i], "--diff-jsondbc") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--diff-jsondbc requires <a.json> <b.json>\n");
return 1;
}
feat(editor): add --diff-extract for asset-extract directory comparison Compares two extracted asset directories side-by-side per file extension. Useful for diffing a fresh asset_extract run against a previous baseline (did the new MPQ add files? did any get dropped?), or comparing what each WoW expansion contributes: wowee_editor --diff-extract baseline/ new/ Diff: baseline/ vs new/ totals: 4 files / 0.0 MB vs 4 files / 0.0 MB Per-extension (count then bytes): ext a count b count a bytes b bytes status .blp 2 2 0 0 .dbc 1 0 0 0 -A .m2 1 2 0 0 DIFF 2 extension(s) differ Status column flags imbalance: -A only in A (extension dropped going B-ward) +B only in B (extension added) DIFF count differs but both sides have some Recursive walk so subdirectories aggregate into the parent's extension counts. JSON mode emits per-extension {count,bytes} pairs for both sides plus union diff count for CI consumption. Diff family for directory-shaped formats: --diff-zone unpacked zone dir vs zone dir --diff-extract extracted asset dir vs extract dir <- new Verified on synthesized 4-file dirs (a: 2 blp + 1 dbc + 1 m2; b: 2 blp + 0 dbc + 2 m2): correctly flags -A on .dbc, DIFF on .m2, exit 1.
2026-05-06 15:25:18 -07:00
if (std::strcmp(argv[i], "--diff-extract") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--diff-extract requires <dirA> <dirB>\n");
return 1;
}
feat(editor): add --diff-checksum for SHA256SUMS comparison Compares two SHA256SUMS files (from --export-zone-checksum). Reports added / removed / changed entries between two zone snapshots — much faster than walking the filesystem to recompute hashes of unchanged content: wowee_editor --export-zone-checksum custom_zones/Z /tmp/before.sha256 ... edits happen ... wowee_editor --export-zone-checksum custom_zones/Z /tmp/after.sha256 wowee_editor --diff-checksum /tmp/before.sha256 /tmp/after.sha256 Diff: /tmp/before.sha256 vs /tmp/after.sha256 added : 1 removed : 0 changed : 0 + creatures.json Standard diff-style markers (+/-/~) for added/removed/changed, sorted within each category alphabetically. Use cases: - Audit what an editing session actually touched (snapshot before, snapshot after, diff) - Verify a zone bundle re-extracts identically (transfer integrity beyond the per-file PASS/FAIL of sha256sum -c) - CI gate: fail build if a refactor touches files it shouldn't Diff family for content/integrity formats: --diff-zone unpacked zone dir vs zone dir (high-level) --diff-extract per-extension counts in two extracts --diff-checksum per-file hash diff between two snapshots <- new Verified: scaffold + export checksum, add creature, re-export, diff correctly reports '+ creatures.json' (added) and exit 1.
2026-05-06 16:32:55 -07:00
if (std::strcmp(argv[i], "--diff-checksum") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--diff-checksum requires <a.sha256> <b.sha256>\n");
return 1;
}
feat(editor): add --diff-wcp CLI for archive comparison Compares two WCP archives file-by-file from their info JSON: lists added (+), removed (-), and size-changed (~) entries. Useful for verifying that an authoring tweak changed only what it claimed to change, and for editor-version regression detection. Exit code 0 if identical, 1 otherwise.
2026-05-06 08:29:21 -07:00
if (std::strcmp(argv[i], "--diff-wcp") == 0 && i + 2 >= argc) {
std::fprintf(stderr, "--diff-wcp requires two paths\n");
return 1;
}
feat(editor): add --add-creature CLI for headless creature placement Appends a single creature spawn to a zone's creatures.json. First real authoring tool that doesn't need the GUI placement system — useful for batch-populating zones via shell script: for npc in goblin spider wolf; do wowee_editor --add-creature "$zone" "$npc" 100 200 50 done Args: <zoneDir> <name> <x> <y> <z> [displayId] [level] - displayId 0 → SQL exporter substitutes 11707 (generic humanoid) - level defaults to 1 - Coordinates are render-space (renderX=wowY, renderY=wowX) Loads any existing creatures.json first then appends, so multiple invocations build up the file. The standard NPC spawner caps (50k creatures) protect against runaway scripts.
2026-05-06 11:35:07 -07:00
if (std::strcmp(argv[i], "--add-creature") == 0 && i + 5 >= argc) {
std::fprintf(stderr,
"--add-creature requires <zoneDir> <name> <x> <y> <z>\n");
return 1;
}
feat(editor): add --add-object CLI for headless M2/WMO placement Mirrors --add-creature for the object placer: wowee_editor --add-object <zoneDir> <m2|wmo> <gamePath> <x> <y> <z> [scale] Lets shell scripts populate objects/buildings without the GUI: for tree in 100,200 150,250 200,300; do x=${tree%,*}; y=${tree#*,} wowee_editor --add-object "$zone" m2 'World/Doodad/Tree.m2' $x $y 0 done Loads existing objects.json first then appends, so multiple invocations build up. Optional scale slot lets the caller set non-default size (clamped to >0 by the load-time guard). Verified end-to-end: scaffolded zone → added m2 + wmo → info-objects reports total=2 with the correct scale range.
2026-05-06 11:37:10 -07:00
if (std::strcmp(argv[i], "--add-object") == 0 && i + 6 >= argc) {
std::fprintf(stderr,
"--add-object requires <zoneDir> <m2|wmo> <gamePath> <x> <y> <z>\n");
return 1;
}
feat(editor): add --add-quest CLI for headless quest creation Third headless authoring command, finishing the trio: wowee_editor --add-quest <zoneDir> <title> [giverId] [turnInId] [xp] [level] Optional positional fields are read in order; omit from the right. Bare 'wowee_editor --add-quest zone Title' produces a valid quest with default values, matching the editor GUI's New Quest behavior. Verified: appended 3 quests (250+100+0 XP) to a scaffolded zone, --info-quests --json reports total=3, totalXp=450, withReward=3.
2026-05-06 11:41:11 -07:00
if (std::strcmp(argv[i], "--add-quest") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--add-quest requires <zoneDir> <title>\n");
return 1;
}
feat(editor): add --add-quest-objective for headless objective creation --add-quest creates a quest shell but quests with no objectives never complete in-game. This fills the gap: wowee_editor --add-quest-objective <zoneDir> <questIdx> \ <kill|collect|talk|explore|escort|use> <targetName> [count] Workflow: Z=custom_zones/MyZone wowee_editor --add-quest $Z 'Hunt Wolves' 100 100 250 5 wowee_editor --add-quest-objective $Z 0 kill 'Wolf' 5 wowee_editor --add-quest-objective $Z 0 collect 'Wolf Pelt' 3 Auto-generates a description from type+count+name so addons and tooltips show something sensible ('Slay 5 Wolf', 'Collect 3 Wolf Pelt', 'Talk to Mayor'). Designers can hand-edit quests.json after the fact for bespoke prose; the auto-text is the floor, not the ceiling. Quest index matches --list-quests output (0-based). Out-of-range index, unknown type, or missing quests.json all error with clear messages and exit 1. Verified: scaffolded zone, added 2 quests + 3 objectives across them; --info-quests reports '1 kill, 1 collect, 1 talk'. Bad type and bad index both rejected.
2026-05-06 12:12:06 -07:00
if (std::strcmp(argv[i], "--add-quest-objective") == 0 && i + 4 >= argc) {
std::fprintf(stderr,
"--add-quest-objective requires <zoneDir> <questIdx> <type> <targetName>\n");
return 1;
}
feat(editor): add --remove-quest-objective for symmetric CRUD Symmetric counterpart to --add-quest-objective. Quest design is iterative — when an objective gets reworked or trimmed, you need to remove the wrong one without nuking the entire quest. wowee_editor --remove-quest-objective <zoneDir> <questIdx> <objIdx> Both indices are 0-based and reported by --info-quests / --list-quests. Range-checks both: questIdx against quest count, objIdx against the selected quest's objective count. Each errors with a precise out-of- range message. Verified: scaffolded zone, added quest with 3 objectives (kill / collect / talk), removed objective at index 1 (the collect), --info-quests confirms '1 kill, 0 collect, 1 talk' afterward. Bad quest and bad objective indices both rejected with exit 1. Quest-authoring CLI is now fully symmetric: --add-quest --remove-quest --add-quest-objective --remove-quest-objective --add-quest-reward-item (additive only — items are dedup'd) --set-quest-reward (idempotent field-level update)
2026-05-06 12:35:10 -07:00
if (std::strcmp(argv[i], "--remove-quest-objective") == 0 && i + 3 >= argc) {
std::fprintf(stderr,
"--remove-quest-objective requires <zoneDir> <questIdx> <objIdx>\n");
return 1;
}
feat(editor): add --clone-quest for templating quests with shared shape Common designer workflow: build a base quest with objectives + rewards once, then make N variants ('Slay Wolves' / 'Slay Bears' / 'Slay Tigers') with the same shape. Doing this through individual --add-* commands means re-typing all objectives + items each time. --clone-quest deep-copies an existing quest in one shot: wowee_editor --clone-quest $Z 0 # 'Foo' -> 'Foo (copy)' wowee_editor --clone-quest $Z 0 'Slay Bears' # custom title Carries: - All objectives (deep copy via vector value-copy) - All item rewards - XP / coin reward fields - requiredLevel, giver, turnIn Resets: - id (set to 0; addQuest auto-assigns a fresh one) - nextQuestId (cleared — chaining the clone to the same next quest would corrupt chain semantics; user can re-set it explicitly) Verified: scaffolded zone, added quest with 2 objectives + 1 item + xp=250. Cloned twice (default name, custom name). Result: 3 quests in list, both clones have full objective list and reward intact.
2026-05-06 12:53:23 -07:00
if (std::strcmp(argv[i], "--clone-quest") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--clone-quest requires <zoneDir> <questIdx>\n");
return 1;
}
feat(editor): add --clone-creature symmetric to --clone-quest Designer workflow: archetype one 'patrol guard' with stats + faction + behavior + equipment dialed in, then stamp it across spawn points around a town: for x in 100 110 120 130; do wowee_editor --clone-creature $Z 0 "Guard $x" $x 200 50 done Defaults give safe behavior: - Position offset by (5, 0, 0) yards so the copy doesn't z-fight the original when no offset is passed. - Name appended with ' (copy)' if no newName given. - id reset (auto-assigned by NpcSpawner). - Patrol path NOT offset — patrol points are world-space waypoints, not relative to the spawn; cloning that vector unchanged matches designer intent. Re-author the path on the clone if needed. Verified: scaffolded zone, added Guard, cloned twice (default offset, custom name + 3D offset). list-creatures shows 3 spawns with correctly differentiated positions and names.
2026-05-06 12:57:31 -07:00
if (std::strcmp(argv[i], "--clone-creature") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--clone-creature requires <zoneDir> <idx>\n");
return 1;
}
feat(editor): add --clone-object completing the CRUD-clone trio Symmetric to --clone-creature and --clone-quest. Common workflow: place one tree just right (rotation, scale dialed in), then clone N copies along a path: for x in 100 110 120 130 140; do wowee_editor --clone-object $Z 0 $x 0 0 done Defaults match --clone-creature: 5-yard X offset prevents z-fighting. Rotation and scale carry over verbatim (so a tilted barrel stays tilted). uniqueId is reset so the new placement doesn't collide with the source's identifier in any downstream system that dedups by it. CRUD-clone surface is now complete: --clone-quest <zone> <questIdx> [newTitle] --clone-creature <zone> <idx> [newName] [dx dy dz] --clone-object <zone> <idx> [dx dy dz] Verified: scaffolded zone, added a tree at (100, 200, 50, scale=1.5). Cloned twice (default offset, custom offset). Result: 3 trees with correctly-shifted positions and preserved scale=1.50.
2026-05-06 13:10:25 -07:00
if (std::strcmp(argv[i], "--clone-object") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--clone-object requires <zoneDir> <idx>\n");
return 1;
}
feat(editor): add --add-quest-reward-item and --set-quest-reward Closes the quest-authoring CLI: --add-quest creates a quest, then --add-quest-objective adds completion conditions, and now these add the rewards. wowee_editor --add-quest-reward-item $Z 0 'Item:Sword' 'Item:Shield' 'Item:Potion' wowee_editor --set-quest-reward $Z 0 --xp 999 --gold 5 --silver 30 --add-quest-reward-item greedy-consumes any trailing positional args that don't start with '-', so a whole loot table can be added in one invocation rather than N round-trips through load+save. --set-quest-reward updates only the fields explicitly passed (--xp / --gold / --silver / --copper) — avoids the round-trip-and-clobber footgun of a 'replace whole reward' command. Field flags are order-independent. At least one flag is required (else error). Both validate questIdx against quest count and bail with exit 1 on out-of-range / missing file / bad numeric value. Verified: scaffolded zone, added quest with default xp=100, batch- added 3 item rewards in one shot, then set xp=999/gold=5/silver=30 in one shot. --info-quests reports total XP=999, with-items=1.
2026-05-06 12:18:20 -07:00
if (std::strcmp(argv[i], "--add-quest-reward-item") == 0 && i + 3 >= argc) {
std::fprintf(stderr,
"--add-quest-reward-item requires <zoneDir> <questIdx> <itemPath>\n");
return 1;
}
if (std::strcmp(argv[i], "--set-quest-reward") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--set-quest-reward requires <zoneDir> <questIdx> [--xp N] [--gold N] [--silver N] [--copper N]\n");
return 1;
}
feat(editor): add --add-tile to extend a zone with another ADT tile --scaffold-zone creates a zone with one tile; some zones (continent fragments, large dungeons) span multiple ADT tiles. This extends an existing zone: wowee_editor --add-tile custom_zones/MyZone 29 30 # default baseHeight=100 wowee_editor --add-tile custom_zones/MyZone 28 31 250.5 # custom baseHeight What it does: - Generates a fresh blank-flat WHM/WOT pair via the same factory --scaffold-zone uses, so output is consistent. - Appends (tx, ty) to ZoneManifest::tiles. Save() rebuilds the files-block from tiles, so the new adt_TX_TY entry appears automatically in zone.json. Safety: - Tile coord must be in WoW grid [0, 64) per axis; rejects 99,99. - Refuses if the tile is already in the manifest (catches typos). - Refuses if the .whm/.wot files exist on disk but aren't in the manifest (catches manifest-out-of-sync drift from hand edits). - Optional baseHeight allows seeding flat terrain at a non-default elevation. Verified end-to-end: scaffolded 1-tile zone, added 2 more tiles (one with custom height). Result: 3 tiles in manifest, 6 files on disk, files-block has all 3 adt_TX_TY entries. Duplicate and out-of-range cases both rejected with exit 1.
2026-05-06 12:33:32 -07:00
if (std::strcmp(argv[i], "--add-tile") == 0 && i + 3 >= argc) {
std::fprintf(stderr,
"--add-tile requires <zoneDir> <tx> <ty>\n");
return 1;
}
feat(editor): add --remove-tile and --list-tiles for zone tile management Round out the tile lifecycle CLI. --add-tile shipped earlier; these are the symmetric counterparts: wowee_editor --list-tiles custom_zones/MyZone wowee_editor --list-tiles custom_zones/MyZone --json wowee_editor --remove-tile custom_zones/MyZone 31 30 --list-tiles: shows tile coords AND on-disk presence of .whm/.wot/.woc per tile, so you can spot manifest-vs-disk drift before pack-wcp would complain. JSON mode emits per-tile records for programmatic checks. --remove-tile: drops the manifest entry AND deletes the .whm/.wot/.woc files for that tile so the zone stays consistent (no orphan sidecars). Refuses to remove the last tile — server module gen and pack-wcp both expect at least one, so a zero-tile zone would just be a footgun. Use 'rm -rf custom_zones/X/' for total removal. Verified end-to-end: scaffolded zone, added 2 more tiles, built WOC on one. --list-tiles shows 3 tiles with correct file presence (y/y/y on the built one, y/y/- on the others). Removed (31, 30) — 2 files deleted, 2 tiles remaining. Tried removing last tile after dropping to 1: correctly refused with exit 1.
2026-05-06 12:40:19 -07:00
if (std::strcmp(argv[i], "--remove-tile") == 0 && i + 3 >= argc) {
std::fprintf(stderr,
"--remove-tile requires <zoneDir> <tx> <ty>\n");
return 1;
}
feat(editor): add --copy-zone CLI for templating zones Duplicate an existing zone to a new slug: wowee_editor --copy-zone custom_zones/Original "My New Zone" Workflow this enables: scaffold one base zone, populate it with creatures/objects/quests, then copy-zone N times to create variants without re-scaffolding each. Designers can template a 'forest base' zone and stamp it into Dark Forest, Frozen Forest, etc. What it does: - Recursive copy preserves any subdirs (e.g. data/ for DBC sidecars) - Reads source slug from zone.json (not the dir name) to know what prefix to rewrite — handles users who renamed dirs without touching the manifest - Renames slug-prefixed files (Original_28_30.whm -> NewSlug_28_30.whm, matches both _-suffixed and .-suffixed forms) - Saves a fresh zone.json via ZoneManifest::save which rebuilds the files-block from mapName, so the manifest references the renamed files correctly Verified end-to-end: scaffolded Original, added creature + quest, copied to 'My New Zone'. Result: 2 files renamed, zone.json mapName/displayName/files all updated, creatures.json + quests.json copied verbatim.
2026-05-06 11:44:31 -07:00
if (std::strcmp(argv[i], "--copy-zone") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--copy-zone requires <srcDir> <newName>\n");
return 1;
}
feat(editor): add --rename-zone for in-place zone renames --copy-zone duplicates and renames; --rename-zone does it in place without doubling disk usage. Useful when fixing typos or rebranding a zone without touching its data: wowee_editor --rename-zone custom_zones/Old 'Brand New Name' What changes: - zone.json mapName: Old -> Brand_New_Name - zone.json displayName: 'Old' -> 'Brand New Name' - zone.json files block (adt_NN_NN, wdt): regenerated from new slug - slug-prefixed files: Old_28_30.whm -> Brand_New_Name_28_30.whm - the directory itself: custom_zones/Old/ -> custom_zones/Brand_New_Name/ Order of operations matters for crash safety: slug-prefixed files get renamed first (atomic per-file via fs::rename), then the manifest is rewritten in the still-named source dir, then the directory is moved last. If the dir-move fails we surface the manifest-already-updated state so the user can recover. Refuses to run if target dir already exists (avoids silent merge), or if both slug AND displayName already match the target (no-op). Verified end-to-end: scaffolded 'Old' with 1 creature, renamed to 'Brand New Name'. Result: dir renamed, .whm/.wot files renamed, zone.json fully updated, creatures.json preserved with 1 entry.
2026-05-06 12:24:36 -07:00
if (std::strcmp(argv[i], "--rename-zone") == 0 && i + 2 >= argc) {
std::fprintf(stderr,
"--rename-zone requires <srcDir> <newName>\n");
return 1;
}
feat(editor): add --remove-{creature,object,quest} CRUD-delete commands Symmetric counterparts to --add-{creature,object,quest} from earlier batches: wowee_editor --remove-creature <zoneDir> <index> wowee_editor --remove-object <zoneDir> <index> wowee_editor --remove-quest <zoneDir> <index> Index is 0-based and is reported in the corresponding --info-* output; nothing identifies entries reliably across reloads, so name-based removal would silently delete the wrong row when duplicates exist. Pair them in scripts: idx=$(wowee_editor --info-creatures $Z/creatures.json --json | jq '.spawns | map(.name) | index("Wolf")') wowee_editor --remove-creature $Z $idx Each prints the removed entry's name/path and the new total so scripts can verify the right row went away. Out-of-range indices exit 1 with a clear message. Verified end-to-end: scaffolded zone, added 3 creatures + 2 objects + 2 quests, removed one of each by index, totals correctly went 3->2/2->1/2->1. Bad index 99 properly errors out.
2026-05-06 12:01:52 -07:00
for (const char* opt : {"--remove-creature", "--remove-object",
"--remove-quest"}) {
if (std::strcmp(argv[i], opt) == 0 && i + 2 >= argc) {
std::fprintf(stderr, "%s requires <zoneDir> <index>\n", opt);
return 1;
}
}
fix(cli): error on non-GUI options that are missing their argument Previously '--info-wcp' (no path) silently dropped into the GUI because the option-parse loop's i+1<argc guard hid the typo. Pre- scan and bail out with a helpful message before trying to start the editor, so users get fast feedback on bad invocations.
2026-05-06 08:08:05 -07:00
}
feat(editor): add standalone world editor (rough/WIP) Standalone wowee_editor tool for creating custom WoW zones. This is a rough initial implementation — many features work but M2/WMO rendering still has issues (frame sync, texture layout transitions) and needs further polish. Terrain: - Create new blank terrain with 10 biome types (Grassland, Forest, Jungle, Desert, Barrens, Snow, Swamp, Rocky, Beach, Volcanic) - Load existing ADT tiles from extracted game data - Sculpt brushes: Raise, Lower, Smooth, Flatten, Level - Chunk edge stitching prevents seams between tiles - Undo/redo (100-deep stack, Ctrl+Z/Ctrl+Shift+Z) - Save to WoW ADT/WDT format Texture Painting: - Paint/Erase/Replace Base modes - Full tileset texture browser (1285 textures from manifest) - Per-zone directory filtering and search - Alpha map editing with 4-layer limit (auto-replaces weakest) Object Placement: - M2 and WMO model placement with full manifest browser (11k M2s, 2k WMOs) - M2Renderer + WMORenderer integrated (loads .skin files for WotLK) - Ghost preview follows cursor before placing - Ctrl+click selection, right-click context menu - Transform gizmo (Move/Rotate/Scale with axis constraints) - Position/rotation/scale editing in properties panel NPC/Monster System: - 631 creature presets scanned from manifest, categorized (Critters, Beasts, Humanoids, Undead, Demons, etc.) - Stats editor: level, health, mana, damage, armor, faction - Behavior: Stationary, Patrol, Wander, Scripted - Aggro/leash radius, respawn time, flags (hostile/vendor/etc.) - Save creature spawns to JSON Water: - Place water at configurable height per chunk - Liquid types: Water, Ocean, Magma, Slime - Rendered as translucent colored quads - Saved in ADT MH2O format Infrastructure: - Free-fly camera (WASD/QE, right-drag look, scroll speed) - 5-mode toolbar: Sculpt | Paint | Objects | Water | NPCs - Asset browser indexes full manifest on startup - Editor water/marker shaders (pos+color vertex format) - forceNoCull added to M2Renderer for editor use - AssetManifest::getEntries() and AssetManager::getManifest() exposed Known issues: - M2/WMO rendering may not display on first placement (frame index sync between update/render was misaligned — now fixed but untested end-to-end) - Validation layer errors on shutdown (resource cleanup ordering) - Object placement on steep terrain can miss raycast - No undo for texture painting or object placement yet
2026-05-05 03:47:03 -07:00
for (int i = 1; i < argc; i++) {
refactor(editor): extract gen-audio-* handlers into cli_gen_audio.cpp main.cpp had grown past 28k lines, with each new procedural- generation command adding 100-200 lines to the inline if/else dispatch chain. This commit starts breaking that up by moving the four audio-related handlers (--gen-audio-tone, -noise, -sweep, --gen-zone-audio-pack) into their own translation unit. Pattern established here for future family extractions: - Family lives in cli_<family>.{hpp,cpp} - Single dispatch entry point: bool handle<Family>(int& i, int argc, char** argv, int& outRc) — true if matched (writes outRc), false to fall through. - main.cpp's argv loop calls each family's dispatcher first and returns its outRc on match, before the legacy in-line chain. Side-benefit: consolidated the duplicated 25-line WAV header writer + 5ms attack/release envelope into shared helpers (writeWavMono16, applyEdgeEnvelope) at the top of the new file. main.cpp drops from 28,943 → 28,329 lines (-614). Audio family is fully self-contained (~440 lines), behavior unchanged (verified by re-running tone/noise/sweep + zone-audio-pack).
2026-05-08 16:19:30 -07:00
// Modular handler families: extracted from the in-line if/else
// chain below to keep main.cpp from sprawling further. Each
// family lives in its own .cpp; if it matches argv[i] it
// sets outRc and we exit. Otherwise fall through to the
// legacy in-line dispatch.
{
int outRc = 0;
if (wowee::editor::cli::handleGenAudio(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract zone-pack orchestrators into cli_zone_packs.cpp Continues the modularization started in 6c9ab6fa. Moves the four pack-orchestrator handlers (--gen-zone-texture-pack, -mesh-pack, -starter-pack, --gen-project-starter-pack) into their own file following the same handle<Family> pattern. Side cleanup: - Consolidated the duplicated --seed flag parser into a single parseSeedFlag helper - Consolidated the std::system + > /dev/null wrap into runSilently main.cpp drops 28,329 → 28,070 lines (-259). Pack family is fully self-contained (~260 lines), behavior unchanged (verified by re-running gen-zone-starter-pack and confirming 6 PNGs + 5 WOMs).
2026-05-08 16:46:14 -07:00
if (wowee::editor::cli::handleZonePacks(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract audit family into cli_audits.cpp Continues the modularization. Moves the four audit handlers (--validate-zone-pack, --validate-project-packs, --info-zone-deps, --info-project-deps) into their own file using the same handle<Family>(int& i, int argc, char** argv, int& outRc) pattern. Side-cleanup: the two project-scope audits had identical subprocess-fanout structure (enumerate zones → run per-zone command → tally PASS/FAIL → print summary). Consolidated that into a shared runPerZoneAudit helper. Saves ~80 lines of duplicated dispatch code. main.cpp drops 28,070 → 27,736 lines (-334). Audit family is fully self-contained (~330 lines), behavior unchanged (verified all 4 commands against existing test zones).
2026-05-08 17:12:10 -07:00
if (wowee::editor::cli::handleAudits(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract README generators into cli_readmes.cpp Continues the modularization. Moves --gen-zone-readme and --gen-project-readme into their own translation unit using the established handle<Family> dispatch pattern. Consolidated the trailing --out flag parser into a single parseOutFlag helper (was duplicated between the two handlers). main.cpp drops 27,736 → 27,445 lines (-291). Behavior unchanged (verified by re-generating README and PROJECT.md, contents identical to pre-refactor output).
2026-05-08 17:36:10 -07:00
if (wowee::editor::cli::handleReadmes(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract per-zone inventory into cli_zone_inventory.cpp Continues the modularization. Moves the four per-zone inventory handlers into their own file: --list-zone-meshes (WOM stats) --list-zone-audio (WAV header parse) --list-zone-textures (texture-ref histogram) --info-zone-summary (BOOTSTRAPPED/PARTIAL/EMPTY status) Each consumes a trailing --json flag the same way; consolidated that check into a consumeJsonFlag helper at the top. main.cpp drops 27,445 → 27,200 lines (-245). Per-zone inventory behavior unchanged (re-verified all 4 commands). A pre-existing duplicate --list-zone-meshes handler (the older detailed per-mesh listing, similar to the --list-project-meshes collision fixed in 976549fe) is now dead code in the in-line chain since the extracted module dispatches first. Will rename or remove that duplicate in a follow-up cleanup.
2026-05-08 18:24:01 -07:00
if (wowee::editor::cli::handleZoneInventory(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract project inventory into cli_project_inventory.cpp Pairs with the per-zone inventory module from c0f2ab75. Moves the five project-wide inventory handlers into their own file: --list-project-meshes (per-zone WOM aggregate) --list-project-meshes-detail (per-mesh sorted listing) --list-project-audio (per-zone WAV aggregate) --list-project-textures (per-zone + global texture refs) --info-project-summary (BOOTSTRAPPED/PARTIAL/EMPTY rollup) All five enumerate zones the same way; consolidated that into a shared enumerateZones() helper at file scope. main.cpp drops 27,200 → 26,650 lines (-550). Behavior unchanged across all 5 commands (verified against /tmp/proj_starter).
2026-05-08 18:47:06 -07:00
if (wowee::editor::cli::handleProjectInventory(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract 7 newer texture generators into cli_gen_texture.cpp Moves the Worley/cellular-noise-based texture handlers (--gen-texture-cobble, -marble, -metal, -leather, -sand, -snow, -lava) into their own translation unit. Each handler previously had its own ~33-line copy of the parseHex lambda; all 7 copies are replaced with a single shared parseHex helper at file scope. Older simpler generators (gradient/noise/radial/stripes/dots/ rings/checker/brick/wood/grass/fabric) still live in main.cpp and will be migrated in subsequent batches. main.cpp drops 26,286 → 25,494 lines (-792). Behavior unchanged across all 7 handlers (re-verified).
2026-05-08 20:59:02 -07:00
if (wowee::editor::cli::handleGenTexture(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract 12 composite mesh primitives into cli_gen_mesh.cpp Moves the recently-added composite-prop mesh handlers (rock, pillar, bridge, tower, house, fountain, statue, altar, portal, archway, barrel, chest) into their own translation unit. These 12 handlers were the most contiguous block of similar-shaped mesh code in main.cpp. Other mesh handlers (--gen-mesh dispatcher, fence, tree, grid, stairs, disc, tube, capsule, arch, pyramid, from-heightmap, textured) still live in main.cpp and may be migrated in subsequent batches. main.cpp drops 24,270 → 22,681 lines (-1,589). Behavior verified by re-running rock/chest/archway/fountain.
2026-05-08 22:19:41 -07:00
if (wowee::editor::cli::handleGenMesh(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract mesh ⇄ heightmap I/O into cli_mesh_io.cpp Moves the three mesh-PNG bridge handlers (--displace-mesh, --gen-mesh-from-heightmap, --export-mesh-heightmap) out of main.cpp into their own translation unit. These three are distinct from the gen-mesh-* primitive generators in that they read or write external image files rather than synthesize geometry from parameters alone. main.cpp drops 21,061 → 20,741 lines (-320). Behavior verified by re-running gen-mesh-from-heightmap → validate-wom → and displace-mesh on a fresh plane.
2026-05-09 00:04:27 -07:00
if (wowee::editor::cli::handleMeshIO(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract 10 mesh edit ops into cli_mesh_edit.cpp Moves the WOM mesh editing/transform handlers out of main.cpp: --add-texture-to-mesh --scale-mesh --translate-mesh --strip-mesh --rotate-mesh --center-mesh --flip-mesh-normals --mirror-mesh --smooth-mesh-normals --merge-meshes These are the post-generation manipulators (load → mutate → save) distinct from the geometry generators in cli_gen_mesh.cpp and the heightmap I/O in cli_mesh_io.cpp. main.cpp drops 20,741 → 20,005 lines (-736). Behavior verified by piping a fresh cube through scale → translate → center.
2026-05-09 00:36:51 -07:00
if (wowee::editor::cli::handleMeshEdit(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract WOM info handlers into cli_wom_info.cpp Moves the WOM model inspection commands out of main.cpp: --info (bare WOM summary) --info-batches (per-batch material info) --info-textures (texture path list) --info-doodads (WOB doodad set / instance list) --info-attachments ⎫ combined handler with same M2 load + --info-particles ⎬ skin merge but different sub-array --info-sequences ⎭ iteration --info-bones (bone hierarchy) --export-bones-dot (Graphviz DOT output) main.cpp drops 20,005 → 19,446 lines (-559). Behavior verified by running --info, --info-batches, --info-textures on a fresh WOM. Build error during extraction (combined-or handler header spanned 4 lines, the transform script only stripped the first; also missing #include for WoweeBuildingLoader) caught by build and fixed before commit.
2026-05-09 01:18:09 -07:00
if (wowee::editor::cli::handleWomInfo(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract format validation into cli_format_validate.cpp Moves the open-format validation + project-audit handlers out of main.cpp: --validate --validate-wom --validate-wob --validate-woc --validate-whm --validate-all --validate-project --validate-project-open-only --audit-project --bench-audit-project --bench-validate-project Also moves the four shared validate*Errors helpers (validateWom/ Wob/Woc/WhmErrors, ~365 lines) into the same module's anonymous namespace — they were file-scope helpers in main.cpp used only by these handlers, so co-locating eliminates the cross-TU coupling. main.cpp drops 19,446 → 18,396 lines (-1,050). Two build errors caught during extraction (wrong include path for the WHM loader header; missing #include for ContentPacker / std::set / std::map); all fixed before commit.
2026-05-09 01:57:37 -07:00
if (wowee::editor::cli::handleFormatValidate(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract batch convert handlers into cli_convert.cpp Moves the four bulk format-conversion handlers out of main.cpp: --convert-m2-batch (M2 → WOM) --convert-wmo-batch (WMO → WOB) --convert-blp-batch (BLP → PNG) --convert-dbc-batch (DBC → JSON) These all share the same pattern: walk srcDir recursively for files of the input extension and fan out to the single-file --convert-* counterpart via subprocess (preserving the existing per-file logic as the source of truth, no duplication). Single-file converters (--convert-m2, --convert-wmo, etc.) and the --migrate-* meta-commands still live in main.cpp; they're in dedicated argv-rescan loops that need a different extraction approach. main.cpp drops 18,396 → 18,198 lines (-198). Behavior verified by re-running --convert-blp-batch with a missing directory and confirming the same error message.
2026-05-09 02:25:05 -07:00
if (wowee::editor::cli::handleConvert(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract format inspection handlers into cli_format_info.cpp Moves the proprietary-format inspection commands out of main.cpp into their own translation unit. Each reads a Blizzard-format file and prints its structure: --info-png --info-blp --info-m2 --info-wmo --info-adt --info-jsondbc main.cpp drops 18,198 → 17,766 lines (-432). Behavior verified by re-running --info-png on a generated noise texture.
2026-05-09 02:48:58 -07:00
if (wowee::editor::cli::handleFormatInfo(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract WCP pack handlers into cli_pack.cpp Moves the six WoWee Content Pack (.wcp) handlers out of main.cpp: --list-wcp --info-wcp --info-pack-budget --info-pack-tree --pack-wcp --unpack-wcp All six defer to wowee::editor::ContentPacker for actual pack I/O; the handlers just parse args and format output, so the extraction has no behavioral impact on the pack format itself. main.cpp drops 17,766 → 17,505 lines (-261). Behavior verified by re-running --info-wcp on a missing file (same error message).
2026-05-09 03:12:09 -07:00
if (wowee::editor::cli::handlePack(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract creature/object/quest info into cli_content_info.cpp Moves 16 contiguous content-inspection handlers out of main.cpp: --info-creatures --info-creatures-by-faction --info-creatures-by-level --info-objects-by-path --info-objects-by-type --info-quests-by-level --info-quests-by-xp --list-creatures --list-objects --list-quests --list-quest-objectives --list-quest-rewards --info-quest-graph-stats --info-creature --info-quest --info-object All read JSON sidecars (creatures.json, objects.json, quests.json) via wowee::editor::{NpcSpawner, ObjectPlacer, QuestEditor} loaders. main.cpp drops 17,505 → 16,564 lines (-941). Behavior verified by running --info-creatures (correctly fails with same parse- error message on a non-zone path).
2026-05-09 03:33:40 -07:00
if (wowee::editor::cli::handleContentInfo(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract zone/project metadata info into cli_zone_info.cpp Moves the three zone & project metadata inspection handlers out of main.cpp: --info-zone (single zone.json print) --info-zone-overview (high-level zone digest) --info-project-overview (per-zone summary table for a project) All three load zone.json via wowee::editor::ZoneManifest. main.cpp drops 16,564 → 16,321 lines (-243). Behavior verified by re-running --info-zone + --info-project-overview against existing test zones.
2026-05-09 03:52:44 -07:00
if (wowee::editor::cli::handleZoneInfo(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract data-tree audit/migration into cli_data_tree.cpp Moves the seven proprietary-data-tree handlers out of main.cpp: --migrate-data-tree --bench-migrate-data-tree --list-data-tree-largest --export-data-tree-md --info-data-tree --strip-data-tree --audit-data-tree All operate on a Blizzard-format extracted Data tree (the .m2/ .skin/.wmo/.blp/.dbc files) — they audit, migrate, or strip proprietary-format files in support of the open-format migration story. Original placement spanned two sub-blocks (12546-12892 and 13093-13417 in main.cpp) interrupted by --gen-texture and --add-texture-to-zone in the middle. Extraction collapses both sub-blocks into one cohesive translation unit. main.cpp drops 16,321 → 15,653 lines (-668). Behavior verified by re-running --info-data-tree against a missing directory.
2026-05-09 04:14:32 -07:00
if (wowee::editor::cli::handleDataTree(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract 10 diff handlers into cli_diff.cpp Moves the file-comparison handlers out of main.cpp into their own translation unit: --diff-wcp --diff-zone --diff-glb --diff-wom --diff-wob --diff-whm --diff-woc --diff-jsondbc --diff-extract --diff-checksum main.cpp drops 15,653 → 14,732 lines (-921). One build error during extraction (missing #include for NpcSpawner / ObjectPlacer / QuestEditor used by --diff-zone) caught by build and fixed.
2026-05-09 04:35:08 -07:00
if (wowee::editor::cli::handleDiff(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract 8 spawn/snap handlers into cli_spawn_audit.cpp Moves the NPC spawn / object placer audit + ground-snap handlers out of main.cpp: --snap-zone-to-ground --snap-project-to-ground --audit-zone-spawns --audit-project-spawns --list-zone-spawns --list-project-spawns --diff-zone-spawns --info-spawn All operate on creatures.json + objects.json sidecars and the WHM terrain heightfield via WoweeTerrainLoader. main.cpp drops 14,628 → 13,887 lines (-741). Behavior verified by re-running --audit-zone-spawns on a test zone (PASSED with 0 issues, same as before).
2026-05-09 05:05:22 -07:00
if (wowee::editor::cli::handleSpawnAudit(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract 5 item read-only handlers into cli_items.cpp Moves the items.json read-only inspection handlers out of main.cpp: --list-items --info-item --validate-items --validate-project-items --info-project-items Item editing handlers (--add-item, --set-item, --remove-item, --add-quest-reward-item) stay in main.cpp since they share state with quest reward editing logic and would need a broader extraction. main.cpp drops 13,887 → 13,485 lines (-402). Behavior verified by re-running --list-items on a non-items zone (same error message).
2026-05-09 05:19:04 -07:00
if (wowee::editor::cli::handleItems(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract data-tree inspection into cli_extract_info.cpp Moves the four extracted-Data-tree audit handlers out of main: --info-extract (per-extension counts + bytes) --info-extract-tree (per-directory rollup) --info-extract-budget (proprietary share + open-format gap) --list-missing-sidecars (find unconverted .m2/.wmo/.blp/.dbc) All four operate on a Blizzard-format extracted Data tree — they audit what's there and what's missing in the migration from proprietary formats to open ones. main.cpp drops 13,485 → 13,120 lines (-365). Behavior verified by re-running --info-extract on a test zone (same output).
2026-05-09 05:32:27 -07:00
if (wowee::editor::cli::handleExtractInfo(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract 9 export handlers + sha256 helper into cli_export.cpp Moves the report-export handlers (md / csv / html / sha256 / graphviz) for zone & project audits out of main.cpp: --export-zone-summary-md --export-zone-csv --export-zone-checksum --export-project-checksum --validate-project-checksum --export-zone-html --export-project-html --export-project-md --export-quest-graph Also moves the file-scope wowee_sha256 namespace (the SHA-256 implementation that the checksum exporters use) into the new module's anonymous namespace — it had no other callers in main.cpp so no cross-TU coupling needed. main.cpp drops 13,120 → 12,119 lines (-1,001). Build error during extraction (missing #include <unordered_set>) caught and fixed.
2026-05-09 05:45:00 -07:00
if (wowee::editor::cli::handleExport(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract zone/project mesh-bake handlers into cli_bake.cpp Moves the 3D-export bake handlers out of main.cpp: --bake-zone-glb --bake-zone-stl --bake-zone-obj --bake-project-obj --bake-project-stl --bake-project-glb The STL + GLB project bakes share a combined dispatcher (one function with internal STL-vs-GLB branching) since they walk the same per-zone asset list and only differ in the output emission code. main.cpp drops 12,119 → 11,261 lines (-858). The combined-OR opener spanning multiple lines created a parse-error fragment in the extraction; caught + manually fixed before commit (same pattern as the WOM info attachments/particles/sequences extraction).
2026-05-09 05:57:25 -07:00
if (wowee::editor::cli::handleBake(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --migrate-* handlers into cli_migrate.cpp Moves the four schema-migration handlers (--migrate-wom, --migrate-zone, --migrate-project, --migrate-jsondbc) out of main.cpp into a new cli_migrate.{hpp,cpp} module. Same behavior — they're idempotent in-place upgraders for older WOM revisions and JSON DBC sidecar schemas. main.cpp shrinks by 282 lines (11,261 → 10,979).
2026-05-09 06:13:41 -07:00
if (wowee::editor::cli::handleMigrate(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract single-file --convert-* into cli_convert_single.cpp Moves the five single-file format converters (--convert-m2, --convert-wmo, --convert-dbc-json, --convert-json-dbc, --convert-blp-png) out of two dedicated post-loop blocks in main.cpp into a new cli_convert_single.{hpp,cpp} module. The batch wrappers in cli_convert.cpp keep working — they shell out to wowee_editor with these flags. main.cpp shrinks by ~335 lines (10,979 → 10,644). The two trailing for-loops were dead code after wiring the dispatcher into the main loop, so they're gone too.
2026-05-09 06:25:04 -07:00
if (wowee::editor::cli::handleConvertSingle(i, argc, argv,
dataPath, outRc)) {
return outRc;
}
refactor(editor): extract interop --validate-* into cli_validate_interop.cpp Moves the four structural validators for INTEROP file formats (--validate-stl, --validate-png, --validate-blp, --validate-jsondbc) out of main.cpp into a new cli_validate_interop.{hpp,cpp} module. These check files coming in/out of wowee from third-party tools, distinct from cli_format_validate.cpp which validates the native open formats (WOM, WOB, WOC, WHM). main.cpp shrinks by 524 lines (10,644 to 10,121). Each validator preserves its --json output mode for machine-readable reports.
2026-05-09 06:36:02 -07:00
if (wowee::editor::cli::handleValidateInterop(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract GLB inspectors into cli_glb_inspect.cpp Moves all 4 GLB introspection handlers (--validate-glb / --info-glb shared, --info-glb-tree, --info-glb-bytes, --check-glb-bounds) out of main.cpp into a new cli_glb_inspect.{hpp,cpp} module. GLB is our open replacement for proprietary M2/WMO bake outputs, so these belong with the other open-format tooling. main.cpp shrinks by 657 lines (10,121 to 9,464). Every handler preserves its --json output mode for machine-readable reports.
2026-05-09 06:46:02 -07:00
if (wowee::editor::cli::handleGlbInspect(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract WOM <-> OBJ/GLB/STL into cli_wom_io.cpp Moves the four WOM interchange-format handlers (--export-obj, --export-glb, --export-stl, --import-stl) out of main.cpp into a new cli_wom_io.{hpp,cpp} module. WOM is our open M2 replacement; these are the bridge that lets it round-trip through every external 3D tool — Blender, Three.js, slicers, CAD packages — so the open format is actually useful. main.cpp shrinks by 467 lines (9,464 to 8,997). The five WOB and WHM exporters (--export-wob-glb, --export-whm-glb, etc.) remain inline for a follow-up extraction.
2026-05-09 06:55:00 -07:00
if (wowee::editor::cli::handleWomIo(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract WOB/WHM/WOC IO into cli_world_io.cpp Moves all six world-asset interchange handlers (--export-wob-glb, --export-wob-obj, --import-wob-obj, --export-whm-glb, --export-whm-obj, --export-woc-obj) out of main.cpp into a new cli_world_io.{hpp,cpp} module. WOB / WHM / WOC are our open replacements for proprietary WMO / ADT-heightmap / ADT-collision data; these are the bridge that lets the open formats round-trip through Blender, MeshLab, Three.js, and the rest of the standard 3D toolchain. main.cpp shrinks by 858 lines (8,997 to 8,140). The single-mesh --import-obj handler stays inline for now -- it shadow-mirrors cli_wom_io's --import-stl semantics and will move there next.
2026-05-09 07:03:14 -07:00
if (wowee::editor::cli::handleWorldIo(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --info-{zone,project}-tree into cli_info_tree.cpp Moves the two tree-style content browser handlers (--info-zone-tree, --info-project-tree) out of main.cpp into a new cli_info_tree.{hpp,cpp} module. Both render Unix-`tree`-style hierarchical views — one drilling into a single zone (manifest, tiles, creatures, objects, quests, files) and one giving a bird's-eye view of every zone in a project with bake/viewer status. main.cpp shrinks by 201 lines (8,140 to 7,939). The remaining info-zone/-project-* pairs (bytes, extents, water, density, audio) form the next natural extraction batch.
2026-05-09 07:10:12 -07:00
if (wowee::editor::cli::handleInfoTree(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --info-{zone,project}-bytes into cli_info_bytes.cpp Moves the two disk-byte audit handlers (--info-zone-bytes, --info-project-bytes) out of main.cpp into a new cli_info_bytes.{hpp,cpp} module. Both categorize files by extension into open / proprietary / derived buckets — the project-wide variant is the headline metric for tracking the open-format migration's progress against the .m2/.wmo/ .blp/.dbc baseline. main.cpp shrinks by 244 lines (7,939 to 7,695). Both --json output modes preserved for machine-readable reports.
2026-05-09 07:16:27 -07:00
if (wowee::editor::cli::handleInfoBytes(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --info-{zone,project}-extents into cli_info_extents.cpp Moves the two spatial-bounds info handlers (--info-zone-extents, --info-project-extents) out of main.cpp into a new cli_info_extents.{hpp,cpp} module. Both compute world-space XYZ bounding boxes from manifest tile coords + per-chunk height samples; the project variant unions every zone's box into one. main.cpp shrinks by 232 lines (7,695 to 7,463). Both --json output modes preserved for camera-framing pipelines.
2026-05-09 07:22:06 -07:00
if (wowee::editor::cli::handleInfoExtents(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --info-{zone,project}-water into cli_info_water.cpp Moves the two water-layer audit handlers (--info-zone-water, --info-project-water) out of main.cpp into a new cli_info_water.{hpp,cpp} module. Both aggregate liquid data (water/ocean/magma/slime) across MH2O chunks; the project variant rolls per-zone counts into a project-wide total with height range and per-type histogram. main.cpp shrinks by 209 lines (7,463 to 7,254). Both --json output modes preserved for capacity-planning pipelines.
2026-05-09 07:28:15 -07:00
if (wowee::editor::cli::handleInfoWater(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --info-{zone,project}-density into cli_info_density.cpp Moves the two content-density audit handlers (--info-zone-density, --info-project-density) out of main.cpp into a new cli_info_density.{hpp,cpp} module. Both count creatures/objects/quests per tile to surface sparse zones (boring) and over-stuffed ones (frame-rate bombs); the project variant rolls per-zone numbers into a project-wide table with per-zone averages for content-pacing reviews. main.cpp shrinks by 201 lines (7,254 to 7,053). Both --json output modes preserved for balance-audit pipelines.
2026-05-09 07:33:40 -07:00
if (wowee::editor::cli::handleInfoDensity(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --info-{zone,project}-audio into cli_info_audio.cpp Moves the two audio-config audit handlers (--info-zone-audio, --info-project-audio) out of main.cpp into a new cli_info_audio.{hpp,cpp} module. Both surface the music / day-ambience / night-ambience / volume settings stored in zone.json so designers can spot zones still missing audio assignment before a release pass. main.cpp shrinks by 127 lines (7,053 to 6,926). Drops the dead `label` lambda inside info-project-audio that the unused-but-set-variable warning had been flagging. Both --json output modes preserved.
2026-05-09 07:38:36 -07:00
if (wowee::editor::cli::handleInfoAudio(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract WOB/WOT/WOC inspectors into cli_world_info.cpp Moves the three open-format world-asset inspectors (--info-wob, --info-wot, --info-woc) out of main.cpp into a new cli_world_info.{hpp,cpp} module. Each prints a quick structural summary (groups / portals / chunk counts / triangles / bounds) without paying the full deserialization cost a viewer would. main.cpp shrinks by 144 lines (6,926 to 6,786). The --copy-project handler that interleaved between --info-wob and --info-wot stays inline -- it isn't an inspector and belongs with project-mutation operations. All --json output modes preserved.
2026-05-09 07:44:57 -07:00
if (wowee::editor::cli::handleWorldInfo(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract quest+objective handlers into cli_quest_objective.cpp Moves three contiguous quest mutation handlers (--add-quest, --add-quest-objective, --remove-quest-objective) out of main.cpp into a new cli_quest_objective.{hpp,cpp} module. All three operate on a zone's quests.json with the same QuestEditor load-edit-save flow; the objective add/remove pair includes auto-generated description text from type+name+count for tooltip-friendly defaults. main.cpp shrinks by 174 lines (6,603 to 6,429). Reward and clone-quest handlers stay inline for follow-up extractions.
2026-05-09 07:56:16 -07:00
if (wowee::editor::cli::handleQuestObjective(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract quest-reward handlers into cli_quest_reward.cpp Moves the two quest-reward mutation handlers (--add-quest-reward-item, --set-quest-reward) out of main.cpp into a new cli_quest_reward.{hpp,cpp} module. Both operate on a quest's reward struct in zone.json: the first greedy-consumes multiple item paths in one invocation, the second uses order-independent flag/value pairs (--xp / --gold / --silver / --copper) with strict 'only changed fields are written' semantics so partial updates don't clobber unrelated fields. main.cpp shrinks by 114 lines (6,429 to 6,315).
2026-05-09 08:01:28 -07:00
if (wowee::editor::cli::handleQuestReward(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract clone-* duplicate handlers into cli_clone.cpp Moves the three clone-* handlers (--clone-quest, --clone-creature, --clone-object) out of main.cpp into a new cli_clone.{hpp,cpp} module. All three deep-copy by index, optionally rename, and (for creature/object) offset the new copy by 5 yards along X to prevent z-fighting with the original. Each resets the per-entity unique id so downstream systems that dedupe by id stay consistent. main.cpp shrinks by 184 lines (6,315 to 6,131).
2026-05-09 08:06:20 -07:00
if (wowee::editor::cli::handleClone(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract remove-* by-index handlers into cli_remove.cpp Moves the four bounds-checked remove-by-index handlers (--remove-creature, --remove-object, --remove-quest, --remove-item) out of main.cpp into a new cli_remove.{hpp,cpp} module. All four share the same load-erase-save pattern with index validation and a "what was removed" report for audit trails. The first three use their respective editor classes (NpcSpawner, ObjectPlacer, QuestEditor); --remove-item walks raw nlohmann::json since items.json doesn't have a dedicated editor class yet. main.cpp shrinks by 145 lines (6,131 to 5,986).
2026-05-09 08:11:50 -07:00
if (wowee::editor::cli::handleRemove(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract add-* append handlers into cli_add.cpp Moves the three add-* coordinate-based append handlers (--add-object, --add-creature, --add-item) out of main.cpp into a new cli_add.{hpp,cpp} module. All three append a single entry to a zone's JSON file with optional positional args after the required ones. --add-item handles raw nlohmann::json (no dedicated editor class) and auto-assigns the smallest unused id when the user passes 0 / nothing. main.cpp shrinks by 198 lines (5,986 to 5,788).
2026-05-09 08:16:52 -07:00
if (wowee::editor::cli::handleAdd(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract random-* / gen-random-* into cli_random.cpp Moves the four random-population handlers (--random-populate-zone, --random-populate-items, --gen-random-zone, --gen-random-project) out of main.cpp into a new cli_random.{hpp,cpp} module. All four use the same seeded LCG so re-runs reproduce the same content; the gen-random-* pair shells out to scaffold-zone + random-populate-zone + random-populate-items so the simpler single-purpose handlers stay the source of truth. main.cpp shrinks by 439 lines (5,788 to 5,349). The inline word lexicons (creature names, object paths, item prefixes/nouns) move with random-populate-zone and -items into the new module.
2026-05-09 08:22:06 -07:00
if (wowee::editor::cli::handleRandom(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract item-export handlers into cli_items_export.cpp Moves the three item-export handlers (--export-zone-items-md, --export-project-items-md, --export-project-items-csv) out of main.cpp into a new cli_items_export.{hpp,cpp} module. All three render items.json data as human-readable Markdown / CSV reports for design docs, PR descriptions, GitHub Pages, and spreadsheet pivot-table workflows. main.cpp shrinks by 262 lines (5,349 to 5,087).
2026-05-09 08:26:52 -07:00
if (wowee::editor::cli::handleItemsExport(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract items.json mutation handlers into cli_items_mutate.cpp Moves the three items.json mutation handlers (--set-item, --copy-zone-items, --clone-item) out of main.cpp into a new cli_items_mutate.{hpp,cpp} module. All three operate on the same {"items": [...]} schema; --set-item supports both id-lookup ("123") and index-lookup ("#0") with strict "only changed fields are written" semantics, --copy-zone-items has replace and --merge modes, --clone-item auto-assigns the smallest unused id. main.cpp shrinks by 316 lines (5,087 to 4,771) and finally drops below 5K. items.json now has its full mutation surface in one focused module instead of scattered through the megafile.
2026-05-09 08:33:59 -07:00
if (wowee::editor::cli::handleItemsMutate(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract zone-creation handlers into cli_zone_create.cpp Moves the two zone-creation handlers (--scaffold-zone, --mvp-zone) out of main.cpp into a new cli_zone_create.{hpp,cpp} module. Both kickstart a new authoring session by generating a new zone directory under custom_zones/ — empty for scaffold, populated with one of each content type (creature + object + quest with objective + reward) for mvp. Each goes terrain + manifest, then mvp adds the demo content positioned at the tile center. main.cpp shrinks by 155 lines (4,771 to 4,616).
2026-05-09 08:42:49 -07:00
if (wowee::editor::cli::handleZoneCreate(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --add-tile / --remove-tile / --list-tiles into cli_tiles.cpp Moves the three per-tile zone-manifest handlers (--add-tile, --remove-tile, --list-tiles) out of main.cpp into a new cli_tiles.{hpp,cpp} module. Zones can span multiple ADT tiles; these manage that list — add creates a fresh blank WHM/WOT pair at the new tile, remove drops the entry + deletes WHM/WOT/WOC files, list prints the manifest with file-presence flags. main.cpp shrinks by 185 lines (4,616 to 4,431).
2026-05-09 08:47:32 -07:00
if (wowee::editor::cli::handleTiles(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract zone lifecycle handlers into cli_zone_mgmt.cpp Moves the four zone-level lifecycle handlers (--copy-zone, --rename-zone, --remove-zone, --clear-zone-content) out of main.cpp into a new cli_zone_mgmt.{hpp,cpp} module. All slug- aware: copy + rename keep file names and manifest mapName in sync so the result is self-consistent; clear-content empties the per-feature JSONs without touching terrain. main.cpp shrinks by 321 lines (4,431 to 4,110).
2026-05-09 08:52:19 -07:00
if (wowee::editor::cli::handleZoneMgmt(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --strip-zone / --strip-project into cli_strip.cpp Moves the two cleanup-pass handlers (--strip-zone, --strip-project) out of main.cpp into a new cli_strip.{hpp,cpp} module. Both remove derived outputs (.glb / .obj / .stl / .html / .dot / .csv / .png / ZONE.md / DEPS.md) leaving only source files. Useful before --pack-wcp so archives don't carry redundant exports, and before committing to git so derived blobs don't bloat history. Both honor --dry-run for safe previews. main.cpp shrinks by 164 lines (4,110 to 3,946).
2026-05-09 08:56:47 -07:00
if (wowee::editor::cli::handleStrip(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --repair-zone / --repair-project into cli_repair.cpp Moves the two manifest-drift fix handlers (--repair-zone, --repair-project) out of main.cpp into a new cli_repair.{hpp,cpp} module. Both auto-fix the common manifest-vs-disk inconsistencies that accumulate when zones are hand-edited or partially copied — adding orphan WHM tiles to the manifest, syncing the hasCreatures flag with the actual creatures.json content, and warning (not removing) for tiles in the manifest without backing files. Both honor --dry-run for safe previews. main.cpp shrinks by 155 lines (3,946 to 3,791).
2026-05-09 08:59:51 -07:00
if (wowee::editor::cli::handleRepair(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --gen-makefile / --gen-project-makefile into cli_makefile.cpp Moves the two Makefile-generation handlers (--gen-makefile, --gen-project-makefile) out of main.cpp into a new cli_makefile.{hpp,cpp} module. Both emit GNU make recipes that rebuild every derived output (.glb / .obj / .stl / .html / .csv / .md) from sources via wowee_editor flags, with proper dependency tracking so make can skip already-up-to-date outputs. Designers can `make -j$(nproc)` to rebuild all zones in parallel after a content edit. main.cpp shrinks by 167 lines (3,791 to 3,624).
2026-05-09 09:04:44 -07:00
if (wowee::editor::cli::handleMakefile(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract --list-zones / --zone-stats into cli_zone_list.cpp Moves the two zone discovery / aggregation handlers (--list-zones, --zone-stats) out of main.cpp into a new cli_zone_list.{hpp,cpp} module. The first quickly enumerates zones across the standard locations (custom_zones, output); the second walks a project dir computing tile / creature / quest / per-format byte totals with a per-zone breakdown table — useful for content-pack release notes and capacity planning. main.cpp shrinks by 191 lines (3,624 to 3,433). Both --json output modes preserved.
2026-05-09 09:09:06 -07:00
if (wowee::editor::cli::handleZoneList(i, argc, argv, outRc)) {
return outRc;
}
refactor(editor): extract gen-audio-* handlers into cli_gen_audio.cpp main.cpp had grown past 28k lines, with each new procedural- generation command adding 100-200 lines to the inline if/else dispatch chain. This commit starts breaking that up by moving the four audio-related handlers (--gen-audio-tone, -noise, -sweep, --gen-zone-audio-pack) into their own translation unit. Pattern established here for future family extractions: - Family lives in cli_<family>.{hpp,cpp} - Single dispatch entry point: bool handle<Family>(int& i, int argc, char** argv, int& outRc) — true if matched (writes outRc), false to fall through. - main.cpp's argv loop calls each family's dispatcher first and returns its outRc on match, before the legacy in-line chain. Side-benefit: consolidated the duplicated 25-line WAV header writer + 5ms attack/release envelope into shared helpers (writeWavMono16, applyEdgeEnvelope) at the top of the new file. main.cpp drops from 28,943 → 28,329 lines (-614). Audio family is fully self-contained (~440 lines), behavior unchanged (verified by re-running tone/noise/sweep + zone-audio-pack).
2026-05-08 16:19:30 -07:00
}
feat(editor): add standalone world editor (rough/WIP) Standalone wowee_editor tool for creating custom WoW zones. This is a rough initial implementation — many features work but M2/WMO rendering still has issues (frame sync, texture layout transitions) and needs further polish. Terrain: - Create new blank terrain with 10 biome types (Grassland, Forest, Jungle, Desert, Barrens, Snow, Swamp, Rocky, Beach, Volcanic) - Load existing ADT tiles from extracted game data - Sculpt brushes: Raise, Lower, Smooth, Flatten, Level - Chunk edge stitching prevents seams between tiles - Undo/redo (100-deep stack, Ctrl+Z/Ctrl+Shift+Z) - Save to WoW ADT/WDT format Texture Painting: - Paint/Erase/Replace Base modes - Full tileset texture browser (1285 textures from manifest) - Per-zone directory filtering and search - Alpha map editing with 4-layer limit (auto-replaces weakest) Object Placement: - M2 and WMO model placement with full manifest browser (11k M2s, 2k WMOs) - M2Renderer + WMORenderer integrated (loads .skin files for WotLK) - Ghost preview follows cursor before placing - Ctrl+click selection, right-click context menu - Transform gizmo (Move/Rotate/Scale with axis constraints) - Position/rotation/scale editing in properties panel NPC/Monster System: - 631 creature presets scanned from manifest, categorized (Critters, Beasts, Humanoids, Undead, Demons, etc.) - Stats editor: level, health, mana, damage, armor, faction - Behavior: Stationary, Patrol, Wander, Scripted - Aggro/leash radius, respawn time, flags (hostile/vendor/etc.) - Save creature spawns to JSON Water: - Place water at configurable height per chunk - Liquid types: Water, Ocean, Magma, Slime - Rendered as translucent colored quads - Saved in ADT MH2O format Infrastructure: - Free-fly camera (WASD/QE, right-drag look, scroll speed) - 5-mode toolbar: Sculpt | Paint | Objects | Water | NPCs - Asset browser indexes full manifest on startup - Editor water/marker shaders (pos+color vertex format) - forceNoCull added to M2Renderer for editor use - AssetManifest::getEntries() and AssetManager::getManifest() exposed Known issues: - M2/WMO rendering may not display on first placement (frame index sync between update/render was misaligned — now fixed but untested end-to-end) - Validation layer errors on shutdown (resource cleanup ordering) - Object placement on steep terrain can miss raycast - No undo for texture painting or object placement yet
2026-05-05 03:47:03 -07:00
if (std::strcmp(argv[i], "--data") == 0 && i + 1 < argc) {
dataPath = argv[++i];
} else if (std::strcmp(argv[i], "--adt") == 0 && i + 3 < argc) {
adtMap = argv[++i];
adtX = std::atoi(argv[++i]);
adtY = std::atoi(argv[++i]);
feat(editor): add --info-zone-models-total for aggregate WOM/WOB stats Aggregates WOM/WOB stats across every model in a zone. Useful for capacity planning and perf budgeting: wowee_editor --info-zone-models-total custom_zones/MyZone Zone models total: custom_zones/MyZone WOM (open M2): files : 47 vertices : 184320 triangles : 122880 bones : 612 anims : 94 batches : 188 WOB (open WMO): files : 8 groups : 32 vertices : 28480 triangles : 18960 doodads : 156 portals : 24 Combined : vertices : 212800 triangles : 141840 Per-format aggregation (WOM = open M2, WOB = open WMO) plus a combined totals row. Catches: - 'how many bones across all my creatures?' (rigging budget) - 'total triangles per frame if all loaded?' (perf ceiling) - 'do my models actually have multi-batch material support?' (counts batch entries; 0 means everything is WOM1/WOM2) Walks the zone dir recursively so models in subdirs (creatures/, buildings/, props/) all roll up. JSON mode emits per-format records for capacity dashboards.
2026-05-06 19:53:31 -07:00
} else if (std::strcmp(argv[i], "--info-zone-models-total") == 0 && i + 1 < argc) {
// Aggregate WOM/WOB stats across every model in a zone.
// Useful for capacity planning ('how many bones across all
// my creatures?') and perf budgeting ('total triangles
// per frame if all loaded?').
std::string zoneDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(zoneDir)) {
std::fprintf(stderr,
"info-zone-models-total: %s does not exist\n", zoneDir.c_str());
return 1;
}
int womCount = 0, wobCount = 0;
uint64_t womVerts = 0, womIndices = 0;
uint64_t womBones = 0, womAnims = 0, womBatches = 0;
uint64_t wobGroups = 0, wobVerts = 0, wobIndices = 0;
uint64_t wobDoodads = 0, wobPortals = 0;
std::error_code ec;
for (const auto& e : fs::recursive_directory_iterator(zoneDir, ec)) {
if (!e.is_regular_file()) continue;
std::string ext = e.path().extension().string();
std::string base = e.path().string();
if (base.size() > ext.size())
base = base.substr(0, base.size() - ext.size());
if (ext == ".wom") {
womCount++;
auto wom = wowee::pipeline::WoweeModelLoader::load(base);
womVerts += wom.vertices.size();
womIndices += wom.indices.size();
womBones += wom.bones.size();
womAnims += wom.animations.size();
womBatches += wom.batches.size();
} else if (ext == ".wob") {
wobCount++;
auto wob = wowee::pipeline::WoweeBuildingLoader::load(base);
wobGroups += wob.groups.size();
for (const auto& g : wob.groups) {
wobVerts += g.vertices.size();
wobIndices += g.indices.size();
}
wobDoodads += wob.doodads.size();
wobPortals += wob.portals.size();
}
}
if (jsonOut) {
nlohmann::json j;
j["zone"] = zoneDir;
j["wom"] = {{"count", womCount},
{"vertices", womVerts},
{"indices", womIndices},
{"triangles", womIndices / 3},
{"bones", womBones},
{"animations", womAnims},
{"batches", womBatches}};
j["wob"] = {{"count", wobCount},
{"groups", wobGroups},
{"vertices", wobVerts},
{"indices", wobIndices},
{"triangles", wobIndices / 3},
{"doodads", wobDoodads},
{"portals", wobPortals}};
std::printf("%s\n", j.dump(2).c_str());
return 0;
}
std::printf("Zone models total: %s\n", zoneDir.c_str());
std::printf("\n WOM (open M2):\n");
std::printf(" files : %d\n", womCount);
std::printf(" vertices : %llu\n", static_cast<unsigned long long>(womVerts));
std::printf(" triangles : %llu\n", static_cast<unsigned long long>(womIndices / 3));
std::printf(" bones : %llu\n", static_cast<unsigned long long>(womBones));
std::printf(" anims : %llu\n", static_cast<unsigned long long>(womAnims));
std::printf(" batches : %llu\n", static_cast<unsigned long long>(womBatches));
std::printf("\n WOB (open WMO):\n");
std::printf(" files : %d\n", wobCount);
std::printf(" groups : %llu\n", static_cast<unsigned long long>(wobGroups));
std::printf(" vertices : %llu\n", static_cast<unsigned long long>(wobVerts));
std::printf(" triangles : %llu\n", static_cast<unsigned long long>(wobIndices / 3));
std::printf(" doodads : %llu\n", static_cast<unsigned long long>(wobDoodads));
std::printf(" portals : %llu\n", static_cast<unsigned long long>(wobPortals));
std::printf("\n Combined :\n");
std::printf(" vertices : %llu\n", static_cast<unsigned long long>(womVerts + wobVerts));
std::printf(" triangles : %llu\n", static_cast<unsigned long long>((womIndices + wobIndices) / 3));
return 0;
fix(editor): un-shadow zone mesh detail view as -detail variant Mirrors the --list-project-meshes-detail rename from 976549fe. After the c0f2ab75 inventory extraction, the older per-mesh sorted-by-tris listing was shadowed by the per-zone aggregate that now lives in cli_zone_inventory.cpp. Renames the older handler to --list-zone-meshes-detail (and updates its help text + kArgRequired entry) so both views coexist: --list-zone-meshes — per-zone aggregate (extracted) --list-zone-meshes-detail — sorted-by-tris listing Removes the last duplicate-flag dead code from main.cpp.
2026-05-08 19:28:18 -07:00
} else if (std::strcmp(argv[i], "--list-zone-meshes-detail") == 0 && i + 1 < argc) {
// Per-mesh breakdown of every .wom file in <zoneDir>,
// sorted by triangle count descending so the heaviest
// meshes float to the top. Complements
// --list-zone-meshes (per-zone summary) by surfacing
// individual mesh metrics — useful for spotting
// outliers ("which mesh is using 80% of my triangle
// budget?") and for content audits.
feat(editor): add --list-zone-meshes per-mesh breakdown Per-mesh listing of every .wom in a zone. Complements --info-zone-models-total (aggregate) by surfacing individual mesh metrics: version, vertex count, triangle count, bone count, batch count, texture-slot count, and on-disk bytes. Sorted by triangle count descending so the heaviest meshes float to the top of the table — useful for spotting outliers ("which mesh is using 80% of my triangle budget?") and for content audits. Both human (table) and --json output modes. Verified on synthetic 3-mesh zone (sphere 384 tris, cube 12, plane 2): table sorted descending, totals row matches sum of individual rows, sub-dir mesh shown with its relative path. Brings command count to 205.
2026-05-07 03:15:05 -07:00
std::string zoneDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(zoneDir)) {
std::fprintf(stderr,
fix(editor): un-shadow zone mesh detail view as -detail variant Mirrors the --list-project-meshes-detail rename from 976549fe. After the c0f2ab75 inventory extraction, the older per-mesh sorted-by-tris listing was shadowed by the per-zone aggregate that now lives in cli_zone_inventory.cpp. Renames the older handler to --list-zone-meshes-detail (and updates its help text + kArgRequired entry) so both views coexist: --list-zone-meshes — per-zone aggregate (extracted) --list-zone-meshes-detail — sorted-by-tris listing Removes the last duplicate-flag dead code from main.cpp.
2026-05-08 19:28:18 -07:00
"list-zone-meshes-detail: %s does not exist\n", zoneDir.c_str());
feat(editor): add --list-zone-meshes per-mesh breakdown Per-mesh listing of every .wom in a zone. Complements --info-zone-models-total (aggregate) by surfacing individual mesh metrics: version, vertex count, triangle count, bone count, batch count, texture-slot count, and on-disk bytes. Sorted by triangle count descending so the heaviest meshes float to the top of the table — useful for spotting outliers ("which mesh is using 80% of my triangle budget?") and for content audits. Both human (table) and --json output modes. Verified on synthetic 3-mesh zone (sphere 384 tris, cube 12, plane 2): table sorted descending, totals row matches sum of individual rows, sub-dir mesh shown with its relative path. Brings command count to 205.
2026-05-07 03:15:05 -07:00
return 1;
}
struct Row {
std::string path;
size_t verts;
size_t tris;
size_t bones;
size_t batches;
size_t textures;
uint64_t bytes;
uint32_t version;
};
std::vector<Row> rows;
std::error_code ec;
for (const auto& e : fs::recursive_directory_iterator(zoneDir, ec)) {
if (!e.is_regular_file()) continue;
if (e.path().extension() != ".wom") continue;
std::string base = e.path().string();
if (base.size() >= 4) base = base.substr(0, base.size() - 4);
auto wom = wowee::pipeline::WoweeModelLoader::load(base);
Row r;
r.path = fs::relative(e.path(), zoneDir, ec).string();
if (ec) r.path = e.path().filename().string();
r.verts = wom.vertices.size();
r.tris = wom.indices.size() / 3;
r.bones = wom.bones.size();
r.batches = wom.batches.size();
r.textures = wom.texturePaths.size();
r.bytes = e.file_size(ec);
if (ec) r.bytes = 0;
r.version = wom.version;
rows.push_back(r);
}
std::sort(rows.begin(), rows.end(),
[](const Row& a, const Row& b) { return a.tris > b.tris; });
uint64_t totVerts = 0, totTris = 0, totBones = 0, totBytes = 0;
for (const auto& r : rows) {
totVerts += r.verts; totTris += r.tris;
totBones += r.bones; totBytes += r.bytes;
}
if (jsonOut) {
nlohmann::json j;
j["zone"] = zoneDir;
j["meshCount"] = rows.size();
j["totals"] = {{"vertices", totVerts},
{"triangles", totTris},
{"bones", totBones},
{"bytes", totBytes}};
nlohmann::json arr = nlohmann::json::array();
for (const auto& r : rows) {
arr.push_back({{"path", r.path},
{"version", r.version},
{"vertices", r.verts},
{"triangles", r.tris},
{"bones", r.bones},
{"batches", r.batches},
{"textures", r.textures},
{"bytes", r.bytes}});
}
j["meshes"] = arr;
std::printf("%s\n", j.dump(2).c_str());
return 0;
}
std::printf("Zone meshes: %s\n", zoneDir.c_str());
std::printf(" meshes : %zu\n", rows.size());
std::printf(" totals : %llu verts, %llu tris, %llu bones, %.1f KB\n",
static_cast<unsigned long long>(totVerts),
static_cast<unsigned long long>(totTris),
static_cast<unsigned long long>(totBones),
totBytes / 1024.0);
if (rows.empty()) {
std::printf("\n *no .wom files in this zone*\n");
return 0;
}
std::printf("\n v verts tris bones batch tex bytes path\n");
for (const auto& r : rows) {
std::printf(" v%u %6zu %6zu %5zu %5zu %3zu %7llu %s\n",
r.version, r.verts, r.tris, r.bones,
r.batches, r.textures,
static_cast<unsigned long long>(r.bytes),
r.path.c_str());
}
return 0;
feat(editor): add --info-mesh single-mesh detail aggregator One-shot composite of what --info-batches and per-mesh stats spread across multiple commands. Reports name, version, counts (vertices/ triangles/bones/anims/batches/textures), bounds (min/max/radius), per-batch detail (indexStart/indexCount/triangles/blend mode/texture name), and the full texture-slot table. Both human and --json output modes. Useful authoring command: pass a WOM and see everything about it without running three sub- commands. Verified on a --gen-mesh-textured cube (size 1.5): correctly reports v3 / 24 verts / 12 tris / 1 batch / 1 texture, bounds ±0.75, batch 0 wired to cube.png with opaque blend. Brings command count to 214.
2026-05-07 05:44:37 -07:00
} else if (std::strcmp(argv[i], "--info-mesh") == 0 && i + 1 < argc) {
// Single-mesh detail view aggregating bounds, version,
// batches, bones, animations, and texture slots into one
// report. Composite of what --info-batches / --info-bones
// / --info-batches show separately. Useful authoring
// command: pass a WOM and see everything about it without
// running three sub-commands.
std::string base = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
if (base.size() >= 4 && base.substr(base.size() - 4) == ".wom") {
base = base.substr(0, base.size() - 4);
}
if (!wowee::pipeline::WoweeModelLoader::exists(base)) {
std::fprintf(stderr,
"info-mesh: %s.wom does not exist\n", base.c_str());
return 1;
}
auto wom = wowee::pipeline::WoweeModelLoader::load(base);
if (!wom.isValid()) {
std::fprintf(stderr,
"info-mesh: failed to load %s.wom\n", base.c_str());
return 1;
}
// Per-batch material summary.
static const char* blendNames[] = {
"opaque", "alpha-test", "alpha", "additive", "?", "?", "?", "?"
};
if (jsonOut) {
nlohmann::json j;
j["base"] = base;
j["name"] = wom.name;
j["version"] = wom.version;
j["bounds"] = {{"min", {wom.boundMin.x, wom.boundMin.y, wom.boundMin.z}},
{"max", {wom.boundMax.x, wom.boundMax.y, wom.boundMax.z}},
{"radius", wom.boundRadius}};
j["counts"] = {{"vertices", wom.vertices.size()},
{"indices", wom.indices.size()},
{"triangles", wom.indices.size() / 3},
{"bones", wom.bones.size()},
{"animations", wom.animations.size()},
{"batches", wom.batches.size()},
{"textures", wom.texturePaths.size()}};
nlohmann::json bs = nlohmann::json::array();
for (const auto& b : wom.batches) {
std::string tex;
if (b.textureIndex < wom.texturePaths.size())
tex = wom.texturePaths[b.textureIndex];
bs.push_back({{"indexStart", b.indexStart},
{"indexCount", b.indexCount},
{"triangles", b.indexCount / 3},
{"textureIndex", b.textureIndex},
{"texture", tex},
{"blendMode", b.blendMode},
{"flags", b.flags}});
}
j["batchDetail"] = bs;
j["texturePaths"] = wom.texturePaths;
std::printf("%s\n", j.dump(2).c_str());
return 0;
}
std::printf("Mesh: %s.wom\n", base.c_str());
std::printf(" name : %s\n", wom.name.c_str());
std::printf(" version : v%u\n", wom.version);
std::printf("\n Counts:\n");
std::printf(" vertices : %zu\n", wom.vertices.size());
std::printf(" triangles : %zu\n", wom.indices.size() / 3);
std::printf(" bones : %zu\n", wom.bones.size());
std::printf(" anims : %zu\n", wom.animations.size());
std::printf(" batches : %zu\n", wom.batches.size());
std::printf(" textures : %zu\n", wom.texturePaths.size());
std::printf("\n Bounds:\n");
std::printf(" min : (%.3f, %.3f, %.3f)\n",
wom.boundMin.x, wom.boundMin.y, wom.boundMin.z);
std::printf(" max : (%.3f, %.3f, %.3f)\n",
wom.boundMax.x, wom.boundMax.y, wom.boundMax.z);
std::printf(" radius : %.3f\n", wom.boundRadius);
if (!wom.batches.empty()) {
std::printf("\n Batches:\n");
std::printf(" idx iStart iCount tris blend texture\n");
for (size_t k = 0; k < wom.batches.size(); ++k) {
const auto& b = wom.batches[k];
std::string tex = "<oob>";
if (b.textureIndex < wom.texturePaths.size())
tex = wom.texturePaths[b.textureIndex];
if (tex.empty()) tex = "(empty)";
int blend = b.blendMode < 8 ? b.blendMode : 0;
std::printf(" %3zu %6u %6u %4u %-10s %s\n",
k, b.indexStart, b.indexCount,
b.indexCount / 3, blendNames[blend],
tex.c_str());
}
}
if (!wom.texturePaths.empty()) {
std::printf("\n Texture slots:\n");
for (size_t k = 0; k < wom.texturePaths.size(); ++k) {
std::printf(" [%zu] %s\n", k,
wom.texturePaths[k].empty()
? "(empty placeholder)"
: wom.texturePaths[k].c_str());
}
}
return 0;
feat(editor): add --info-mesh-storage-budget byte-category breakdown Estimated bytes-per-category breakdown for a single WOM. Numbers are based on the in-memory struct sizes (vertex 40B, index 4B, bone 22B, batch 16B, anim keyframe 44B, plus texture path strings) — not the actual on-disk encoding (which has framing overhead) — but the relative shares are accurate and help users decide where shrinking efforts pay off. Surfaces actionable tips when a category dominates: animations > vertices → suggest --strip-mesh --anims with the saved KB; bones non-trivial → suggest --bones for static placement; vertices dominate → suggest a lower-poly variant. Verified on procedural cube: 960B vertices (85%) + 144B indices (13%) + 16B batches + 8B textures, total 1128 estimated vs 1184 on-disk (~5% framing overhead). Tip correctly fires for vertex-dominated mesh. Brings command count to 231.
2026-05-07 09:00:47 -07:00
} else if (std::strcmp(argv[i], "--info-mesh-storage-budget") == 0 && i + 1 < argc) {
// Estimated bytes-per-category breakdown for a WOM.
// Numbers are based on the in-memory struct sizes, not
// the actual on-disk encoding (which has framing
// overhead) — but the relative shares are accurate and
// help users decide where shrinking efforts pay off.
//
// For example: a heightmap mesh's bytes are dominated by
// vertices, so reducing vertex count is the lever to
// pull. A skeletal mesh's animation keyframes can dwarf
// the geometry itself — surfacing that lets the user
// know to consider --strip-mesh --anims.
std::string base = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
if (base.size() >= 4 && base.substr(base.size() - 4) == ".wom") {
base = base.substr(0, base.size() - 4);
}
if (!wowee::pipeline::WoweeModelLoader::exists(base)) {
std::fprintf(stderr,
"info-mesh-storage-budget: %s.wom does not exist\n",
base.c_str());
return 1;
}
auto wom = wowee::pipeline::WoweeModelLoader::load(base);
if (!wom.isValid()) {
std::fprintf(stderr,
"info-mesh-storage-budget: failed to load %s.wom\n",
base.c_str());
return 1;
}
// Per-category byte estimates. Vertex is 12+12+8+4+4=40
// bytes (pos/normal/uv/4 weights/4 indices). Index is
// 4 bytes. Bone is 4+2+12+4=22 bytes. Batch is 4+4+4+2+
// 2=16. Animation keyframe is 4+12+16+12=44 bytes.
// Texture path is summed length plus a small per-string
// overhead.
uint64_t vertBytes = wom.vertices.size() * 40;
uint64_t idxBytes = wom.indices.size() * 4;
uint64_t boneBytes = wom.bones.size() * 22;
uint64_t batchBytes = wom.batches.size() * 16;
uint64_t animBytes = 0;
size_t totalKeyframes = 0;
for (const auto& a : wom.animations) {
animBytes += 12; // id + duration + movingSpeed
for (const auto& bone : a.boneKeyframes) {
animBytes += bone.size() * 44;
totalKeyframes += bone.size();
}
}
uint64_t texBytes = 0;
for (const auto& t : wom.texturePaths) texBytes += t.size() + 8;
namespace fs = std::filesystem;
uint64_t actualBytes = fs::file_size(base + ".wom");
uint64_t estBytes = vertBytes + idxBytes + boneBytes +
batchBytes + animBytes + texBytes;
struct Row { const char* name; uint64_t bytes; };
std::vector<Row> rows = {
{"vertices ", vertBytes},
{"indices ", idxBytes},
{"bones ", boneBytes},
{"animations", animBytes},
{"batches ", batchBytes},
{"textures ", texBytes},
};
if (jsonOut) {
nlohmann::json j;
j["base"] = base;
j["fileBytes"] = actualBytes;
j["estimatedBytes"] = estBytes;
j["categories"] = nlohmann::json::object();
for (const auto& r : rows) {
double share = estBytes > 0
? 100.0 * r.bytes / estBytes : 0.0;
j["categories"][r.name] = {{"bytes", r.bytes},
{"share", share}};
}
j["counts"] = {{"vertices", wom.vertices.size()},
{"indices", wom.indices.size()},
{"bones", wom.bones.size()},
{"animations", wom.animations.size()},
{"keyframes", totalKeyframes},
{"batches", wom.batches.size()},
{"textures", wom.texturePaths.size()}};
std::printf("%s\n", j.dump(2).c_str());
return 0;
}
std::printf("Mesh storage budget: %s.wom\n", base.c_str());
std::printf(" on-disk : %llu bytes (%.1f KB)\n",
static_cast<unsigned long long>(actualBytes),
actualBytes / 1024.0);
std::printf(" estimated : %llu bytes (sum of in-memory parts)\n",
static_cast<unsigned long long>(estBytes));
std::printf("\n Per-category (estimated):\n");
for (const auto& r : rows) {
if (r.bytes == 0) continue;
double share = estBytes > 0
? 100.0 * r.bytes / estBytes : 0.0;
std::printf(" %s : %10llu bytes (%5.1f%%)\n",
r.name,
static_cast<unsigned long long>(r.bytes),
share);
}
std::printf("\n Tips:\n");
if (animBytes > vertBytes && wom.animations.size() > 0) {
std::printf(" - animations dominate; --strip-mesh "
"--anims would save %.1f KB\n",
animBytes / 1024.0);
}
if (boneBytes > vertBytes / 2 && wom.bones.size() > 0) {
std::printf(" - bones non-trivial; consider "
"--strip-mesh --bones for static placement\n");
}
if (vertBytes > estBytes / 2) {
std::printf(" - vertices dominate; check if a "
"lower-poly variant works for placement\n");
}
return 0;
feat(editor): add --info-project-models-total for cross-zone WOM/WOB rollup Project-wide companion to --info-zone-models-total. Walks every zone in <projectDir>, sums verts/tris/bones/anims/batches per WOM and groups/ verts/tris/doodads/portals per WOB, then prints a per-zone breakdown table plus a TOTAL row. Both human (table) and --json output modes. Useful for capacity planning across an entire content project — e.g. "how many bones across all my creatures" or "total triangles per frame if every model loaded simultaneously." Verified on the 2-zone migration test project: per-zone counts match --info-zone-models-total output, totals row aggregates correctly, JSON form parses cleanly. Brings command count to 170.
2026-05-06 20:25:00 -07:00
} else if (std::strcmp(argv[i], "--info-project-models-total") == 0 && i + 1 < argc) {
// Multi-zone aggregate. Walks every zone in <projectDir>,
// sums the same WOM/WOB metrics --info-zone-models-total
// emits, and prints a per-zone breakdown table followed
// by project-wide totals. Useful for capacity planning
// across an entire content project.
std::string projectDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(projectDir) || !fs::is_directory(projectDir)) {
std::fprintf(stderr,
"info-project-models-total: %s is not a directory\n",
projectDir.c_str());
return 1;
}
std::vector<std::string> zones;
for (const auto& entry : fs::directory_iterator(projectDir)) {
if (!entry.is_directory()) continue;
if (!fs::exists(entry.path() / "zone.json")) continue;
zones.push_back(entry.path().string());
}
std::sort(zones.begin(), zones.end());
struct ZRow {
std::string name;
int womCount = 0, wobCount = 0;
uint64_t womVerts = 0, womIndices = 0, womBones = 0;
uint64_t womAnims = 0, womBatches = 0;
uint64_t wobGroups = 0, wobVerts = 0, wobIndices = 0;
uint64_t wobDoodads = 0, wobPortals = 0;
};
std::vector<ZRow> rows;
ZRow tot;
tot.name = "TOTAL";
for (const auto& zoneDir : zones) {
ZRow r;
r.name = fs::path(zoneDir).filename().string();
std::error_code ec;
for (const auto& e : fs::recursive_directory_iterator(zoneDir, ec)) {
if (!e.is_regular_file()) continue;
std::string ext = e.path().extension().string();
std::string base = e.path().string();
if (base.size() > ext.size())
base = base.substr(0, base.size() - ext.size());
if (ext == ".wom") {
r.womCount++;
auto wom = wowee::pipeline::WoweeModelLoader::load(base);
r.womVerts += wom.vertices.size();
r.womIndices += wom.indices.size();
r.womBones += wom.bones.size();
r.womAnims += wom.animations.size();
r.womBatches += wom.batches.size();
} else if (ext == ".wob") {
r.wobCount++;
auto wob = wowee::pipeline::WoweeBuildingLoader::load(base);
r.wobGroups += wob.groups.size();
for (const auto& g : wob.groups) {
r.wobVerts += g.vertices.size();
r.wobIndices += g.indices.size();
}
r.wobDoodads += wob.doodads.size();
r.wobPortals += wob.portals.size();
}
}
tot.womCount += r.womCount;
tot.wobCount += r.wobCount;
tot.womVerts += r.womVerts;
tot.womIndices += r.womIndices;
tot.womBones += r.womBones;
tot.womAnims += r.womAnims;
tot.womBatches += r.womBatches;
tot.wobGroups += r.wobGroups;
tot.wobVerts += r.wobVerts;
tot.wobIndices += r.wobIndices;
tot.wobDoodads += r.wobDoodads;
tot.wobPortals += r.wobPortals;
rows.push_back(r);
}
if (jsonOut) {
nlohmann::json j;
j["project"] = projectDir;
j["zones"] = nlohmann::json::array();
auto rowJson = [](const ZRow& r) {
nlohmann::json z;
z["name"] = r.name;
z["wom"] = {{"count", r.womCount},
{"vertices", r.womVerts},
{"indices", r.womIndices},
{"triangles", r.womIndices / 3},
{"bones", r.womBones},
{"animations", r.womAnims},
{"batches", r.womBatches}};
z["wob"] = {{"count", r.wobCount},
{"groups", r.wobGroups},
{"vertices", r.wobVerts},
{"indices", r.wobIndices},
{"triangles", r.wobIndices / 3},
{"doodads", r.wobDoodads},
{"portals", r.wobPortals}};
return z;
};
for (const auto& r : rows) j["zones"].push_back(rowJson(r));
j["total"] = rowJson(tot);
std::printf("%s\n", j.dump(2).c_str());
return 0;
}
std::printf("Project models total: %s\n", projectDir.c_str());
std::printf(" zones : %zu\n\n", zones.size());
std::printf(" zone WOMs WOMtri bones WOBs WOBtri doodads\n");
for (const auto& r : rows) {
std::printf(" %-20s %5d %7llu %6llu %5d %7llu %8llu\n",
r.name.substr(0, 20).c_str(),
r.womCount,
static_cast<unsigned long long>(r.womIndices / 3),
static_cast<unsigned long long>(r.womBones),
r.wobCount,
static_cast<unsigned long long>(r.wobIndices / 3),
static_cast<unsigned long long>(r.wobDoodads));
}
std::printf(" %-20s %5d %7llu %6llu %5d %7llu %8llu\n",
tot.name.c_str(),
tot.womCount,
static_cast<unsigned long long>(tot.womIndices / 3),
static_cast<unsigned long long>(tot.womBones),
tot.wobCount,
static_cast<unsigned long long>(tot.wobIndices / 3),
static_cast<unsigned long long>(tot.wobDoodads));
std::printf("\n Combined verts/tris (WOM+WOB): %llu / %llu\n",
static_cast<unsigned long long>(tot.womVerts + tot.wobVerts),
static_cast<unsigned long long>((tot.womIndices + tot.wobIndices) / 3));
return 0;
feat(editor): add --copy-project recursive project tree copy Recursively copies an entire project tree (every zone subdir + manifests + content files). Refuses to overwrite an existing destination so a typo doesn't silently merge into the wrong project — user must delete the destination first if intentional. Reports zone count, total file count, and total byte count of what was copied. Useful for forking a project for experimentation, or for creating snapshot backups before risky bulk operations like --strip-data-tree or --remove-project-orphans. Verified: 2-zone gen-random-project source → copy-project → "zones: 2, files: 12, total bytes: 395989" reported correctly, existing destination correctly rejected.
2026-05-07 19:31:09 -07:00
} else if (std::strcmp(argv[i], "--copy-project") == 0 && i + 2 < argc) {
// Recursively copy an entire project tree. Refuses to
// overwrite an existing destination so a typo doesn't
// silently merge into the wrong project.
std::string fromDir = argv[++i];
std::string toDir = argv[++i];
namespace fs = std::filesystem;
if (!fs::exists(fromDir) || !fs::is_directory(fromDir)) {
std::fprintf(stderr,
"copy-project: %s is not a directory\n", fromDir.c_str());
return 1;
}
if (fs::exists(toDir)) {
std::fprintf(stderr,
"copy-project: destination %s already exists "
"(delete it first if intentional)\n", toDir.c_str());
return 1;
}
std::error_code ec;
fs::copy(fromDir, toDir,
fs::copy_options::recursive | fs::copy_options::copy_symlinks,
ec);
if (ec) {
std::fprintf(stderr,
"copy-project: copy failed (%s)\n", ec.message().c_str());
return 1;
}
// Count what was copied for the report.
int zoneCount = 0, fileCount = 0;
uint64_t totalBytes = 0;
for (const auto& entry : fs::directory_iterator(toDir, ec)) {
if (entry.is_directory() &&
fs::exists(entry.path() / "zone.json")) zoneCount++;
}
for (const auto& e : fs::recursive_directory_iterator(toDir, ec)) {
if (e.is_regular_file()) {
fileCount++;
totalBytes += e.file_size(ec);
}
}
std::printf("Copied %s -> %s\n", fromDir.c_str(), toDir.c_str());
std::printf(" zones : %d\n", zoneCount);
std::printf(" files : %d\n", fileCount);
std::printf(" total bytes : %llu (%.1f MB)\n",
static_cast<unsigned long long>(totalBytes),
totalBytes / (1024.0 * 1024.0));
return 0;
feat(editor): add --zone-summary CLI for one-shot zone overview Combines validate + creature/object/quest counts in a single output. Useful for CI reports and quick sanity checks. Exits 0 if open-format score is 7/7 (full coverage), 1 otherwise.
2026-05-06 08:39:38 -07:00
} else if (std::strcmp(argv[i], "--zone-summary") == 0 && i + 1 < argc) {
// One-shot zone overview: validate + creature/object/quest counts.
// Collapses the most common multi-step inspection into a single
// command; useful for CI reports and quick sanity checks.
std::string zoneDir = argv[++i];
feat(editor): --zone-summary --json for unified machine-readable report Adds --json output to the one-shot zone-summary aggregator. Refactor also moves creature/object/quest data reads to a shared step before either branch so both human and JSON outputs use the same numbers. Schema: { "zone": "custom_zones/Foo", "score": 3, "maxScore": 7, "formats": "WOT WHM zone.json ", "counts": { "wot":1, "whm":1, "wom":0, "wob":0, "woc":0, "png":0 }, "creatures": { "total":N, "hostile":N, "questgiver":N, "vendor":N }, "objects": { "total":N, "m2":N, "wmo":N }, "quests": { "total":N, "chainWarnings":N } } Now CI can gate on any combination — open-format coverage, NPC counts, quest chain health — from a single command. Fourth and last commonly-CI'd inspector to gain --json mode (after --info-extract, --validate, --info-wcp).
2026-05-06 11:14:41 -07:00
// Optional --json after the dir for machine-readable output.
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
feat(editor): add --zone-summary CLI for one-shot zone overview Combines validate + creature/object/quest counts in a single output. Useful for CI reports and quick sanity checks. Exits 0 if open-format score is 7/7 (full coverage), 1 otherwise.
2026-05-06 08:39:38 -07:00
namespace fs = std::filesystem;
if (!fs::exists(zoneDir)) {
std::fprintf(stderr, "zone-summary: %s does not exist\n", zoneDir.c_str());
return 1;
}
auto v = wowee::editor::ContentPacker::validateZone(zoneDir);
feat(editor): --zone-summary --json for unified machine-readable report Adds --json output to the one-shot zone-summary aggregator. Refactor also moves creature/object/quest data reads to a shared step before either branch so both human and JSON outputs use the same numbers. Schema: { "zone": "custom_zones/Foo", "score": 3, "maxScore": 7, "formats": "WOT WHM zone.json ", "counts": { "wot":1, "whm":1, "wom":0, "wob":0, "woc":0, "png":0 }, "creatures": { "total":N, "hostile":N, "questgiver":N, "vendor":N }, "objects": { "total":N, "m2":N, "wmo":N }, "quests": { "total":N, "chainWarnings":N } } Now CI can gate on any combination — open-format coverage, NPC counts, quest chain health — from a single command. Fourth and last commonly-CI'd inspector to gain --json mode (after --info-extract, --validate, --info-wcp).
2026-05-06 11:14:41 -07:00
// Read creature/object/quest data once so both human and JSON
// outputs share the same numbers.
int creatureTotal = 0, hostile = 0, qg = 0, vendor = 0;
int objectTotal = 0, m2Count = 0, wmoCount = 0;
int questTotal = 0, chainWarnings = 0;
feat(editor): add --zone-summary CLI for one-shot zone overview Combines validate + creature/object/quest counts in a single output. Useful for CI reports and quick sanity checks. Exits 0 if open-format score is 7/7 (full coverage), 1 otherwise.
2026-05-06 08:39:38 -07:00
std::string creaturesPath = zoneDir + "/creatures.json";
if (fs::exists(creaturesPath)) {
wowee::editor::NpcSpawner sp;
if (sp.loadFromFile(creaturesPath)) {
feat(editor): --zone-summary --json for unified machine-readable report Adds --json output to the one-shot zone-summary aggregator. Refactor also moves creature/object/quest data reads to a shared step before either branch so both human and JSON outputs use the same numbers. Schema: { "zone": "custom_zones/Foo", "score": 3, "maxScore": 7, "formats": "WOT WHM zone.json ", "counts": { "wot":1, "whm":1, "wom":0, "wob":0, "woc":0, "png":0 }, "creatures": { "total":N, "hostile":N, "questgiver":N, "vendor":N }, "objects": { "total":N, "m2":N, "wmo":N }, "quests": { "total":N, "chainWarnings":N } } Now CI can gate on any combination — open-format coverage, NPC counts, quest chain health — from a single command. Fourth and last commonly-CI'd inspector to gain --json mode (after --info-extract, --validate, --info-wcp).
2026-05-06 11:14:41 -07:00
creatureTotal = static_cast<int>(sp.getSpawns().size());
feat(editor): add --zone-summary CLI for one-shot zone overview Combines validate + creature/object/quest counts in a single output. Useful for CI reports and quick sanity checks. Exits 0 if open-format score is 7/7 (full coverage), 1 otherwise.
2026-05-06 08:39:38 -07:00
for (const auto& s : sp.getSpawns()) {
if (s.hostile) hostile++;
if (s.questgiver) qg++;
if (s.vendor) vendor++;
}
}
}
std::string objectsPath = zoneDir + "/objects.json";
if (fs::exists(objectsPath)) {
wowee::editor::ObjectPlacer op;
if (op.loadFromFile(objectsPath)) {
feat(editor): --zone-summary --json for unified machine-readable report Adds --json output to the one-shot zone-summary aggregator. Refactor also moves creature/object/quest data reads to a shared step before either branch so both human and JSON outputs use the same numbers. Schema: { "zone": "custom_zones/Foo", "score": 3, "maxScore": 7, "formats": "WOT WHM zone.json ", "counts": { "wot":1, "whm":1, "wom":0, "wob":0, "woc":0, "png":0 }, "creatures": { "total":N, "hostile":N, "questgiver":N, "vendor":N }, "objects": { "total":N, "m2":N, "wmo":N }, "quests": { "total":N, "chainWarnings":N } } Now CI can gate on any combination — open-format coverage, NPC counts, quest chain health — from a single command. Fourth and last commonly-CI'd inspector to gain --json mode (after --info-extract, --validate, --info-wcp).
2026-05-06 11:14:41 -07:00
objectTotal = static_cast<int>(op.getObjects().size());
feat(editor): add --zone-summary CLI for one-shot zone overview Combines validate + creature/object/quest counts in a single output. Useful for CI reports and quick sanity checks. Exits 0 if open-format score is 7/7 (full coverage), 1 otherwise.
2026-05-06 08:39:38 -07:00
for (const auto& o : op.getObjects()) {
feat(editor): --zone-summary --json for unified machine-readable report Adds --json output to the one-shot zone-summary aggregator. Refactor also moves creature/object/quest data reads to a shared step before either branch so both human and JSON outputs use the same numbers. Schema: { "zone": "custom_zones/Foo", "score": 3, "maxScore": 7, "formats": "WOT WHM zone.json ", "counts": { "wot":1, "whm":1, "wom":0, "wob":0, "woc":0, "png":0 }, "creatures": { "total":N, "hostile":N, "questgiver":N, "vendor":N }, "objects": { "total":N, "m2":N, "wmo":N }, "quests": { "total":N, "chainWarnings":N } } Now CI can gate on any combination — open-format coverage, NPC counts, quest chain health — from a single command. Fourth and last commonly-CI'd inspector to gain --json mode (after --info-extract, --validate, --info-wcp).
2026-05-06 11:14:41 -07:00
if (o.type == wowee::editor::PlaceableType::M2) m2Count++;
else wmoCount++;
feat(editor): add --zone-summary CLI for one-shot zone overview Combines validate + creature/object/quest counts in a single output. Useful for CI reports and quick sanity checks. Exits 0 if open-format score is 7/7 (full coverage), 1 otherwise.
2026-05-06 08:39:38 -07:00
}
}
}
std::string questsPath = zoneDir + "/quests.json";
if (fs::exists(questsPath)) {
wowee::editor::QuestEditor qe;
if (qe.loadFromFile(questsPath)) {
feat(editor): --zone-summary --json for unified machine-readable report Adds --json output to the one-shot zone-summary aggregator. Refactor also moves creature/object/quest data reads to a shared step before either branch so both human and JSON outputs use the same numbers. Schema: { "zone": "custom_zones/Foo", "score": 3, "maxScore": 7, "formats": "WOT WHM zone.json ", "counts": { "wot":1, "whm":1, "wom":0, "wob":0, "woc":0, "png":0 }, "creatures": { "total":N, "hostile":N, "questgiver":N, "vendor":N }, "objects": { "total":N, "m2":N, "wmo":N }, "quests": { "total":N, "chainWarnings":N } } Now CI can gate on any combination — open-format coverage, NPC counts, quest chain health — from a single command. Fourth and last commonly-CI'd inspector to gain --json mode (after --info-extract, --validate, --info-wcp).
2026-05-06 11:14:41 -07:00
questTotal = static_cast<int>(qe.getQuests().size());
feat(editor): add --zone-summary CLI for one-shot zone overview Combines validate + creature/object/quest counts in a single output. Useful for CI reports and quick sanity checks. Exits 0 if open-format score is 7/7 (full coverage), 1 otherwise.
2026-05-06 08:39:38 -07:00
std::vector<std::string> errors;
qe.validateChains(errors);
feat(editor): --zone-summary --json for unified machine-readable report Adds --json output to the one-shot zone-summary aggregator. Refactor also moves creature/object/quest data reads to a shared step before either branch so both human and JSON outputs use the same numbers. Schema: { "zone": "custom_zones/Foo", "score": 3, "maxScore": 7, "formats": "WOT WHM zone.json ", "counts": { "wot":1, "whm":1, "wom":0, "wob":0, "woc":0, "png":0 }, "creatures": { "total":N, "hostile":N, "questgiver":N, "vendor":N }, "objects": { "total":N, "m2":N, "wmo":N }, "quests": { "total":N, "chainWarnings":N } } Now CI can gate on any combination — open-format coverage, NPC counts, quest chain health — from a single command. Fourth and last commonly-CI'd inspector to gain --json mode (after --info-extract, --validate, --info-wcp).
2026-05-06 11:14:41 -07:00
chainWarnings = static_cast<int>(errors.size());
feat(editor): add --zone-summary CLI for one-shot zone overview Combines validate + creature/object/quest counts in a single output. Useful for CI reports and quick sanity checks. Exits 0 if open-format score is 7/7 (full coverage), 1 otherwise.
2026-05-06 08:39:38 -07:00
}
}
feat(editor): --zone-summary --json for unified machine-readable report Adds --json output to the one-shot zone-summary aggregator. Refactor also moves creature/object/quest data reads to a shared step before either branch so both human and JSON outputs use the same numbers. Schema: { "zone": "custom_zones/Foo", "score": 3, "maxScore": 7, "formats": "WOT WHM zone.json ", "counts": { "wot":1, "whm":1, "wom":0, "wob":0, "woc":0, "png":0 }, "creatures": { "total":N, "hostile":N, "questgiver":N, "vendor":N }, "objects": { "total":N, "m2":N, "wmo":N }, "quests": { "total":N, "chainWarnings":N } } Now CI can gate on any combination — open-format coverage, NPC counts, quest chain health — from a single command. Fourth and last commonly-CI'd inspector to gain --json mode (after --info-extract, --validate, --info-wcp).
2026-05-06 11:14:41 -07:00
if (jsonOut) {
nlohmann::json j;
j["zone"] = zoneDir;
j["score"] = v.openFormatScore();
j["maxScore"] = 7;
j["formats"] = v.summary();
j["counts"] = {
{"wot", v.wotCount}, {"whm", v.whmCount},
{"wom", v.womCount}, {"wob", v.wobCount},
{"woc", v.wocCount}, {"png", v.pngCount},
};
j["creatures"] = {
{"total", creatureTotal},
{"hostile", hostile},
{"questgiver", qg},
{"vendor", vendor},
};
j["objects"] = {
{"total", objectTotal},
{"m2", m2Count},
{"wmo", wmoCount},
};
j["quests"] = {
{"total", questTotal},
{"chainWarnings", chainWarnings},
};
std::printf("%s\n", j.dump(2).c_str());
return v.openFormatScore() == 7 ? 0 : 1;
}
std::printf("Zone: %s\n", zoneDir.c_str());
std::printf(" open formats : %d/7 (%s)\n",
v.openFormatScore(), v.summary().c_str());
std::printf(" WOT/WHM : %d/%d WOM: %d WOB: %d WOC: %d PNG: %d\n",
v.wotCount, v.whmCount, v.womCount, v.wobCount,
v.wocCount, v.pngCount);
if (creatureTotal > 0) {
std::printf(" creatures : %d (%d hostile, %d quest, %d vendor)\n",
creatureTotal, hostile, qg, vendor);
}
if (objectTotal > 0) {
std::printf(" objects : %d (%d M2, %d WMO)\n",
objectTotal, m2Count, wmoCount);
}
if (questTotal > 0) {
std::printf(" quests : %d (%d chain warnings)\n",
questTotal, chainWarnings);
}
feat(editor): add --zone-summary CLI for one-shot zone overview Combines validate + creature/object/quest counts in a single output. Useful for CI reports and quick sanity checks. Exits 0 if open-format score is 7/7 (full coverage), 1 otherwise.
2026-05-06 08:39:38 -07:00
return v.openFormatScore() == 7 ? 0 : 1;
feat(editor): add --bench-bake-project for terrain-load timing analysis Companion to --bench-validate-project. Times the WHM/WOT load step (the dominant cost in --bake-zone-glb/obj/stl) per zone. The actual write side adds ~constant cost proportional to vertex count, so load time is a strong proxy for bake cost: wowee_editor --bench-bake-project custom_zones Bench bake (load-only): custom_zones zones : 12 total : 4731.20 ms (terrain load) per zone : avg=394.27 min=87.42 max=2103.55 ms slowest : Stranglethorn (2103.55 ms) Per-zone: zone ms tiles chunks ms/tile AshenForest 87.42 1 256 87.42 BoneOasis 245.10 4 1024 61.27 Stranglethorn 2103.55 9 2304 233.73 Useful for tracking 'has my latest geometry change made baking 3× slower?' across releases. Per-tile timing surfaces zones with high-variance chunk loads (e.g. dense doodad placements that inflate ADT load time). Pairs with --bench-validate-project (validation timing). Both use std::chrono::steady_clock for monotonic measurement; JSON modes emit per-zone records for CI dashboard consumption. Verified on a 2-zone project (Forest 2 tiles + Desert 1 tile): correctly reports per-zone timings + ms/tile ratio.
2026-05-06 18:50:20 -07:00
} else if (std::strcmp(argv[i], "--bench-bake-project") == 0 && i + 1 < argc) {
// Time WHM/WOT load (the dominant cost in --bake-zone-glb/obj/
// stl) per zone. The actual write side adds ~constant cost
// proportional to vertex count, so load time is a strong
// proxy. Useful for tracking 'has my latest geometry change
// made baking 3× slower?' across releases.
std::string projectDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(projectDir) || !fs::is_directory(projectDir)) {
std::fprintf(stderr,
"bench-bake-project: %s is not a directory\n",
projectDir.c_str());
return 1;
}
std::vector<std::string> zones;
for (const auto& entry : fs::directory_iterator(projectDir)) {
if (!entry.is_directory()) continue;
if (!fs::exists(entry.path() / "zone.json")) continue;
zones.push_back(entry.path().string());
}
std::sort(zones.begin(), zones.end());
struct Timing {
std::string name;
int tiles;
double loadMs;
int chunks;
};
std::vector<Timing> timings;
double totalMs = 0;
for (const auto& zoneDir : zones) {
wowee::editor::ZoneManifest zm;
if (!zm.load(zoneDir + "/zone.json")) continue;
Timing t{fs::path(zoneDir).filename().string(), 0, 0.0, 0};
auto t0 = std::chrono::steady_clock::now();
for (const auto& [tx, ty] : zm.tiles) {
std::string base = zoneDir + "/" + zm.mapName + "_" +
std::to_string(tx) + "_" + std::to_string(ty);
if (!wowee::pipeline::WoweeTerrainLoader::exists(base)) continue;
wowee::pipeline::ADTTerrain terrain;
wowee::pipeline::WoweeTerrainLoader::load(base, terrain);
t.tiles++;
for (const auto& chunk : terrain.chunks) {
if (chunk.heightMap.isLoaded()) t.chunks++;
}
}
auto t1 = std::chrono::steady_clock::now();
t.loadMs = std::chrono::duration<double, std::milli>(t1 - t0).count();
totalMs += t.loadMs;
timings.push_back(t);
}
double avgMs = !timings.empty() ? totalMs / timings.size() : 0.0;
double minMs = 1e30, maxMs = 0;
std::string slowest;
for (const auto& t : timings) {
if (t.loadMs < minMs) minMs = t.loadMs;
if (t.loadMs > maxMs) { maxMs = t.loadMs; slowest = t.name; }
}
if (timings.empty()) { minMs = 0; maxMs = 0; }
if (jsonOut) {
nlohmann::json j;
j["projectDir"] = projectDir;
j["totalMs"] = totalMs;
j["zoneCount"] = timings.size();
j["avgMs"] = avgMs;
j["minMs"] = minMs;
j["maxMs"] = maxMs;
j["slowestZone"] = slowest;
nlohmann::json arr = nlohmann::json::array();
for (const auto& t : timings) {
arr.push_back({{"zone", t.name},
{"loadMs", t.loadMs},
{"tiles", t.tiles},
{"chunks", t.chunks}});
}
j["perZone"] = arr;
std::printf("%s\n", j.dump(2).c_str());
return 0;
}
std::printf("Bench bake (load-only): %s\n", projectDir.c_str());
std::printf(" zones : %zu\n", timings.size());
std::printf(" total : %.2f ms (terrain load)\n", totalMs);
std::printf(" per zone : avg=%.2f min=%.2f max=%.2f ms\n",
avgMs, minMs, maxMs);
if (!slowest.empty()) {
std::printf(" slowest : %s (%.2f ms)\n", slowest.c_str(), maxMs);
}
std::printf("\n Per-zone:\n");
std::printf(" zone ms tiles chunks ms/tile\n");
for (const auto& t : timings) {
double mspt = t.tiles > 0 ? t.loadMs / t.tiles : 0.0;
std::printf(" %-26s %7.2f %5d %5d %6.2f\n",
t.name.substr(0, 26).c_str(),
t.loadMs, t.tiles, t.chunks, mspt);
}
return 0;
feat(editor): add --export-png CLI for terrain preview rendering Renders heightmap, normal-map, and zone-map PNGs alongside a WHM/WOT terrain pair. Useful for portfolio screenshots, ground- truth map comparison, and quick visual validation without launching the GUI.
2026-05-06 08:22:26 -07:00
} else if (std::strcmp(argv[i], "--export-png") == 0 && i + 1 < argc) {
// Render heightmap, normal-map, and zone-map PNG previews for a
// terrain. Useful for portfolio screenshots, ground-truth map
// comparison, and quick visual validation without launching GUI.
std::string base = argv[++i];
for (const char* ext : {".wot", ".whm"}) {
if (base.size() >= 4 && base.substr(base.size() - 4) == ext) {
base = base.substr(0, base.size() - 4);
break;
}
}
if (!wowee::pipeline::WoweeTerrainLoader::exists(base)) {
std::fprintf(stderr, "WOT/WHM not found at base: %s\n", base.c_str());
return 1;
}
wowee::pipeline::ADTTerrain terrain;
if (!wowee::pipeline::WoweeTerrainLoader::load(base, terrain)) {
std::fprintf(stderr, "Failed to load terrain: %s\n", base.c_str());
return 1;
}
wowee::editor::WoweeTerrain::exportHeightmapPreview(terrain, base + "_heightmap.png");
wowee::editor::WoweeTerrain::exportNormalMap(terrain, base + "_normals.png");
wowee::editor::WoweeTerrain::exportZoneMap(terrain, base + "_zone.png", 512);
std::printf("Exported PNGs: %s_{heightmap,normals,zone}.png\n", base.c_str());
feat(editor): add --fix-zone CLI to re-apply load-time scrubs/caps Loads + immediately re-saves zone.json, creatures.json, objects.json, and quests.json. The load-time scrubs (NaN, out-of-range, oversize) and save-time caps fire on the round-trip, producing a cleaned-up zone without ever opening the GUI. Useful when an old zone was created before recent hardening batches — running this once normalizes the on-disk state to match what the current loaders expect.
2026-05-06 10:08:49 -07:00
return 0;
} else if (std::strcmp(argv[i], "--fix-zone") == 0 && i + 1 < argc) {
// Re-parse + re-save every JSON/binary file in a zone to apply
// the editor's load-time scrubs and save-time caps. Useful when
// an old zone was created before recent hardening — running
// this once cleans up NaN/oversize fields without touching
// the editor GUI.
std::string zoneDir = argv[++i];
namespace fs = std::filesystem;
if (!fs::exists(zoneDir)) {
std::fprintf(stderr, "fix-zone: %s does not exist\n", zoneDir.c_str());
return 1;
}
int touched = 0;
// zone.json
{
wowee::editor::ZoneManifest m;
std::string p = zoneDir + "/zone.json";
if (fs::exists(p) && m.load(p) && m.save(p)) touched++;
}
// creatures.json
{
wowee::editor::NpcSpawner sp;
std::string p = zoneDir + "/creatures.json";
if (fs::exists(p) && sp.loadFromFile(p) && sp.saveToFile(p)) touched++;
}
// objects.json
{
wowee::editor::ObjectPlacer op;
std::string p = zoneDir + "/objects.json";
if (fs::exists(p) && op.loadFromFile(p) && op.saveToFile(p)) touched++;
}
// quests.json
{
wowee::editor::QuestEditor qe;
std::string p = zoneDir + "/quests.json";
if (fs::exists(p) && qe.loadFromFile(p) && qe.saveToFile(p)) touched++;
}
// WHM/WOT pairs and WoB files would need full pipeline access;
// skip them — the editor opens them on next zone load anyway,
// and the load-time scrubs run then.
std::printf("fix-zone: cleaned %d files in %s\n", touched, zoneDir.c_str());
feat(editor): add --export-png CLI for terrain preview rendering Renders heightmap, normal-map, and zone-map PNGs alongside a WHM/WOT terrain pair. Useful for portfolio screenshots, ground- truth map comparison, and quick visual validation without launching the GUI.
2026-05-06 08:22:26 -07:00
return 0;
feat(editor): add --regen-collision CLI for batch WOC rebuild Walks a zone directory recursively, finds every WHM file, and rebuilds the matching WOC. Useful after batch terrain edits when you want to refresh collision for many tiles in one shot. Reports per-tile triangle counts and exits 1 if any rebuild failed.
2026-05-06 08:53:12 -07:00
} else if (std::strcmp(argv[i], "--regen-collision") == 0 && i + 1 < argc) {
// Find all WHM/WOT pairs under a zone dir and rebuild WOC for each.
// Useful after sculpting changes when you want to re-derive
// collision in batch instead of one tile at a time.
std::string zoneDir = argv[++i];
namespace fs = std::filesystem;
if (!fs::exists(zoneDir)) {
std::fprintf(stderr, "regen-collision: %s does not exist\n",
zoneDir.c_str());
return 1;
}
int rebuilt = 0, failed = 0;
for (auto& entry : fs::recursive_directory_iterator(zoneDir)) {
if (!entry.is_regular_file()) continue;
if (entry.path().extension() != ".whm") continue;
std::string base = entry.path().string();
base = base.substr(0, base.size() - 4); // strip .whm
wowee::pipeline::ADTTerrain terrain;
if (!wowee::pipeline::WoweeTerrainLoader::load(base, terrain)) {
std::fprintf(stderr, " FAILED to load: %s\n", base.c_str());
failed++;
continue;
}
auto col = wowee::pipeline::WoweeCollisionBuilder::fromTerrain(terrain);
std::string outPath = base + ".woc";
if (wowee::pipeline::WoweeCollisionBuilder::save(col, outPath)) {
std::printf(" WOC rebuilt: %s (%zu triangles)\n",
outPath.c_str(), col.triangles.size());
rebuilt++;
} else {
std::fprintf(stderr, " FAILED to save: %s\n", outPath.c_str());
failed++;
}
}
std::printf("regen-collision: %d rebuilt, %d failed\n", rebuilt, failed);
return failed > 0 ? 1 : 0;
feat(editor): add --build-woc CLI for headless collision generation Loads a WHM/WOT terrain pair and writes a .woc collision mesh alongside it. Terrain triangles only (no WMO overlays — those need the asset manager) but enough for first-pass walkability while authoring. Verified end-to-end: scaffold-zone → build-woc → info-woc reports 32k triangles for a flat 256-chunk tile.
2026-05-06 08:21:14 -07:00
} else if (std::strcmp(argv[i], "--build-woc") == 0 && i + 1 < argc) {
// Generate a WOC collision mesh from a WHM/WOT terrain pair.
// Uses terrain triangles only (no WMO overlays); useful as a
// first-pass collision build before the editor adds buildings.
std::string base = argv[++i];
for (const char* ext : {".wot", ".whm", ".woc"}) {
if (base.size() >= 4 && base.substr(base.size() - 4) == ext) {
base = base.substr(0, base.size() - 4);
break;
}
}
if (!wowee::pipeline::WoweeTerrainLoader::exists(base)) {
std::fprintf(stderr, "WOT/WHM not found at base: %s\n", base.c_str());
return 1;
}
wowee::pipeline::ADTTerrain terrain;
if (!wowee::pipeline::WoweeTerrainLoader::load(base, terrain)) {
std::fprintf(stderr, "Failed to load terrain: %s\n", base.c_str());
return 1;
}
auto col = wowee::pipeline::WoweeCollisionBuilder::fromTerrain(terrain);
std::string outPath = base + ".woc";
if (!wowee::pipeline::WoweeCollisionBuilder::save(col, outPath)) {
std::fprintf(stderr, "WOC save failed: %s\n", outPath.c_str());
return 1;
}
std::printf("WOC built: %s (%zu triangles, %zu walkable, %zu steep)\n",
outPath.c_str(),
col.triangles.size(), col.walkableCount(), col.steepCount());
return 0;
feat(editor): add --gen-texture for synthesizing placeholder PNG textures Lets users add a working texture to a project without firing up an external image editor. Useful for prototyping new meshes, filling out a zone before art is final, or generating CI test fixtures. Three spec modes: - "RRGGBB" or "RGB" hex (case-insensitive, optional leading '#') → solid fill - "checker" → 32x32 black/white checkerboard - "grid" → black background with white 1-px grid every 16 Default 256x256, configurable via optional W H positional args (clamped to 1..8192). Writes via stbi_write_png so the output is a standard PNG every WoW open-format pipeline already accepts. First commit in the new "add content" direction (items / textures / meshes) the user requested. Verified: solid hex (ff0000), 3-char hex (8a3), checker, grid all produce valid PNGs of correct sizes; 'notacolor' input fails with exit 1 and a clear error. Brings command count to 194.
2026-05-07 00:52:29 -07:00
} else if (std::strcmp(argv[i], "--gen-texture") == 0 && i + 2 < argc) {
// Synthesize a placeholder PNG texture. Lets users add a
// working texture to their project without an external
// image editor — useful for prototyping new meshes,
// filling out a zone before art is final, or generating
// test fixtures.
//
// <colorHex|pattern>:
// "RRGGBB" or "RGB" hex (case-insensitive) → solid color
// "checker" → 32x32 black/white checkerboard
// "grid" → black background with white 1-px grid every 16
std::string outPath = argv[++i];
std::string spec = argv[++i];
int W = 256, H = 256;
if (i + 1 < argc && argv[i + 1][0] != '-') {
try { W = std::stoi(argv[++i]); } catch (...) {}
}
if (i + 1 < argc && argv[i + 1][0] != '-') {
try { H = std::stoi(argv[++i]); } catch (...) {}
}
if (W < 1 || H < 1 || W > 8192 || H > 8192) {
std::fprintf(stderr,
"gen-texture: invalid size %dx%d (must be 1..8192)\n", W, H);
return 1;
}
std::vector<uint8_t> pixels(static_cast<size_t>(W) * H * 3, 0);
std::string lower = spec;
std::transform(lower.begin(), lower.end(), lower.begin(),
[](unsigned char c) { return std::tolower(c); });
if (lower == "checker") {
for (int y = 0; y < H; ++y) {
for (int x = 0; x < W; ++x) {
bool dark = ((x / 32) + (y / 32)) & 1;
uint8_t v = dark ? 16 : 240;
size_t i2 = (static_cast<size_t>(y) * W + x) * 3;
pixels[i2 + 0] = v;
pixels[i2 + 1] = v;
pixels[i2 + 2] = v;
}
}
} else if (lower == "grid") {
for (int y = 0; y < H; ++y) {
for (int x = 0; x < W; ++x) {
bool line = (x % 16 == 0) || (y % 16 == 0);
uint8_t v = line ? 240 : 32;
size_t i2 = (static_cast<size_t>(y) * W + x) * 3;
pixels[i2 + 0] = v;
pixels[i2 + 1] = v;
pixels[i2 + 2] = v;
}
}
} else {
// Hex color. Accept "RGB" (3 chars) or "RRGGBB" (6 chars),
// optional leading '#'.
std::string hex = lower;
if (!hex.empty() && hex[0] == '#') hex.erase(0, 1);
auto fromHex = [](char c) -> int {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'a' && c <= 'f') return 10 + c - 'a';
return -1;
};
uint8_t r = 0, g = 0, b = 0;
if (hex.size() == 6) {
int hi, lo;
if ((hi = fromHex(hex[0])) < 0) goto bad_color;
if ((lo = fromHex(hex[1])) < 0) goto bad_color;
r = static_cast<uint8_t>((hi << 4) | lo);
if ((hi = fromHex(hex[2])) < 0) goto bad_color;
if ((lo = fromHex(hex[3])) < 0) goto bad_color;
g = static_cast<uint8_t>((hi << 4) | lo);
if ((hi = fromHex(hex[4])) < 0) goto bad_color;
if ((lo = fromHex(hex[5])) < 0) goto bad_color;
b = static_cast<uint8_t>((hi << 4) | lo);
} else if (hex.size() == 3) {
int v0, v1, v2;
if ((v0 = fromHex(hex[0])) < 0) goto bad_color;
if ((v1 = fromHex(hex[1])) < 0) goto bad_color;
if ((v2 = fromHex(hex[2])) < 0) goto bad_color;
r = static_cast<uint8_t>((v0 << 4) | v0);
g = static_cast<uint8_t>((v1 << 4) | v1);
b = static_cast<uint8_t>((v2 << 4) | v2);
} else {
goto bad_color;
}
for (int y = 0; y < H; ++y) {
for (int x = 0; x < W; ++x) {
size_t i2 = (static_cast<size_t>(y) * W + x) * 3;
pixels[i2 + 0] = r;
pixels[i2 + 1] = g;
pixels[i2 + 2] = b;
}
}
goto color_ok;
bad_color:
std::fprintf(stderr,
"gen-texture: '%s' is not a valid hex color or 'checker'/'grid'\n",
spec.c_str());
return 1;
color_ok: ;
}
if (!stbi_write_png(outPath.c_str(), W, H, 3,
pixels.data(), W * 3)) {
std::fprintf(stderr,
"gen-texture: stbi_write_png failed for %s\n", outPath.c_str());
return 1;
}
std::printf("Wrote %s\n", outPath.c_str());
std::printf(" size : %dx%d\n", W, H);
std::printf(" spec : %s\n", spec.c_str());
return 0;
feat(editor): add --add-texture-to-zone for importing existing PNGs Imports an existing PNG into a zone directory. Companion to --gen-texture (procedural placeholder) for the "I have an artist- painted texture, get it into my project" workflow. Optional <renameTo> argument lets the user store the PNG under a project- specific name. Safety: - Refuses non-.png input with a hint to use --convert-blp-png first (so .blp/.tga don't get silently shoved into a tree that won't render them) - Auto-appends .png to renameTo if user supplied just a stem - Idempotent re-runs: byte-identical destination → no-op exit 0 - Different-content destination → refuses to overwrite, exit 1 Closing line suggests --add-texture-to-mesh as the next step so the user has the full workflow in front of them. Verified all five paths: plain copy, rename+auto-ext, idempotent re-run (no-op exit 0), conflict (different bytes, exit 1), wrong extension (.blp, exit 1). Brings command count to 208.
2026-05-07 04:00:21 -07:00
} else if (std::strcmp(argv[i], "--add-texture-to-zone") == 0 && i + 2 < argc) {
// Import an existing PNG into a zone directory. Useful
// for the "I have an artist-painted texture, get it into
// my project" workflow — complements --gen-texture
// (procedural placeholder) and --convert-blp-png (legacy
// BLP migration).
//
// Optional <renameTo> argument lets the user store the
// PNG under a project-specific name (e.g., a generic
// "stone.png" downloaded from a tileset becomes
// "courtyard_floor.png" in the zone).
//
// Refuses to overwrite an existing destination unless the
// source and destination are byte-identical (idempotent
// re-runs are safe).
std::string zoneDir = argv[++i];
std::string srcPng = argv[++i];
std::string renameTo;
if (i + 1 < argc && argv[i + 1][0] != '-') renameTo = argv[++i];
namespace fs = std::filesystem;
if (!fs::exists(zoneDir) || !fs::is_directory(zoneDir)) {
std::fprintf(stderr,
"add-texture-to-zone: %s is not a directory\n",
zoneDir.c_str());
return 1;
}
if (!fs::exists(srcPng) || !fs::is_regular_file(srcPng)) {
std::fprintf(stderr,
"add-texture-to-zone: %s is not a file\n",
srcPng.c_str());
return 1;
}
// Sanity-check: must end in .png (any case) so users
// don't accidentally drop a .blp/.tga and get surprised
// when nothing renders.
std::string srcExt = fs::path(srcPng).extension().string();
std::transform(srcExt.begin(), srcExt.end(), srcExt.begin(),
[](unsigned char c) { return std::tolower(c); });
if (srcExt != ".png") {
std::fprintf(stderr,
"add-texture-to-zone: %s is not a .png "
"(use --convert-blp-png for .blp first)\n",
srcPng.c_str());
return 1;
}
std::string destLeaf = renameTo.empty()
? fs::path(srcPng).filename().string()
: renameTo;
// If the rename arg lacks an extension, append .png so
// common typos ("stone" -> "stone.png") just work.
if (fs::path(destLeaf).extension().string().empty()) {
destLeaf += ".png";
}
std::string destPath = zoneDir + "/" + destLeaf;
std::error_code ec;
if (fs::exists(destPath)) {
// Allow re-running if the bytes already match — makes
// makefile-driven workflows idempotent.
if (fs::file_size(srcPng, ec) == fs::file_size(destPath, ec)) {
std::ifstream a(srcPng, std::ios::binary);
std::ifstream b(destPath, std::ios::binary);
std::stringstream sa, sb;
sa << a.rdbuf(); sb << b.rdbuf();
if (sa.str() == sb.str()) {
std::printf("Already present: %s (no-op)\n",
destPath.c_str());
return 0;
}
}
std::fprintf(stderr,
"add-texture-to-zone: %s already exists with different "
"content (delete it first if intentional)\n",
destPath.c_str());
return 1;
}
fs::copy_file(srcPng, destPath, ec);
if (ec) {
std::fprintf(stderr,
"add-texture-to-zone: copy failed (%s)\n",
ec.message().c_str());
return 1;
}
uint64_t bytes = fs::file_size(destPath, ec);
std::printf("Imported %s -> %s\n",
srcPng.c_str(), destPath.c_str());
std::printf(" bytes : %llu\n",
static_cast<unsigned long long>(bytes));
std::printf(" next : --add-texture-to-mesh <wom-base> %s\n",
destPath.c_str());
return 0;
feat(editor): add --info-tilemap for project-wide ADT grid visualization Renders the WoW 64x64 ADT coordinate grid as ASCII art showing which tiles are claimed by which zones. Useful for spotting tile-coord collisions before two zones ship overlapping content, and for 'where am I working?' overview of multi-zone projects: wowee_editor --info-tilemap custom_zones Tilemap: custom_zones zones : 2 tiles used : 5 collisions : 0 (multiple zones claiming same tile) legend : D=Desert F=Forest 0 1 2 3 4 5 6 0123456789012345678901234567890123456789012345678901234567890123 y=30 ..............................FFDD.............................. y=31 ...............................F................................ Glyphs are first-letter-of-zone uppercased; collision tiles render as '*'. Empty rows are skipped to keep output bounded for projects in one corner of the map (skipping all 60+ blank rows of the full 64x64 grid). Exit 1 on collisions so CI can gate before merging two PRs that both add tiles in the same area. JSON mode emits per-tile claims for programmatic consumption. Verified on a 2-zone project: Forest (3 tiles) + Desert (2 tiles) correctly rendered, no collisions detected, glyphs F/D placed at the right grid coords.
2026-05-06 15:01:32 -07:00
} else if (std::strcmp(argv[i], "--info-tilemap") == 0 && i + 1 < argc) {
// Visualize the WoW 64x64 ADT grid showing which tiles are
// claimed by which zones across a project. Useful for
// spotting tile-coord collisions before two zones try to
// ship overlapping content, and for getting a 'where am I
// working?' overview of a multi-zone project.
std::string projectDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(projectDir) || !fs::is_directory(projectDir)) {
std::fprintf(stderr,
"info-tilemap: %s is not a directory\n", projectDir.c_str());
return 1;
}
// Map (tx, ty) -> vector<zone names> so collision overlaps
// are visible. Walk every zone in the project.
std::map<std::pair<int,int>, std::vector<std::string>> claims;
std::vector<std::string> zones;
for (const auto& entry : fs::directory_iterator(projectDir)) {
if (!entry.is_directory()) continue;
if (!fs::exists(entry.path() / "zone.json")) continue;
wowee::editor::ZoneManifest zm;
if (!zm.load((entry.path() / "zone.json").string())) continue;
std::string zname = zm.mapName.empty()
? entry.path().filename().string() : zm.mapName;
zones.push_back(zname);
for (const auto& [tx, ty] : zm.tiles) {
if (tx >= 0 && tx < 64 && ty >= 0 && ty < 64) {
claims[{tx, ty}].push_back(zname);
}
}
}
// Per-zone label glyph: first letter of the zone name,
// uppercased so different zones get distinct chars in the
// grid. Multi-letter overlap collapses to '*'.
std::map<std::string, char> zoneGlyph;
char nextGlyph = 'A';
for (const auto& z : zones) {
if (zoneGlyph.count(z)) continue;
if (!z.empty() && std::isalpha(static_cast<unsigned char>(z[0]))) {
zoneGlyph[z] = static_cast<char>(std::toupper(static_cast<unsigned char>(z[0])));
} else {
zoneGlyph[z] = nextGlyph++;
if (nextGlyph > 'Z') nextGlyph = 'a';
}
}
int collisions = 0;
for (const auto& [coord, owners] : claims) {
if (owners.size() > 1) collisions++;
}
if (jsonOut) {
nlohmann::json j;
j["projectDir"] = projectDir;
j["zoneCount"] = zones.size();
j["claimedTiles"] = claims.size();
j["collisions"] = collisions;
nlohmann::json claimsJson = nlohmann::json::array();
for (const auto& [coord, owners] : claims) {
claimsJson.push_back({{"x", coord.first},
{"y", coord.second},
{"zones", owners}});
}
j["claims"] = claimsJson;
std::printf("%s\n", j.dump(2).c_str());
return collisions == 0 ? 0 : 1;
}
std::printf("Tilemap: %s\n", projectDir.c_str());
std::printf(" zones : %zu\n", zones.size());
std::printf(" tiles used : %zu\n", claims.size());
std::printf(" collisions : %d (multiple zones claiming same tile)\n",
collisions);
std::printf(" legend :");
for (const auto& [name, glyph] : zoneGlyph) {
std::printf(" %c=%s", glyph, name.c_str());
}
std::printf("\n\n");
// Render 64x64 grid. Print column header in groups of 10
// for readability.
std::printf(" ");
for (int x = 0; x < 64; ++x) {
std::printf("%c", (x % 10 == 0) ? '0' + (x / 10) : ' ');
}
std::printf("\n");
std::printf(" ");
for (int x = 0; x < 64; ++x) std::printf("%d", x % 10);
std::printf("\n");
for (int y = 0; y < 64; ++y) {
// Skip rows that have no tiles claimed — keeps the
// output bounded for projects in one corner of the map.
bool rowHasContent = false;
for (int x = 0; x < 64 && !rowHasContent; ++x) {
if (claims.count({x, y})) rowHasContent = true;
}
if (!rowHasContent) continue;
std::printf(" y=%2d ", y);
for (int x = 0; x < 64; ++x) {
auto it = claims.find({x, y});
if (it == claims.end()) {
std::printf(".");
} else if (it->second.size() > 1) {
std::printf("*"); // collision
} else {
std::printf("%c", zoneGlyph[it->second[0]]);
}
}
std::printf("\n");
}
if (collisions > 0) {
std::printf("\n COLLISIONS:\n");
for (const auto& [coord, owners] : claims) {
if (owners.size() < 2) continue;
std::printf(" (%d, %d) claimed by:", coord.first, coord.second);
for (const auto& o : owners) std::printf(" %s", o.c_str());
std::printf("\n");
}
}
return collisions == 0 ? 0 : 1;
feat(editor): add --list-zone-deps for asset packaging audit Enumerates every external model path a zone references — both directly placed (objects.json) and indirectly via WOB doodad placements. Useful when packaging a content pack to confirm every asset will ship: wowee_editor --list-zone-deps custom_zones/MyZone Zone deps: custom_zones/MyZone WOBs scanned : 3 unique paths total : 12 Direct M2 placements (5 unique): World/Generic/Lamp.m2 World/Generic/Tree.m2 ×8 ... Direct WMO placements (2 unique): World/StaticObject/Stormwind/HumanInn.wmo WOB doodad M2 refs (5 unique): World/Furniture/Chair.wom World/Furniture/Table.wom ... Aggregation: - Counts duplicates so frequently-used assets show '×N' instead of cluttering the list with N identical lines. - Walks WOBs in the zone dir recursively (catches buildings/ subdir). - Also recurses into WOBs referenced by direct WMO placements so transitive doodad deps surface — matches the runtime's actual load chain. - Sorted output (std::map) so diffs across versions are stable. JSON mode emits per-category arrays for programmatic consumption (e.g. piping into a script that checks each path exists in Data/). Verified on a synthesized zone with 3 M2 placements (one duplicated) + 1 WMO placement + no WOBs: 3 unique total, Tree.m2 correctly deduped with ×2 count, JSON arrays well-formed.
2026-05-06 13:24:27 -07:00
} else if (std::strcmp(argv[i], "--list-zone-deps") == 0 && i + 1 < argc) {
// Enumerate every external model path a zone references —
// both directly placed (objects.json) and indirectly via
// doodad placements inside any WOB sitting next to the
// zone manifest. Useful when packaging a content pack to
// confirm every needed asset will ship.
std::string zoneDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(zoneDir + "/zone.json")) {
std::fprintf(stderr,
"list-zone-deps: %s has no zone.json\n", zoneDir.c_str());
return 1;
}
// Collect with usage counts so duplicates report '×N' instead
// of cluttering the table.
std::map<std::string, int> directM2; // m2 placements
std::map<std::string, int> directWMO; // wmo placements
std::map<std::string, int> doodadM2; // m2s referenced inside WOBs
wowee::editor::ObjectPlacer op;
if (op.loadFromFile(zoneDir + "/objects.json")) {
for (const auto& o : op.getObjects()) {
if (o.type == wowee::editor::PlaceableType::M2) directM2[o.path]++;
else if (o.type == wowee::editor::PlaceableType::WMO) directWMO[o.path]++;
}
}
// Walk WOBs in the zone directory recursively and pull in
// their doodad model paths. Sub-dirs caught too in case the
// user organizes buildings under a buildings/ subfolder.
int wobCount = 0;
std::error_code ec;
for (const auto& e : fs::recursive_directory_iterator(zoneDir, ec)) {
if (!e.is_regular_file()) continue;
std::string ext = e.path().extension().string();
if (ext != ".wob") continue;
wobCount++;
std::string base = e.path().string();
if (base.size() >= 4) base = base.substr(0, base.size() - 4);
auto bld = wowee::pipeline::WoweeBuildingLoader::load(base);
for (const auto& d : bld.doodads) {
if (d.modelPath.empty()) continue;
doodadM2[d.modelPath]++;
}
}
// For each direct WMO placement, also recurse into the WOB
// sitting at that path (relative to the zone) so transitive
// doodad deps surface — this matches the runtime's actual
// load chain.
for (const auto& [path, count] : directWMO) {
// Strip extension since loader takes a base path.
std::string base = path;
if (base.size() >= 4 && base.substr(base.size() - 4) == ".wmo")
base = base.substr(0, base.size() - 4);
// Try relative-to-zone first, then absolute.
std::string trial = zoneDir + "/" + base;
if (!wowee::pipeline::WoweeBuildingLoader::exists(trial)) trial = base;
if (!wowee::pipeline::WoweeBuildingLoader::exists(trial)) continue;
auto bld = wowee::pipeline::WoweeBuildingLoader::load(trial);
for (const auto& d : bld.doodads) {
if (d.modelPath.empty()) continue;
doodadM2[d.modelPath]++;
}
}
size_t totalUnique = directM2.size() + directWMO.size() + doodadM2.size();
if (jsonOut) {
nlohmann::json j;
j["zone"] = zoneDir;
j["wobCount"] = wobCount;
j["totalUnique"] = totalUnique;
auto toArr = [](const std::map<std::string, int>& m) {
nlohmann::json a = nlohmann::json::array();
for (const auto& [path, count] : m) {
a.push_back({{"path", path}, {"count", count}});
}
return a;
};
j["directM2"] = toArr(directM2);
j["directWMO"] = toArr(directWMO);
j["doodadM2"] = toArr(doodadM2);
std::printf("%s\n", j.dump(2).c_str());
return 0;
}
std::printf("Zone deps: %s\n", zoneDir.c_str());
std::printf(" WOBs scanned : %d\n", wobCount);
std::printf(" unique paths total : %zu\n", totalUnique);
auto emit = [](const char* tag, const std::map<std::string, int>& m) {
std::printf("\n %s (%zu unique):\n", tag, m.size());
if (m.empty()) {
std::printf(" *none*\n");
return;
}
for (const auto& [path, count] : m) {
if (count > 1) std::printf(" %s ×%d\n", path.c_str(), count);
else std::printf(" %s\n", path.c_str());
}
};
emit("Direct M2 placements", directM2);
emit("Direct WMO placements", directWMO);
emit("WOB doodad M2 refs", doodadM2);
return 0;
feat(editor): add --list-project-orphans to find unreferenced models Inverse of --list-zone-deps. Walks every zone in <projectDir>, collects the set of .wom/.wob files on disk plus the set of paths actually referenced by objects.json placements + WOB doodad lists, and reports any model files in the first set but not the second. Useful pre-pack cleanup — orphans bloat .wcp archives without contributing to gameplay. The output table shows zone + path + bytes so users can decide which to delete. Comparison normalizes paths by stripping extensions and matching both the full relative path and the leaf basename, so unqualified refs in objects.json (e.g. just "cube_a" without ".wom") still resolve. Verified: empty objects.json → 3 orphans across 2 zones; after --add-object cube_a → only 2 orphans remain (cube_a correctly removed from the list). Brings command count to 181.
2026-05-06 22:30:10 -07:00
} else if (std::strcmp(argv[i], "--list-project-orphans") == 0 && i + 1 < argc) {
// Inverse of --list-zone-deps. Walks every zone in
// <projectDir>, collects the set of .wom/.wob files
// sitting on disk and the set of paths actually
// referenced by objects.json placements + WOB doodad
// lists. Files in the first set but not the second are
// orphans — candidates for removal before --pack-wcp so
// the archive doesn't carry dead weight.
//
// Comparison is by basename (extension stripped) since
// the reference paths sometimes include the extension and
// sometimes don't.
std::string projectDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(projectDir) || !fs::is_directory(projectDir)) {
std::fprintf(stderr,
"list-project-orphans: %s is not a directory\n",
projectDir.c_str());
return 1;
}
std::vector<std::string> zones;
for (const auto& entry : fs::directory_iterator(projectDir)) {
if (!entry.is_directory()) continue;
if (!fs::exists(entry.path() / "zone.json")) continue;
zones.push_back(entry.path().string());
}
std::sort(zones.begin(), zones.end());
// Project-wide reference set. Normalize by stripping
// extension and any leading "./".
auto normalize = [](std::string p) {
while (p.size() >= 2 && p[0] == '.' && p[1] == '/') p.erase(0, 2);
std::string ext = fs::path(p).extension().string();
if (ext == ".wom" || ext == ".wob" || ext == ".m2" || ext == ".wmo") {
p = p.substr(0, p.size() - ext.size());
}
return p;
};
std::set<std::string> referencedBases; // normalized basenames
for (const auto& zoneDir : zones) {
wowee::editor::ObjectPlacer op;
if (op.loadFromFile(zoneDir + "/objects.json")) {
for (const auto& o : op.getObjects()) {
if (o.path.empty()) continue;
// Reference can be relative to zone or just a
// bare model name; record both forms for the
// membership test.
std::string norm = normalize(o.path);
referencedBases.insert(norm);
// Also try the leaf basename so unqualified
// refs match.
referencedBases.insert(fs::path(norm).filename().string());
}
}
std::error_code ec;
for (const auto& e : fs::recursive_directory_iterator(zoneDir, ec)) {
if (!e.is_regular_file()) continue;
if (e.path().extension() != ".wob") continue;
std::string base = e.path().string();
if (base.size() >= 4) base = base.substr(0, base.size() - 4);
auto bld = wowee::pipeline::WoweeBuildingLoader::load(base);
for (const auto& d : bld.doodads) {
if (d.modelPath.empty()) continue;
std::string norm = normalize(d.modelPath);
referencedBases.insert(norm);
referencedBases.insert(fs::path(norm).filename().string());
}
}
}
// Now walk every zone again and flag orphan .wom/.wob files.
struct Orphan { std::string zone, path; uint64_t bytes; };
std::vector<Orphan> orphans;
uint64_t totalOrphanBytes = 0;
for (const auto& zoneDir : zones) {
std::string zoneName = fs::path(zoneDir).filename().string();
std::error_code ec;
for (const auto& e : fs::recursive_directory_iterator(zoneDir, ec)) {
if (!e.is_regular_file()) continue;
std::string ext = e.path().extension().string();
if (ext != ".wom" && ext != ".wob") continue;
std::string rel = fs::relative(e.path(), zoneDir, ec).string();
if (ec) rel = e.path().filename().string();
std::string normRel = rel.substr(0, rel.size() - ext.size());
std::string leaf = e.path().stem().string();
if (referencedBases.count(normRel) ||
referencedBases.count(leaf)) {
continue; // referenced, not orphan
}
uint64_t sz = e.file_size(ec);
if (ec) sz = 0;
orphans.push_back({zoneName, rel, sz});
totalOrphanBytes += sz;
}
}
std::sort(orphans.begin(), orphans.end(),
[](const Orphan& a, const Orphan& b) {
if (a.zone != b.zone) return a.zone < b.zone;
return a.path < b.path;
});
if (jsonOut) {
nlohmann::json j;
j["project"] = projectDir;
j["referencedCount"] = referencedBases.size();
j["orphanCount"] = orphans.size();
j["orphanBytes"] = totalOrphanBytes;
nlohmann::json arr = nlohmann::json::array();
for (const auto& o : orphans) {
arr.push_back({{"zone", o.zone},
{"path", o.path},
{"bytes", o.bytes}});
}
j["orphans"] = arr;
std::printf("%s\n", j.dump(2).c_str());
return 0;
}
std::printf("Project orphans: %s\n", projectDir.c_str());
std::printf(" zones scanned : %zu\n", zones.size());
std::printf(" refs collected : %zu (normalized basenames)\n",
referencedBases.size());
std::printf(" orphan .wom/.wob : %zu file(s), %.1f KB\n",
orphans.size(), totalOrphanBytes / 1024.0);
if (orphans.empty()) {
std::printf("\n (no orphans — every model file is referenced)\n");
return 0;
}
std::printf("\n zone bytes path\n");
for (const auto& o : orphans) {
std::printf(" %-20s %8llu %s\n",
o.zone.substr(0, 20).c_str(),
static_cast<unsigned long long>(o.bytes),
o.path.c_str());
}
return 0;
feat(editor): add --remove-project-orphans for pre-pack cleanup Destructive companion to --list-project-orphans. Reuses the same reference-collection + orphan-detection logic, then deletes the resulting .wom/.wob files. Honors --dry-run for safe previews. Completes the list/remove cycle for unreferenced model files: run --list-project-orphans to audit, then --remove-project-orphans --dry-run to confirm, then drop --dry-run to actually clean. Useful right before --pack-wcp so the archive doesn't carry dead weight. Verified: dry-run preserves files (3 reported, all still present); real run on a copy removes all 3 with no failures, freeing 1.2 KB. Brings command count to 182.
2026-05-06 22:42:29 -07:00
} else if (std::strcmp(argv[i], "--remove-project-orphans") == 0 && i + 1 < argc) {
// Destructive companion to --list-project-orphans. Reuses
// the same reference-collection + orphan-detection logic
// and then deletes the resulting files. --dry-run shows
// what would be removed without touching anything.
std::string projectDir = argv[++i];
bool dryRun = false;
if (i + 1 < argc && std::strcmp(argv[i + 1], "--dry-run") == 0) {
dryRun = true; i++;
}
namespace fs = std::filesystem;
if (!fs::exists(projectDir) || !fs::is_directory(projectDir)) {
std::fprintf(stderr,
"remove-project-orphans: %s is not a directory\n",
projectDir.c_str());
return 1;
}
std::vector<std::string> zones;
for (const auto& entry : fs::directory_iterator(projectDir)) {
if (!entry.is_directory()) continue;
if (!fs::exists(entry.path() / "zone.json")) continue;
zones.push_back(entry.path().string());
}
std::sort(zones.begin(), zones.end());
// Same normalize + reference collection as --list-project-orphans.
// Keep both functions in sync if the matching rules evolve.
auto normalize = [](std::string p) {
while (p.size() >= 2 && p[0] == '.' && p[1] == '/') p.erase(0, 2);
std::string ext = fs::path(p).extension().string();
if (ext == ".wom" || ext == ".wob" || ext == ".m2" || ext == ".wmo") {
p = p.substr(0, p.size() - ext.size());
}
return p;
};
std::set<std::string> referencedBases;
for (const auto& zoneDir : zones) {
wowee::editor::ObjectPlacer op;
if (op.loadFromFile(zoneDir + "/objects.json")) {
for (const auto& o : op.getObjects()) {
if (o.path.empty()) continue;
std::string norm = normalize(o.path);
referencedBases.insert(norm);
referencedBases.insert(fs::path(norm).filename().string());
}
}
std::error_code ec;
for (const auto& e : fs::recursive_directory_iterator(zoneDir, ec)) {
if (!e.is_regular_file()) continue;
if (e.path().extension() != ".wob") continue;
std::string base = e.path().string();
if (base.size() >= 4) base = base.substr(0, base.size() - 4);
auto bld = wowee::pipeline::WoweeBuildingLoader::load(base);
for (const auto& d : bld.doodads) {
if (d.modelPath.empty()) continue;
std::string norm = normalize(d.modelPath);
referencedBases.insert(norm);
referencedBases.insert(fs::path(norm).filename().string());
}
}
}
int removed = 0, failed = 0;
uint64_t freedBytes = 0;
for (const auto& zoneDir : zones) {
std::string zoneName = fs::path(zoneDir).filename().string();
std::error_code ec;
std::vector<fs::path> toRemove;
for (const auto& e : fs::recursive_directory_iterator(zoneDir, ec)) {
if (!e.is_regular_file()) continue;
std::string ext = e.path().extension().string();
if (ext != ".wom" && ext != ".wob") continue;
std::string rel = fs::relative(e.path(), zoneDir, ec).string();
if (ec) rel = e.path().filename().string();
std::string normRel = rel.substr(0, rel.size() - ext.size());
std::string leaf = e.path().stem().string();
if (referencedBases.count(normRel) ||
referencedBases.count(leaf)) continue;
toRemove.push_back(e.path());
}
// Materialize the deletion list before removing so we
// don't mutate the directory while iterating.
for (const auto& p : toRemove) {
uint64_t sz = fs::file_size(p, ec);
if (ec) sz = 0;
std::string rel = fs::relative(p, zoneDir, ec).string();
if (ec) rel = p.filename().string();
if (dryRun) {
std::printf(" would remove: %s/%s (%llu bytes)\n",
zoneName.c_str(), rel.c_str(),
static_cast<unsigned long long>(sz));
removed++;
freedBytes += sz;
} else {
if (fs::remove(p, ec)) {
std::printf(" removed: %s/%s (%llu bytes)\n",
zoneName.c_str(), rel.c_str(),
static_cast<unsigned long long>(sz));
removed++;
freedBytes += sz;
} else {
std::fprintf(stderr,
" WARN: failed to remove %s (%s)\n",
p.c_str(), ec.message().c_str());
failed++;
}
}
}
}
std::printf("\nremove-project-orphans: %s%s\n",
projectDir.c_str(), dryRun ? " (dry-run)" : "");
std::printf(" zones : %zu\n", zones.size());
std::printf(" refs : %zu (normalized basenames)\n",
referencedBases.size());
std::printf(" %s : %d file(s)\n",
dryRun ? "would remove" : "removed ", removed);
std::printf(" freed : %.1f KB\n", freedBytes / 1024.0);
if (failed > 0) {
std::printf(" FAILED : %d (see stderr)\n", failed);
}
if (dryRun && removed > 0) {
std::printf(" re-run without --dry-run to apply\n");
}
return failed == 0 ? 0 : 1;
feat(editor): add --export-zone-deps-md for shareable dependency tables Markdown counterpart to --list-zone-deps. PR reviewers see at a glance whether every referenced model exists in either open or proprietary form across the conventional asset roots: wowee_editor --export-zone-deps-md custom_zones/MyZone # -> custom_zones/MyZone/DEPS.md # Dependencies — MyZone *Auto-generated. Status is best-effort — checks zone-local, output/, custom_zones/, Data/ roots in that order.* ## Direct M2 placements (12) | Refs | Path | Status | |---:|---|---| | 8 | `World/Tree.m2` | open + proprietary | | 3 | `World/Lamp.m2` | open only | | 1 | `World/Banner.m2` | MISSING | Status column resolves each path against zone-local + output/ + custom_zones/ + Data/ roots, trying both .wob/.wmo for buildings and .wom/.m2 for models. Catches missing assets BEFORE pack-wcp would silently include broken refs. GitHub-Flavored Markdown — sortable by Refs column once rendered, backtick-wrapped paths so URLs/spaces don't confuse the viewer. Verified: scaffolded zone with 2 M2 placements (one duplicated) + 1 WMO placement → DEPS.md has 3 sections (one per category) with correct ref counts (Tree.m2 ×2) and MISSING status for paths that don't resolve in any root.
2026-05-06 14:44:53 -07:00
} else if (std::strcmp(argv[i], "--export-zone-deps-md") == 0 && i + 1 < argc) {
// Markdown counterpart to --list-zone-deps. Writes a sortable
// GitHub-rendered table of every external model the zone
// references plus on-disk presence (so PR reviewers see at a
// glance whether dependencies are accounted for in the
// accompanying asset bundle).
std::string zoneDir = argv[++i];
std::string outPath;
if (i + 1 < argc && argv[i + 1][0] != '-') outPath = argv[++i];
namespace fs = std::filesystem;
if (!fs::exists(zoneDir + "/zone.json")) {
std::fprintf(stderr,
"export-zone-deps-md: %s has no zone.json\n", zoneDir.c_str());
return 1;
}
wowee::editor::ZoneManifest zm;
zm.load(zoneDir + "/zone.json");
if (outPath.empty()) outPath = zoneDir + "/DEPS.md";
// Same dep-collection pass as --list-zone-deps.
std::map<std::string, int> directM2;
std::map<std::string, int> directWMO;
std::map<std::string, int> doodadM2;
wowee::editor::ObjectPlacer op;
if (op.loadFromFile(zoneDir + "/objects.json")) {
for (const auto& o : op.getObjects()) {
if (o.type == wowee::editor::PlaceableType::M2) directM2[o.path]++;
else if (o.type == wowee::editor::PlaceableType::WMO) directWMO[o.path]++;
}
}
int wobCount = 0;
std::error_code ec;
for (const auto& e : fs::recursive_directory_iterator(zoneDir, ec)) {
if (!e.is_regular_file() ||
e.path().extension() != ".wob") continue;
wobCount++;
std::string base = e.path().string();
if (base.size() >= 4) base = base.substr(0, base.size() - 4);
auto bld = wowee::pipeline::WoweeBuildingLoader::load(base);
for (const auto& d : bld.doodads) {
if (!d.modelPath.empty()) doodadM2[d.modelPath]++;
}
}
// Resolve dep on disk. Same heuristic as --check-zone-refs:
// try both open + proprietary in conventional roots.
auto stripExt = [](const std::string& p, const char* ext) {
size_t n = std::strlen(ext);
if (p.size() >= n) {
std::string tail = p.substr(p.size() - n);
std::string lower = tail;
for (auto& c : lower) c = std::tolower(static_cast<unsigned char>(c));
if (lower == ext) return p.substr(0, p.size() - n);
}
return p;
};
auto resolveStatus = [&](const std::string& path, bool isWMO) {
std::string base, openExt, propExt;
if (isWMO) {
base = stripExt(path, ".wmo");
openExt = ".wob"; propExt = ".wmo";
} else {
base = stripExt(path, ".m2");
openExt = ".wom"; propExt = ".m2";
}
std::vector<std::string> roots = {
"", zoneDir + "/", "output/", "custom_zones/", "Data/"
};
bool hasOpen = false, hasProp = false;
for (const auto& root : roots) {
if (fs::exists(root + base + openExt)) hasOpen = true;
if (fs::exists(root + base + propExt)) hasProp = true;
}
if (hasOpen && hasProp) return "open + proprietary";
if (hasOpen) return "open only";
if (hasProp) return "proprietary only";
return "MISSING";
};
std::ofstream out(outPath);
if (!out) {
std::fprintf(stderr,
"export-zone-deps-md: cannot write %s\n", outPath.c_str());
return 1;
}
out << "# Dependencies — " <<
(zm.displayName.empty() ? zm.mapName : zm.displayName) << "\n\n";
out << "*Auto-generated by `wowee_editor --export-zone-deps-md`. "
"Status is best-effort — checks zone-local, output/, "
"custom_zones/, Data/ roots in that order.*\n\n";
auto emitTable = [&](const char* heading,
const std::map<std::string,int>& m,
bool isWMO) {
out << "## " << heading << " (" << m.size() << ")\n\n";
if (m.empty()) {
out << "*None.*\n\n";
return;
}
out << "| Refs | Path | Status |\n";
out << "|---:|---|---|\n";
for (const auto& [path, count] : m) {
out << "| " << count << " | `" << path << "` | "
<< resolveStatus(path, isWMO) << " |\n";
}
out << "\n";
};
emitTable("Direct M2 placements", directM2, false);
emitTable("Direct WMO placements", directWMO, true);
emitTable("WOB doodad M2 refs", doodadM2, false);
out << "## Summary\n\n";
out << "- Zone: `" << zm.mapName << "`\n";
out << "- WOBs scanned: " << wobCount << "\n";
out << "- Unique dependencies: " <<
directM2.size() + directWMO.size() + doodadM2.size() << "\n";
out.close();
std::printf("Wrote %s\n", outPath.c_str());
std::printf(" %zu M2 placements, %zu WMO placements, %zu WOB doodad refs\n",
directM2.size(), directWMO.size(), doodadM2.size());
return 0;
feat(editor): add --export-zone-spawn-png for top-down spawn-position maps Renders a top-down PNG showing creature + object spawn positions colored by type. Bound by the zone's tile range so the image is properly framed at zone scale: wowee_editor --export-zone-spawn-png custom_zones/MyZone # -> custom_zones/MyZone/MyZone_spawns.png Layout: - Tile-grid lines at tile boundaries (subtle grey on dark grey) - Red 3×3 dots: creature spawns - Green 3×3 dots: M2 object placements - Blue 3×3 dots: WMO object placements - 256 px per tile (so a 4-tile zone is 512×512); cap at 4096 largest dim for huge multi-tile projects WoW coord -> image transform: +X world is north (up in image), +Y world is west (left in image). Same convention --info-tilemap uses, so the spawn map and the tilemap line up visually. Useful for design review ('does the spawn distribution match the encounter design?'), screenshot bait for blog posts, and instant visual validation of new content before opening the GUI. Verified on a 1-tile mvp-zone with 3 creatures + 1 object plotted: 256×256 RGB PNG, dots placed at expected positions, --info-png confirms the output is well-formed (8-bit RGB, 2184 bytes).
2026-05-06 18:59:44 -07:00
} else if (std::strcmp(argv[i], "--export-zone-spawn-png") == 0 && i + 1 < argc) {
// Top-down PNG of spawn positions colored by type. Bound by
// the zone's tile range so the image is properly framed.
// Useful for design review (does the spawn distribution
// match the intended encounter design?) and for showing
// collaborators 'where are the mobs'.
std::string zoneDir = argv[++i];
std::string outPath;
if (i + 1 < argc && argv[i + 1][0] != '-') outPath = argv[++i];
namespace fs = std::filesystem;
std::string manifestPath = zoneDir + "/zone.json";
if (!fs::exists(manifestPath)) {
std::fprintf(stderr,
"export-zone-spawn-png: %s has no zone.json\n", zoneDir.c_str());
return 1;
}
wowee::editor::ZoneManifest zm;
if (!zm.load(manifestPath)) {
std::fprintf(stderr,
"export-zone-spawn-png: parse failed\n");
return 1;
}
if (zm.tiles.empty()) {
std::fprintf(stderr, "export-zone-spawn-png: zone has no tiles\n");
return 1;
}
if (outPath.empty()) outPath = zoneDir + "/" + zm.mapName + "_spawns.png";
// Compute world-space bounds from manifest tiles. Same math
// as --info-zone-extents.
constexpr float kTileSize = 533.33333f;
int tileMinX = 64, tileMaxX = -1;
int tileMinY = 64, tileMaxY = -1;
for (const auto& [tx, ty] : zm.tiles) {
tileMinX = std::min(tileMinX, tx);
tileMaxX = std::max(tileMaxX, tx);
tileMinY = std::min(tileMinY, ty);
tileMaxY = std::max(tileMaxY, ty);
}
float worldMinX = (32.0f - tileMaxY - 1) * kTileSize;
float worldMaxX = (32.0f - tileMinY) * kTileSize;
float worldMinY = (32.0f - tileMaxX - 1) * kTileSize;
float worldMaxY = (32.0f - tileMinX) * kTileSize;
// Image dimensions: 256px per tile so detail is visible
// without inflating per-pixel cost.
int tilesX = tileMaxY - tileMinY + 1; // tile.y maps to world.x
int tilesY = tileMaxX - tileMinX + 1;
const int kPxPerTile = 256;
int imgW = tilesX * kPxPerTile;
int imgH = tilesY * kPxPerTile;
// Cap output size — 16-tile-wide projects shouldn't exceed
// 4096 wide. Scale down if needed.
int maxDim = std::max(imgW, imgH);
if (maxDim > 4096) {
int divisor = (maxDim + 4095) / 4096;
imgW = std::max(64, imgW / divisor);
imgH = std::max(64, imgH / divisor);
}
std::vector<uint8_t> img(imgW * imgH * 3, 32); // dark grey background
// Tile-grid lines so the boundary is visible.
for (int t = 1; t < tilesX; ++t) {
int x = (t * imgW) / tilesX;
if (x >= 0 && x < imgW) {
for (int y = 0; y < imgH; ++y) {
size_t off = (y * imgW + x) * 3;
img[off] = img[off+1] = img[off+2] = 64;
}
}
}
for (int t = 1; t < tilesY; ++t) {
int y = (t * imgH) / tilesY;
if (y >= 0 && y < imgH) {
for (int x = 0; x < imgW; ++x) {
size_t off = (y * imgW + x) * 3;
img[off] = img[off+1] = img[off+2] = 64;
}
}
}
// Plot spawn points. Map world (X, Y) to image (px, py):
// px = (worldMaxX - X) / (worldMaxX - worldMinX) * imgW
// py = (worldMaxY - Y) / (worldMaxY - worldMinY) * imgH
// since +X world is north (up) and +Y world is west (left)
// in WoW coords.
float wRangeX = worldMaxX - worldMinX;
float wRangeY = worldMaxY - worldMinY;
auto plotPoint = [&](float wx, float wy, uint8_t r, uint8_t g, uint8_t b) {
if (wRangeX <= 0 || wRangeY <= 0) return;
int px = static_cast<int>((worldMaxX - wx) / wRangeX * imgW);
int py = static_cast<int>((worldMaxY - wy) / wRangeY * imgH);
// 3×3 dot.
for (int dy = -1; dy <= 1; ++dy) {
for (int dx = -1; dx <= 1; ++dx) {
int x = px + dx, y = py + dy;
if (x < 0 || x >= imgW || y < 0 || y >= imgH) continue;
size_t off = (y * imgW + x) * 3;
img[off] = r; img[off+1] = g; img[off+2] = b;
}
}
};
// Creatures = red.
wowee::editor::NpcSpawner sp;
int creaturesPlotted = 0;
if (sp.loadFromFile(zoneDir + "/creatures.json")) {
for (const auto& s : sp.getSpawns()) {
plotPoint(s.position.x, s.position.y, 220, 60, 60);
creaturesPlotted++;
}
}
// Objects = green (M2) / blue (WMO).
wowee::editor::ObjectPlacer op;
int objectsPlotted = 0;
if (op.loadFromFile(zoneDir + "/objects.json")) {
for (const auto& o : op.getObjects()) {
if (o.type == wowee::editor::PlaceableType::M2) {
plotPoint(o.position.x, o.position.y, 60, 200, 60);
} else {
plotPoint(o.position.x, o.position.y, 60, 120, 220);
}
objectsPlotted++;
}
}
if (!stbi_write_png(outPath.c_str(), imgW, imgH, 3,
img.data(), imgW * 3)) {
std::fprintf(stderr,
"export-zone-spawn-png: stbi_write_png failed\n");
return 1;
}
std::printf("Wrote %s\n", outPath.c_str());
std::printf(" %dx%d px, tile grid %dx%d, %d creatures (red), %d objects (green/blue)\n",
imgW, imgH, tilesX, tilesY, creaturesPlotted, objectsPlotted);
return 0;
feat(editor): add --check-zone-refs cross-reference validator Catches dangling references that --validate (which only checks open-format file presence) doesn't: wowee_editor --check-zone-refs custom_zones/MyZone Zone refs: custom_zones/MyZone objects checked : 12 (2 missing) quests checked : 5 (1 bad NPC refs) FAILED — 3 issue(s): - object[3] missing: World/Doodad/Tree.m2 - object[7] missing: World/Building/Inn.wmo - quest[1] 'Hunt' giver 999 not in creatures.json Two checks: 1. Every objects.json model path resolves on disk in any of the conventional roots (zone-local, output/, custom_zones/, Data/), trying both the open (.wom/.wob) and proprietary (.m2/.wmo) variants, with a case-fold fallback for case-sensitive Linux filesystems where extracted assets are usually lowercased. 2. Every quest's questGiverNpcId / turnInNpcId references a creature in creatures.json (when the zone has any). Filter: only flag IDs < 100000 since production wires upstream NPCs with 6-digit IDs that legitimately reference outside content. Errors capped at 30 listed (with full counts in the summary) so a misconfigured zone with 500 broken refs doesn't drown the output. Exit 1 on any issue so CI can gate. Verified: zone with 1 creature, 2 dead model refs, 1 bad NPC giver — all 3 issues reported with precise indices and exit 1.
2026-05-06 13:27:18 -07:00
} else if (std::strcmp(argv[i], "--check-zone-refs") == 0 && i + 1 < argc) {
// Cross-reference checker: every model path in objects.json
// must resolve as either an open WOM/WOB sidecar or a
// proprietary M2/WMO; every quest's giver/turnIn NPC ID must
// appear in creatures.json (when the zone has creatures).
// Catches dangling references that --validate doesn't, since
// --validate only checks open-format file presence.
std::string zoneDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(zoneDir + "/zone.json")) {
std::fprintf(stderr,
"check-zone-refs: %s has no zone.json\n", zoneDir.c_str());
return 1;
}
// Try to find a model on disk in any of the conventional
// locations (zone-local, output/, custom_zones/, Data/).
// Strips extension and tries each open + proprietary variant.
auto stripExt = [](const std::string& p, const char* ext) {
size_t n = std::strlen(ext);
if (p.size() >= n) {
std::string tail = p.substr(p.size() - n);
std::string lower = tail;
for (auto& c : lower) c = std::tolower(static_cast<unsigned char>(c));
if (lower == ext) return p.substr(0, p.size() - n);
}
return p;
};
auto modelExists = [&](const std::string& path, bool isWMO) {
std::string base;
std::vector<std::string> exts;
if (isWMO) {
base = stripExt(path, ".wmo");
exts = {".wob", ".wmo"};
} else {
base = stripExt(path, ".m2");
exts = {".wom", ".m2"};
}
std::vector<std::string> roots = {
"", zoneDir + "/", "output/", "custom_zones/", "Data/"
};
for (const auto& root : roots) {
for (const auto& ext : exts) {
if (fs::exists(root + base + ext)) return true;
// Case-fold fallback for case-sensitive filesystems
// (designers usually type Mixed Case but Linux
// stores asset paths lowercase after extraction).
std::string lower = base + ext;
for (auto& c : lower) c = std::tolower(static_cast<unsigned char>(c));
if (fs::exists(root + lower)) return true;
}
}
return false;
};
std::vector<std::string> errors;
// Object placements -> models on disk
wowee::editor::ObjectPlacer op;
int objectsChecked = 0, objectsMissing = 0;
if (op.loadFromFile(zoneDir + "/objects.json")) {
for (size_t k = 0; k < op.getObjects().size(); ++k) {
const auto& o = op.getObjects()[k];
objectsChecked++;
bool isWMO = (o.type == wowee::editor::PlaceableType::WMO);
if (!modelExists(o.path, isWMO)) {
objectsMissing++;
if (errors.size() < 30) {
errors.push_back("object[" + std::to_string(k) +
"] missing: " + o.path);
}
}
}
}
// Quest NPCs -> creatures.json IDs (only when creatures exist;
// otherwise NPC IDs may legitimately reference upstream content
// outside the zone).
wowee::editor::NpcSpawner sp;
wowee::editor::QuestEditor qe;
int questsChecked = 0, questsMissing = 0;
bool hasCreatures = sp.loadFromFile(zoneDir + "/creatures.json");
std::unordered_set<uint32_t> creatureIds;
if (hasCreatures) {
for (const auto& s : sp.getSpawns()) creatureIds.insert(s.id);
}
if (qe.loadFromFile(zoneDir + "/quests.json") && hasCreatures) {
for (size_t k = 0; k < qe.getQuests().size(); ++k) {
const auto& q = qe.getQuests()[k];
questsChecked++;
bool localGiver = (q.questGiverNpcId != 0 &&
creatureIds.count(q.questGiverNpcId) == 0);
bool localTurn = (q.turnInNpcId != 0 &&
q.turnInNpcId != q.questGiverNpcId &&
creatureIds.count(q.turnInNpcId) == 0);
// Only flag IDs that look 'small' (likely zone-local).
// Production uses 6-digit IDs that reference upstream
// content; designers wire those in deliberately.
if (localGiver && q.questGiverNpcId < 100000) {
questsMissing++;
if (errors.size() < 30) {
errors.push_back("quest[" + std::to_string(k) + "] '" +
q.title + "' giver " +
std::to_string(q.questGiverNpcId) +
" not in creatures.json");
}
}
if (localTurn && q.turnInNpcId < 100000) {
questsMissing++;
if (errors.size() < 30) {
errors.push_back("quest[" + std::to_string(k) + "] '" +
q.title + "' turn-in " +
std::to_string(q.turnInNpcId) +
" not in creatures.json");
}
}
}
}
int totalErrors = objectsMissing + questsMissing;
if (jsonOut) {
nlohmann::json j;
j["zone"] = zoneDir;
j["objectsChecked"] = objectsChecked;
j["objectsMissing"] = objectsMissing;
j["questsChecked"] = questsChecked;
j["questsMissing"] = questsMissing;
j["errors"] = errors;
j["passed"] = (totalErrors == 0);
std::printf("%s\n", j.dump(2).c_str());
return totalErrors == 0 ? 0 : 1;
}
std::printf("Zone refs: %s\n", zoneDir.c_str());
std::printf(" objects checked : %d (%d missing)\n",
objectsChecked, objectsMissing);
std::printf(" quests checked : %d (%d bad NPC refs)\n",
questsChecked, questsMissing);
if (totalErrors == 0) {
std::printf(" PASSED\n");
return 0;
}
std::printf(" FAILED — %d issue(s):\n", totalErrors);
for (const auto& e : errors) std::printf(" - %s\n", e.c_str());
return 1;
feat(editor): add --check-zone-content for content data-quality validation Sanity-checks creature/object/quest fields for plausible values. Where --check-zone-refs catches dangling references, this catches data-quality issues that pass technical validation but break gameplay: wowee_editor --check-zone-content custom_zones/MyZone Zone content: custom_zones/MyZone creature warnings: 1 object warnings : 0 quest warnings : 2 FAILED — 3 total warning(s): - creature[0] 'Wolf' has displayId=0 (will render invisibly) - quest[0] 'Hunt' has no objectives (uncompletable) - quest[0] 'Hunt' has no reward at all Per-type checks: Creatures: - empty name - 0 health (dies on spawn) - level 0 - minDamage > maxDamage (broken combat math) - non-positive or non-finite scale - displayId=0 (invisible at runtime) Objects: - empty path - non-positive or non-finite scale - non-finite position Quests: - empty title - no objectives (player can never complete) - no reward at all (XP=0, items=[], coins all 0) - requiredLevel=0 Both --check-zone-refs (link integrity) and --check-zone-content (data quality) needed — a quest can have valid NPC IDs (refs OK) AND no objectives (content broken). Run both before --pack-wcp. Verified end-to-end: zone with displayId=0 creature + objective- less + rewardless quest reports 3 warnings; after fixing all three, PASSED.
2026-05-06 15:31:12 -07:00
} else if (std::strcmp(argv[i], "--check-zone-content") == 0 && i + 1 < argc) {
// Sanity-check creature/object/quest fields for plausible
// values. --check-zone-refs catches dangling references;
// this catches data-quality issues like creatures with 0 HP,
// objects with negative scale, quests with no objectives.
// Both are needed — a quest can have valid NPC IDs (refs OK)
// AND no objectives (content broken).
std::string zoneDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(zoneDir + "/zone.json")) {
std::fprintf(stderr,
"check-zone-content: %s has no zone.json\n", zoneDir.c_str());
return 1;
}
std::vector<std::string> warnings;
int creatureWarn = 0, objectWarn = 0, questWarn = 0;
// Creatures
wowee::editor::NpcSpawner sp;
if (sp.loadFromFile(zoneDir + "/creatures.json")) {
for (size_t k = 0; k < sp.spawnCount(); ++k) {
const auto& s = sp.getSpawns()[k];
if (s.name.empty()) {
warnings.push_back("creature[" + std::to_string(k) + "] has empty name");
creatureWarn++;
}
if (s.health == 0) {
warnings.push_back("creature[" + std::to_string(k) + "] '" +
s.name + "' has 0 health");
creatureWarn++;
}
if (s.level == 0) {
warnings.push_back("creature[" + std::to_string(k) + "] '" +
s.name + "' has level 0");
creatureWarn++;
}
if (s.minDamage > s.maxDamage) {
warnings.push_back("creature[" + std::to_string(k) + "] '" +
s.name + "' has minDamage > maxDamage");
creatureWarn++;
}
if (s.scale <= 0.0f || !std::isfinite(s.scale)) {
warnings.push_back("creature[" + std::to_string(k) + "] '" +
s.name + "' has non-positive or non-finite scale");
creatureWarn++;
}
if (s.displayId == 0) {
warnings.push_back("creature[" + std::to_string(k) + "] '" +
s.name + "' has displayId=0 (will render invisibly)");
creatureWarn++;
}
}
}
// Objects
wowee::editor::ObjectPlacer op;
if (op.loadFromFile(zoneDir + "/objects.json")) {
for (size_t k = 0; k < op.getObjects().size(); ++k) {
const auto& o = op.getObjects()[k];
if (o.path.empty()) {
warnings.push_back("object[" + std::to_string(k) + "] has empty path");
objectWarn++;
}
if (o.scale <= 0.0f || !std::isfinite(o.scale)) {
warnings.push_back("object[" + std::to_string(k) +
"] has non-positive or non-finite scale");
objectWarn++;
}
if (!std::isfinite(o.position.x) ||
!std::isfinite(o.position.y) ||
!std::isfinite(o.position.z)) {
warnings.push_back("object[" + std::to_string(k) +
"] has non-finite position");
objectWarn++;
}
}
}
// Quests
wowee::editor::QuestEditor qe;
if (qe.loadFromFile(zoneDir + "/quests.json")) {
for (size_t k = 0; k < qe.questCount(); ++k) {
const auto& q = qe.getQuests()[k];
if (q.title.empty()) {
warnings.push_back("quest[" + std::to_string(k) + "] has empty title");
questWarn++;
}
if (q.objectives.empty()) {
warnings.push_back("quest[" + std::to_string(k) + "] '" +
q.title + "' has no objectives (uncompletable)");
questWarn++;
}
if (q.reward.xp == 0 && q.reward.itemRewards.empty() &&
q.reward.gold == 0 && q.reward.silver == 0 && q.reward.copper == 0) {
warnings.push_back("quest[" + std::to_string(k) + "] '" +
q.title + "' has no reward at all");
questWarn++;
}
if (q.requiredLevel == 0) {
warnings.push_back("quest[" + std::to_string(k) + "] '" +
q.title + "' has requiredLevel=0");
questWarn++;
}
}
}
int total = creatureWarn + objectWarn + questWarn;
if (jsonOut) {
nlohmann::json j;
j["zone"] = zoneDir;
j["creatureWarnings"] = creatureWarn;
j["objectWarnings"] = objectWarn;
j["questWarnings"] = questWarn;
j["totalWarnings"] = total;
j["warnings"] = warnings;
j["passed"] = (total == 0);
std::printf("%s\n", j.dump(2).c_str());
return total == 0 ? 0 : 1;
}
std::printf("Zone content: %s\n", zoneDir.c_str());
std::printf(" creature warnings: %d\n", creatureWarn);
std::printf(" object warnings : %d\n", objectWarn);
std::printf(" quest warnings : %d\n", questWarn);
if (total == 0) {
std::printf(" PASSED\n");
return 0;
}
std::printf(" FAILED — %d total warning(s):\n", total);
for (const auto& w : warnings) std::printf(" - %s\n", w.c_str());
return 1;
feat(editor): add --check-project-content for project-wide content validation Project-level content sanity check. Walks every zone and runs the same per-zone checks --check-zone-content does, aggregating warnings per zone. Designed for CI gates before --pack-wcp: wowee_editor --check-project-content custom_zones check-project-content: custom_zones zones : 12 (2 failed) total warns : 7 zone creat object quest status AshenForest 0 0 0 PASS BoneOasis 3 0 1 FAIL CrystalCaverns 0 0 0 PASS Stranglethorn 2 1 0 FAIL ... 2 zone(s) have content warnings Per-zone warning columns (creature/object/quest) make it instantly clear which content category needs attention. Exit 1 if any zone has any warning so CI can gate. Pairs with --validate-project (binary integrity) — both needed for release gates: a zone can have valid file structure (validate passes) AND content data-quality issues (check-content fails). Verified on a 2-zone project: mvp-zone Forest (all defaults sane) PASS, Empty zone with displayId=0 creature FAIL with 1 warning, exit 1.
2026-05-06 19:08:31 -07:00
} else if (std::strcmp(argv[i], "--check-project-content") == 0 && i + 1 < argc) {
// Project-level content sanity check. Walks every zone and
// runs the same per-zone checks that --check-zone-content
// does, aggregating warnings per zone. Exit 1 if any zone
// has any warning. Designed for CI gates before --pack-wcp.
std::string projectDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(projectDir) || !fs::is_directory(projectDir)) {
std::fprintf(stderr,
"check-project-content: %s is not a directory\n",
projectDir.c_str());
return 1;
}
std::vector<std::string> zones;
for (const auto& entry : fs::directory_iterator(projectDir)) {
if (!entry.is_directory()) continue;
if (!fs::exists(entry.path() / "zone.json")) continue;
zones.push_back(entry.path().string());
}
std::sort(zones.begin(), zones.end());
// Same per-zone walks as --check-zone-content. Reuse the
// logic by counting issues directly here (cheaper than
// shelling out to a sub-invocation per zone).
struct ZoneRow { std::string name; int creatureWarn, objectWarn, questWarn; };
std::vector<ZoneRow> rows;
int projectFailedZones = 0;
for (const auto& zoneDir : zones) {
ZoneRow row{fs::path(zoneDir).filename().string(), 0, 0, 0};
wowee::editor::NpcSpawner sp;
if (sp.loadFromFile(zoneDir + "/creatures.json")) {
for (const auto& s : sp.getSpawns()) {
if (s.name.empty()) row.creatureWarn++;
if (s.health == 0) row.creatureWarn++;
if (s.level == 0) row.creatureWarn++;
if (s.minDamage > s.maxDamage) row.creatureWarn++;
if (s.scale <= 0.0f || !std::isfinite(s.scale)) row.creatureWarn++;
if (s.displayId == 0) row.creatureWarn++;
}
}
wowee::editor::ObjectPlacer op;
if (op.loadFromFile(zoneDir + "/objects.json")) {
for (const auto& o : op.getObjects()) {
if (o.path.empty()) row.objectWarn++;
if (o.scale <= 0.0f || !std::isfinite(o.scale)) row.objectWarn++;
if (!std::isfinite(o.position.x) ||
!std::isfinite(o.position.y) ||
!std::isfinite(o.position.z)) row.objectWarn++;
}
}
wowee::editor::QuestEditor qe;
if (qe.loadFromFile(zoneDir + "/quests.json")) {
for (const auto& q : qe.getQuests()) {
if (q.title.empty()) row.questWarn++;
if (q.objectives.empty()) row.questWarn++;
if (q.reward.xp == 0 && q.reward.itemRewards.empty() &&
q.reward.gold == 0 && q.reward.silver == 0 &&
q.reward.copper == 0) row.questWarn++;
if (q.requiredLevel == 0) row.questWarn++;
}
}
int rowTotal = row.creatureWarn + row.objectWarn + row.questWarn;
if (rowTotal > 0) projectFailedZones++;
rows.push_back(row);
}
int allPassed = (projectFailedZones == 0);
int totalWarn = 0;
for (const auto& r : rows) totalWarn += r.creatureWarn + r.objectWarn + r.questWarn;
if (jsonOut) {
nlohmann::json j;
j["projectDir"] = projectDir;
j["totalZones"] = zones.size();
j["failedZones"] = projectFailedZones;
j["totalWarnings"] = totalWarn;
j["passed"] = bool(allPassed);
nlohmann::json arr = nlohmann::json::array();
for (const auto& r : rows) {
arr.push_back({{"zone", r.name},
{"creatureWarn", r.creatureWarn},
{"objectWarn", r.objectWarn},
{"questWarn", r.questWarn}});
}
j["zones"] = arr;
std::printf("%s\n", j.dump(2).c_str());
return allPassed ? 0 : 1;
}
std::printf("check-project-content: %s\n", projectDir.c_str());
std::printf(" zones : %zu (%d failed)\n",
zones.size(), projectFailedZones);
std::printf(" total warns : %d\n", totalWarn);
std::printf("\n zone creat object quest status\n");
for (const auto& r : rows) {
int rowTotal = r.creatureWarn + r.objectWarn + r.questWarn;
std::printf(" %-26s %5d %5d %5d %s\n",
r.name.substr(0, 26).c_str(),
r.creatureWarn, r.objectWarn, r.questWarn,
rowTotal == 0 ? "PASS" : "FAIL");
}
if (allPassed) {
std::printf("\n ALL ZONES PASSED\n");
return 0;
}
std::printf("\n %d zone(s) have content warnings\n",
projectFailedZones);
return 1;
feat(editor): add --check-project-refs for project-wide reference validation Project-level cross-reference checker. Walks every zone and runs the same model-path / NPC-id checks --check-zone-refs does, with per-zone breakdown: wowee_editor --check-project-refs custom_zones check-project-refs: custom_zones zones : 12 (2 failed) total missing: 5 zone obj_chk obj_miss q_chk q_miss status AshenForest 12 0 4 0 PASS BoneOasis 17 2 6 0 FAIL Stranglethorn 34 1 8 2 FAIL ... 2 zone(s) have dangling refs Per-zone columns split objects vs quests so designers see at a glance whether the issue is missing models (asset bundle drift) or NPC IDs (creature definitions out of sync with quest references). Pairs with --check-project-content (data quality) and --validate-project (binary integrity). Together the three give a complete pre-ship validation gate: --validate-project binary structure --check-project-content field plausibility --check-project-refs cross-references resolve Verified on a 2-zone project: Forest mvp-zone has 1 unresolved object placement (no Tree.m2 on disk in test cwd), Bad zone has 1 missing object → 2 zones FAIL, exit 1.
2026-05-06 19:44:28 -07:00
} else if (std::strcmp(argv[i], "--check-project-refs") == 0 && i + 1 < argc) {
// Project-level cross-reference checker. Walks every zone
// and runs the same model-path / NPC-id checks as
// --check-zone-refs. Aggregates per zone with file-level
// breakdown. Exit 1 if any zone has dangling refs.
std::string projectDir = argv[++i];
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
namespace fs = std::filesystem;
if (!fs::exists(projectDir) || !fs::is_directory(projectDir)) {
std::fprintf(stderr,
"check-project-refs: %s is not a directory\n",
projectDir.c_str());
return 1;
}
std::vector<std::string> zones;
for (const auto& entry : fs::directory_iterator(projectDir)) {
if (!entry.is_directory()) continue;
if (!fs::exists(entry.path() / "zone.json")) continue;
zones.push_back(entry.path().string());
}
std::sort(zones.begin(), zones.end());
// Same model-resolve logic as --check-zone-refs, applied
// per zone with the appropriate root list.
auto stripExt = [](const std::string& p, const char* ext) {
size_t n = std::strlen(ext);
if (p.size() >= n) {
std::string tail = p.substr(p.size() - n);
std::string lower = tail;
for (auto& c : lower) c = std::tolower(static_cast<unsigned char>(c));
if (lower == ext) return p.substr(0, p.size() - n);
}
return p;
};
struct ZoneRow { std::string name; int objCheck, objMiss, qCheck, qMiss; };
std::vector<ZoneRow> rows;
int projectFailedZones = 0;
for (const auto& zoneDir : zones) {
ZoneRow row{fs::path(zoneDir).filename().string(), 0, 0, 0, 0};
auto modelExists = [&](const std::string& path, bool isWMO) {
std::string base;
std::vector<std::string> exts;
if (isWMO) {
base = stripExt(path, ".wmo");
exts = {".wob", ".wmo"};
} else {
base = stripExt(path, ".m2");
exts = {".wom", ".m2"};
}
std::vector<std::string> roots = {
"", zoneDir + "/", "output/", "custom_zones/", "Data/"
};
for (const auto& root : roots) {
for (const auto& ext : exts) {
if (fs::exists(root + base + ext)) return true;
std::string lower = base + ext;
for (auto& c : lower) c = std::tolower(static_cast<unsigned char>(c));
if (fs::exists(root + lower)) return true;
}
}
return false;
};
wowee::editor::ObjectPlacer op;
if (op.loadFromFile(zoneDir + "/objects.json")) {
for (const auto& o : op.getObjects()) {
row.objCheck++;
bool isWMO = (o.type == wowee::editor::PlaceableType::WMO);
if (!modelExists(o.path, isWMO)) row.objMiss++;
}
}
wowee::editor::NpcSpawner sp;
wowee::editor::QuestEditor qe;
bool hasCreatures = sp.loadFromFile(zoneDir + "/creatures.json");
std::unordered_set<uint32_t> creatureIds;
if (hasCreatures) {
for (const auto& s : sp.getSpawns()) creatureIds.insert(s.id);
}
if (qe.loadFromFile(zoneDir + "/quests.json") && hasCreatures) {
for (const auto& q : qe.getQuests()) {
row.qCheck++;
bool localGiver = (q.questGiverNpcId != 0 &&
q.questGiverNpcId < 100000 &&
creatureIds.count(q.questGiverNpcId) == 0);
bool localTurn = (q.turnInNpcId != 0 &&
q.turnInNpcId < 100000 &&
q.turnInNpcId != q.questGiverNpcId &&
creatureIds.count(q.turnInNpcId) == 0);
if (localGiver) row.qMiss++;
if (localTurn) row.qMiss++;
}
}
if (row.objMiss + row.qMiss > 0) projectFailedZones++;
rows.push_back(row);
}
int allPassed = (projectFailedZones == 0);
int totalMiss = 0;
for (const auto& r : rows) totalMiss += r.objMiss + r.qMiss;
if (jsonOut) {
nlohmann::json j;
j["projectDir"] = projectDir;
j["totalZones"] = zones.size();
j["failedZones"] = projectFailedZones;
j["totalMissing"] = totalMiss;
j["passed"] = bool(allPassed);
nlohmann::json arr = nlohmann::json::array();
for (const auto& r : rows) {
arr.push_back({{"zone", r.name},
{"objectsChecked", r.objCheck},
{"objectsMissing", r.objMiss},
{"questsChecked", r.qCheck},
{"questsMissing", r.qMiss}});
}
j["zones"] = arr;
std::printf("%s\n", j.dump(2).c_str());
return allPassed ? 0 : 1;
}
std::printf("check-project-refs: %s\n", projectDir.c_str());
std::printf(" zones : %zu (%d failed)\n",
zones.size(), projectFailedZones);
std::printf(" total missing: %d\n", totalMiss);
std::printf("\n zone obj_chk obj_miss q_chk q_miss status\n");
for (const auto& r : rows) {
int rowMiss = r.objMiss + r.qMiss;
std::printf(" %-26s %5d %5d %5d %5d %s\n",
r.name.substr(0, 26).c_str(),
r.objCheck, r.objMiss, r.qCheck, r.qMiss,
rowMiss == 0 ? "PASS" : "FAIL");
}
if (allPassed) {
std::printf("\n ALL ZONES PASSED\n");
return 0;
}
std::printf("\n %d zone(s) have dangling refs\n", projectFailedZones);
return 1;
feat(editor): add --for-each-zone batch runner Shell-script-equivalent of looping over every zone in a project dir, in a single editor invocation. Substitutes '{}' in the command with each zone's path (find -exec convention): wowee_editor --for-each-zone custom_zones -- \ wowee_editor --validate-all {} wowee_editor --for-each-zone custom_zones -- \ wowee_editor --info-creatures {}/creatures.json Implementation: - Walks projectDir for child dirs containing zone.json (canonical 'is this a zone?' test the rest of the editor uses). - Sorts results so output is deterministic across runs. - Each token after '--' is shell-escaped via single-quote wrapping with embedded ' replaced by '\'' — safe against names with spaces and quotes. - {} replacement done per-token so paths with spaces don't get split. - fflush(stdout) before std::system so the [zone] header lands above the child output instead of after (parent stdout buffered, child unbuffered to terminal). - Returns failed-run count as exit code (capped at 255 for POSIX). Verified: scaffolded 2 zones, ran --info-creatures across both via for-each-zone. Output ordered correctly with [zone] headers + child output, exit 0 when all succeed.
2026-05-06 13:00:15 -07:00
} else if (std::strcmp(argv[i], "--for-each-zone") == 0 && i + 1 < argc) {
// Batch runner: enumerates zones in <projectDir> and runs the
// command after '--' for each one. '{}' in the command is
// substituted with the zone path (find -exec convention).
//
// wowee_editor --for-each-zone custom_zones -- \\
// wowee_editor --validate-all {}
//
// Returns the count of failed runs as the exit code (capped
// at 255 so the shell can still see it).
std::string projectDir = argv[++i];
// The literal '--' separates the projectDir from the command.
// Skip it; everything after is the command template.
if (i + 1 < argc && std::strcmp(argv[i + 1], "--") == 0) ++i;
if (i + 1 >= argc) {
std::fprintf(stderr,
"for-each-zone: need command after '--'\n");
return 1;
}
// Collect command tokens until end of argv. Don't try to be
// clever about quoting — just escape each token for shell
// safety using single quotes (' inside is escaped as '\\'').
std::vector<std::string> cmdTokens;
for (int k = i + 1; k < argc; ++k) cmdTokens.push_back(argv[k]);
i = argc - 1; // consume rest of argv
namespace fs = std::filesystem;
if (!fs::exists(projectDir) || !fs::is_directory(projectDir)) {
std::fprintf(stderr, "for-each-zone: %s is not a directory\n",
projectDir.c_str());
return 1;
}
// Find every child dir that contains a zone.json — that's the
// canonical 'is this a zone?' test the rest of the editor uses.
std::vector<std::string> zones;
for (const auto& entry : fs::directory_iterator(projectDir)) {
if (!entry.is_directory()) continue;
if (fs::exists(entry.path() / "zone.json")) {
zones.push_back(entry.path().string());
}
}
std::sort(zones.begin(), zones.end());
if (zones.empty()) {
std::fprintf(stderr, "for-each-zone: no zones found in %s\n",
projectDir.c_str());
return 1;
}
auto shellEscape = [](const std::string& s) {
std::string out = "'";
for (char c : s) {
if (c == '\'') out += "'\\''";
else out += c;
}
out += "'";
return out;
};
int failed = 0;
for (const auto& zone : zones) {
std::string cmd;
for (size_t k = 0; k < cmdTokens.size(); ++k) {
if (k > 0) cmd += " ";
std::string token = cmdTokens[k];
// Replace {} with zone path (every occurrence).
size_t pos;
while ((pos = token.find("{}")) != std::string::npos) {
token.replace(pos, 2, zone);
}
cmd += shellEscape(token);
}
std::printf("[%s]\n", zone.c_str());
// Flush before std::system so the header lands above the
// child's output rather than after (parent stdout is line-
// buffered, child writes go straight to the terminal).
std::fflush(stdout);
int rc = std::system(cmd.c_str());
if (rc != 0) {
failed++;
std::fprintf(stderr,
"for-each-zone: command exited %d for %s\n",
rc, zone.c_str());
}
}
std::printf("\nfor-each-zone: %zu zones, %d failed\n",
zones.size(), failed);
return failed > 255 ? 255 : failed;
feat(editor): add --for-each-tile for per-tile batch operations Per-tile batch runner. Pairs with --for-each-zone (project-level tile iteration is too coarse for tile-level commands like --build-woc, --validate-whm, --info-whm). wowee_editor --for-each-tile custom_zones/MyZone -- \ wowee_editor --build-woc {} [custom_zones/MyZone/MyZone_30_30 (30, 30)] WOC built: custom_zones/MyZone/MyZone_30_30.woc (32768 triangles, ...) [custom_zones/MyZone/MyZone_31_30 (31, 30)] WOC built: custom_zones/MyZone/MyZone_31_30.woc (32768 triangles, ...) for-each-tile: 2 tiles, 0 failed The {} substitution receives the tile-base path (zoneDir/mapName_TX_TY) which is the form most tile-level commands accept. Sorts tiles by (tx, ty) so output ordering is deterministic. Use cases: - Build WOC for every tile in one shot after editing terrain - Validate WHM headers across all tiles - Export per-tile previews via --export-whm-obj - Per-tile data dump via --info-whm Same shell-escaping + cmd-substitution machinery as --for-each-zone (safe against names with spaces and quotes). Returns failed-run count as exit code (capped at 255). Verified on a 2-tile zone running --build-woc per tile: both tiles built correctly, exit 0.
2026-05-06 18:11:54 -07:00
} else if (std::strcmp(argv[i], "--for-each-tile") == 0 && i + 1 < argc) {
// Per-tile batch runner. --for-each-zone iterates zones in
// a project; this iterates tiles within a zone. The '{}' in
// the command template is replaced with the tile-base path
// (zoneDir/mapName_TX_TY) — the form most tile-level
// editor commands take.
//
// wowee_editor --for-each-tile MyZone -- \\
// wowee_editor --build-woc {}
// wowee_editor --for-each-tile MyZone -- \\
// wowee_editor --validate-whm {}
std::string zoneDir = argv[++i];
if (i + 1 < argc && std::strcmp(argv[i + 1], "--") == 0) ++i;
if (i + 1 >= argc) {
std::fprintf(stderr,
"for-each-tile: need command after '--'\n");
return 1;
}
std::vector<std::string> cmdTokens;
for (int k = i + 1; k < argc; ++k) cmdTokens.push_back(argv[k]);
i = argc - 1;
namespace fs = std::filesystem;
std::string manifestPath = zoneDir + "/zone.json";
if (!fs::exists(manifestPath)) {
std::fprintf(stderr,
"for-each-tile: %s has no zone.json\n", zoneDir.c_str());
return 1;
}
wowee::editor::ZoneManifest zm;
if (!zm.load(manifestPath)) {
std::fprintf(stderr, "for-each-tile: parse failed\n");
return 1;
}
if (zm.tiles.empty()) {
std::fprintf(stderr, "for-each-tile: zone has no tiles\n");
return 1;
}
// Same shell-escape + cmd-substitution as --for-each-zone.
auto shellEscape = [](const std::string& s) {
std::string out = "'";
for (char c : s) {
if (c == '\'') out += "'\\''";
else out += c;
}
out += "'";
return out;
};
int failed = 0;
// Sort tiles so order is deterministic across runs.
auto tiles = zm.tiles;
std::sort(tiles.begin(), tiles.end());
for (const auto& [tx, ty] : tiles) {
std::string tileBase = zoneDir + "/" + zm.mapName + "_" +
std::to_string(tx) + "_" + std::to_string(ty);
std::string cmd;
for (size_t k = 0; k < cmdTokens.size(); ++k) {
if (k > 0) cmd += " ";
std::string token = cmdTokens[k];
size_t pos;
while ((pos = token.find("{}")) != std::string::npos) {
token.replace(pos, 2, tileBase);
}
cmd += shellEscape(token);
}
std::printf("[%s (%d, %d)]\n", tileBase.c_str(), tx, ty);
std::fflush(stdout);
int rc = std::system(cmd.c_str());
if (rc != 0) {
failed++;
std::fprintf(stderr,
"for-each-tile: command exited %d for (%d, %d)\n",
rc, tx, ty);
}
}
std::printf("\nfor-each-tile: %zu tiles, %d failed\n",
tiles.size(), failed);
return failed > 255 ? 255 : failed;
feat(editor): --version CLI flag shows editor version and format info
2026-05-05 11:53:12 -07:00
} else if (std::strcmp(argv[i], "--version") == 0 || std::strcmp(argv[i], "-v") == 0) {
fix(editor): CLI output visible on stdout (was silent LOG_INFO) --help, --version, and --list-zones now print to stdout via printf instead of LOG_INFO which writes to log file only. Users running CLI commands would see no output at all — critical first-impression bug for new users. Also updated --version format list to include WOC.
2026-05-05 16:54:03 -07:00
std::printf("Wowee World Editor v1.0.0\n");
std::printf("Open formats: WOT/WHM/WOM/WOB/WOC/WCP + PNG/JSON (all novel)\n");
std::printf("By Kelsi Davis\n");
feat(editor): --version CLI flag shows editor version and format info
2026-05-05 11:53:12 -07:00
return 0;
feat(editor): add --list-commands and --gen-completion for shell ergonomics The CLI surface is now 103 commands. Tab completion is no longer a nice-to-have: source <(wowee_editor --gen-completion bash) # one-time setup wowee_editor --info-<TAB> # all info-* offered Two complementary commands: --list-commands: parses printUsage's own output to extract every '--flag' it documents, dedupes, sorts. Auto-tracks new commands as they're added (no parallel list to maintain). --gen-completion bash|zsh: emits a completion script that re-execs --list-commands at completion time, so newly-added flags light up without regenerating the script. Bash version uses compgen with per-session caching in ; zsh version uses the _arguments + compdef framework. Both completion scripts also fall back to file-path completion in arg slots (the common case for --info-/--validate-/--export- commands that take a path). Verified: - --list-commands: 103 unique flags emitted alphabetically - --gen-completion bash: well-formed script using full binary path for the cached --list-commands invocation - --gen-completion zsh: same shape, _arguments-based - Unknown shell: clear error + exit 1
2026-05-06 13:59:54 -07:00
} else if (std::strcmp(argv[i], "--list-commands") == 0) {
// Capture printUsage's stdout and grep for '--flag' tokens at
// the start of each line. This auto-tracks the help text as
// commands are added — no parallel list to maintain. Result
// is a sorted, deduped, one-per-line list of recognized flags.
FILE* old = stdout;
// Temp file lets us read printUsage's output back. fmemopen
// would be cleaner but isn't available on Windows; tmpfile is
// portable.
FILE* tmp = std::tmpfile();
if (!tmp) { std::fprintf(stderr, "list-commands: tmpfile failed\n"); return 1; }
stdout = tmp;
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
wowee::editor::cli::printUsage(argv[0]);
feat(editor): add --list-commands and --gen-completion for shell ergonomics The CLI surface is now 103 commands. Tab completion is no longer a nice-to-have: source <(wowee_editor --gen-completion bash) # one-time setup wowee_editor --info-<TAB> # all info-* offered Two complementary commands: --list-commands: parses printUsage's own output to extract every '--flag' it documents, dedupes, sorts. Auto-tracks new commands as they're added (no parallel list to maintain). --gen-completion bash|zsh: emits a completion script that re-execs --list-commands at completion time, so newly-added flags light up without regenerating the script. Bash version uses compgen with per-session caching in ; zsh version uses the _arguments + compdef framework. Both completion scripts also fall back to file-path completion in arg slots (the common case for --info-/--validate-/--export- commands that take a path). Verified: - --list-commands: 103 unique flags emitted alphabetically - --gen-completion bash: well-formed script using full binary path for the cached --list-commands invocation - --gen-completion zsh: same shape, _arguments-based - Unknown shell: clear error + exit 1
2026-05-06 13:59:54 -07:00
stdout = old;
std::fseek(tmp, 0, SEEK_SET);
std::set<std::string> commands;
char line[512];
while (std::fgets(line, sizeof(line), tmp)) {
// Match leading whitespace then '--' then [a-z-]+
const char* p = line;
while (*p == ' ' || *p == '\t') ++p;
if (p[0] != '-' || p[1] != '-') continue;
std::string flag;
while (*p && (std::isalnum(static_cast<unsigned char>(*p)) ||
*p == '-' || *p == '_')) {
flag += *p++;
}
if (flag.size() > 2) commands.insert(flag);
}
std::fclose(tmp);
// Always include the meta-flags that printUsage describes
// alongside others (-h/-v aliases) since the regex above only
// captures double-dash forms.
commands.insert("--help");
commands.insert("--version");
for (const auto& c : commands) std::printf("%s\n", c.c_str());
return 0;
feat(editor): add --info-cli-stats meta command for surface tracking 130 commands and counting — surface inspection has graduated from 'nice to have' to 'necessary to plan'. This drops a per-category breakdown: wowee_editor --info-cli-stats CLI surface stats total commands : 130 longest flag : 24 chars Categories (by verb prefix, sorted by count): --info 33 --export 15 --list 12 --validate 11 --diff 8 --add 6 --remove 5 --convert 5 --bake 3 --migrate 3 --clone 3 ... Pulls the command list via the same printUsage-parser as --list-commands so it auto-tracks new flags. Buckets by the verb prefix (text between '--' and the next '-') so '--info-zone-tree' counts under 'info'. JSON mode emits the histogram as an object for dashboard consumption. Useful for spotting category imbalances ('we have 33 inspectors but only 5 add commands — should consider more authoring CRUD?'), tracking growth over releases, and planning where to invest.
2026-05-06 15:21:24 -07:00
} else if (std::strcmp(argv[i], "--info-cli-stats") == 0) {
// Meta-stats on the CLI surface: total command count + per-
// category breakdown by prefix verb (--info-*, --validate-*,
// --diff-*, etc.). Useful for tracking growth over time and
// spotting category imbalances.
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
// Re-use --list-commands' parser. Capture printUsage stdout.
FILE* old = stdout;
FILE* tmp = std::tmpfile();
if (!tmp) { std::fprintf(stderr, "info-cli-stats: tmpfile failed\n"); return 1; }
stdout = tmp;
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
wowee::editor::cli::printUsage(argv[0]);
feat(editor): add --info-cli-stats meta command for surface tracking 130 commands and counting — surface inspection has graduated from 'nice to have' to 'necessary to plan'. This drops a per-category breakdown: wowee_editor --info-cli-stats CLI surface stats total commands : 130 longest flag : 24 chars Categories (by verb prefix, sorted by count): --info 33 --export 15 --list 12 --validate 11 --diff 8 --add 6 --remove 5 --convert 5 --bake 3 --migrate 3 --clone 3 ... Pulls the command list via the same printUsage-parser as --list-commands so it auto-tracks new flags. Buckets by the verb prefix (text between '--' and the next '-') so '--info-zone-tree' counts under 'info'. JSON mode emits the histogram as an object for dashboard consumption. Useful for spotting category imbalances ('we have 33 inspectors but only 5 add commands — should consider more authoring CRUD?'), tracking growth over releases, and planning where to invest.
2026-05-06 15:21:24 -07:00
stdout = old;
std::fseek(tmp, 0, SEEK_SET);
std::set<std::string> commands;
char line[512];
while (std::fgets(line, sizeof(line), tmp)) {
const char* p = line;
while (*p == ' ' || *p == '\t') ++p;
if (p[0] != '-' || p[1] != '-') continue;
std::string flag;
while (*p && (std::isalnum(static_cast<unsigned char>(*p)) ||
*p == '-' || *p == '_')) { flag += *p++; }
if (flag.size() > 2) commands.insert(flag);
}
std::fclose(tmp);
commands.insert("--help");
commands.insert("--version");
// Bucket by category — verb is the second token after '--',
// up to the next dash. So '--info-zone-tree' -> 'info'.
std::map<std::string, int> byCategory;
int maxLen = 0;
for (const auto& c : commands) {
if (static_cast<int>(c.size()) > maxLen) maxLen = static_cast<int>(c.size());
size_t verbStart = 2; // skip '--'
size_t verbEnd = c.find('-', verbStart);
std::string verb = (verbEnd == std::string::npos)
? c.substr(verbStart)
: c.substr(verbStart, verbEnd - verbStart);
byCategory[verb]++;
}
if (jsonOut) {
nlohmann::json j;
j["totalCommands"] = commands.size();
j["maxFlagLength"] = maxLen;
nlohmann::json cats = nlohmann::json::object();
for (const auto& [v, c] : byCategory) cats[v] = c;
j["byCategory"] = cats;
std::printf("%s\n", j.dump(2).c_str());
return 0;
}
std::printf("CLI surface stats\n");
std::printf(" total commands : %zu\n", commands.size());
std::printf(" longest flag : %d chars\n", maxLen);
std::printf("\n Categories (by verb prefix, sorted by count):\n");
// Sort by count descending for the table.
std::vector<std::pair<std::string, int>> sorted(
byCategory.begin(), byCategory.end());
std::sort(sorted.begin(), sorted.end(),
[](const auto& a, const auto& b) {
return a.second > b.second;
});
for (const auto& [verb, count] : sorted) {
std::printf(" --%-12s %4d\n", verb.c_str(), count);
}
return 0;
feat(editor): add --info-cli-categories grouped command discovery Where --info-cli-stats just counts per category, this lists every command in each category. Categories sorted by count descending, commands within each alphabetically. Header shows total count for context. Useful for "I know I want to gen something but what shapes/textures are available?" — opens a clear view into the procedural toolset that --help's flat dump buries. With 250 commands today the categorization makes the surface tractable.
2026-05-07 17:43:58 -07:00
} else if (std::strcmp(argv[i], "--info-cli-categories") == 0) {
// Discovery view of every CLI flag grouped by verb prefix.
// Where --info-cli-stats just counts per category, this
// lists every command in each category — handy for "I
// know I want to gen something but what shapes/textures
// are available?"
FILE* old = stdout;
FILE* tmp = std::tmpfile();
if (!tmp) {
std::fprintf(stderr, "info-cli-categories: tmpfile failed\n");
return 1;
}
stdout = tmp;
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
wowee::editor::cli::printUsage(argv[0]);
feat(editor): add --info-cli-categories grouped command discovery Where --info-cli-stats just counts per category, this lists every command in each category. Categories sorted by count descending, commands within each alphabetically. Header shows total count for context. Useful for "I know I want to gen something but what shapes/textures are available?" — opens a clear view into the procedural toolset that --help's flat dump buries. With 250 commands today the categorization makes the surface tractable.
2026-05-07 17:43:58 -07:00
stdout = old;
std::fseek(tmp, 0, SEEK_SET);
std::set<std::string> commands;
char line[512];
while (std::fgets(line, sizeof(line), tmp)) {
const char* p = line;
while (*p == ' ' || *p == '\t') ++p;
if (p[0] != '-' || p[1] != '-') continue;
std::string flag;
while (*p && (std::isalnum(static_cast<unsigned char>(*p)) ||
*p == '-' || *p == '_')) { flag += *p++; }
if (flag.size() > 2) commands.insert(flag);
}
std::fclose(tmp);
commands.insert("--help");
commands.insert("--version");
std::map<std::string, std::vector<std::string>> byCategory;
for (const auto& c : commands) {
size_t verbStart = 2;
size_t verbEnd = c.find('-', verbStart);
std::string verb = (verbEnd == std::string::npos)
? c.substr(verbStart)
: c.substr(verbStart, verbEnd - verbStart);
byCategory[verb].push_back(c);
}
std::printf("CLI commands by category (%zu total):\n\n",
commands.size());
// Sort categories by count descending, commands within
// each alphabetically.
std::vector<std::pair<std::string, std::vector<std::string>>> sorted(
byCategory.begin(), byCategory.end());
std::sort(sorted.begin(), sorted.end(),
[](const auto& a, const auto& b) {
if (a.second.size() != b.second.size())
return a.second.size() > b.second.size();
return a.first < b.first;
});
for (const auto& [verb, cmds] : sorted) {
std::printf("--%s (%zu):\n", verb.c_str(), cmds.size());
for (const auto& c : cmds) {
std::printf(" %s\n", c.c_str());
}
std::printf("\n");
}
return 0;
feat(editor): add --info-cli-help for substring searching the help text 130+ commands. 'Is there a thing for X?' is a common question. Scrolling --help to find out is slow. This searches: wowee_editor --info-cli-help quest --add-quest <zoneDir> <title> [giverId] [turnInId] [xp] [level] Append one quest to <zoneDir>/quests.json and exit --add-quest-objective <zoneDir> <questIdx> <kill|collect|...> ... Append one objective to a quest by index --remove-quest-objective <zoneDir> <questIdx> <objIdx> Remove the objective at given 0-based index from a quest --clone-quest <zoneDir> <questIdx> [newTitle] Duplicate a quest (with all objectives + rewards) ... 32 line(s) matched 'quest' Case-insensitive substring match. Continuation lines (the indented description right after a flag) are emitted along with their flag line for context. Match-count summary on stderr so it doesn't contaminate piped output. Pairs with --list-commands (full list) and --info-cli-stats (counts by category). Three meta commands now cover the discovery loop: 'how many?' (--info-cli-stats), 'which ones?' (--list-commands), 'what does X do?' (--info-cli-help X).
2026-05-06 15:43:02 -07:00
} else if (std::strcmp(argv[i], "--info-cli-help") == 0 && i + 1 < argc) {
// Substring search through the help text. With 130+ commands,
// 'is there a thing for X?' is a common ask — this answers it
// without making the user scroll the full --help output:
//
// wowee_editor --info-cli-help quest
// wowee_editor --info-cli-help validate
// wowee_editor --info-cli-help glb
std::string pattern = argv[++i];
// Lowercase the pattern for case-insensitive match.
std::string patLower = pattern;
for (auto& c : patLower) c = std::tolower(static_cast<unsigned char>(c));
// Capture printUsage stdout, walk line-by-line, print every
// line containing the pattern (case-insensitive). Continuation
// lines (the indented description on the line after a flag)
// are emitted along with the flag line for context.
FILE* old = stdout;
FILE* tmp = std::tmpfile();
if (!tmp) {
std::fprintf(stderr, "info-cli-help: tmpfile failed\n"); return 1;
}
stdout = tmp;
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
wowee::editor::cli::printUsage(argv[0]);
feat(editor): add --info-cli-help for substring searching the help text 130+ commands. 'Is there a thing for X?' is a common question. Scrolling --help to find out is slow. This searches: wowee_editor --info-cli-help quest --add-quest <zoneDir> <title> [giverId] [turnInId] [xp] [level] Append one quest to <zoneDir>/quests.json and exit --add-quest-objective <zoneDir> <questIdx> <kill|collect|...> ... Append one objective to a quest by index --remove-quest-objective <zoneDir> <questIdx> <objIdx> Remove the objective at given 0-based index from a quest --clone-quest <zoneDir> <questIdx> [newTitle] Duplicate a quest (with all objectives + rewards) ... 32 line(s) matched 'quest' Case-insensitive substring match. Continuation lines (the indented description right after a flag) are emitted along with their flag line for context. Match-count summary on stderr so it doesn't contaminate piped output. Pairs with --list-commands (full list) and --info-cli-stats (counts by category). Three meta commands now cover the discovery loop: 'how many?' (--info-cli-stats), 'which ones?' (--list-commands), 'what does X do?' (--info-cli-help X).
2026-05-06 15:43:02 -07:00
stdout = old;
std::fseek(tmp, 0, SEEK_SET);
std::vector<std::string> lines;
char buf[1024];
while (std::fgets(buf, sizeof(buf), tmp)) {
std::string s = buf;
if (!s.empty() && s.back() == '\n') s.pop_back();
lines.push_back(std::move(s));
}
std::fclose(tmp);
int matches = 0;
for (size_t k = 0; k < lines.size(); ++k) {
std::string lower = lines[k];
for (auto& c : lower) c = std::tolower(static_cast<unsigned char>(c));
if (lower.find(patLower) == std::string::npos) continue;
std::printf("%s\n", lines[k].c_str());
// Look ahead for a continuation line (indented and not
// starting with '--'). Print it for context.
if (k + 1 < lines.size()) {
const auto& next = lines[k + 1];
if (!next.empty() && next[0] == ' ' &&
next.find("--") == std::string::npos) {
std::printf("%s\n", next.c_str());
}
}
matches++;
}
if (matches == 0) {
std::fprintf(stderr, "info-cli-help: no matches for '%s'\n",
pattern.c_str());
return 1;
}
std::fprintf(stderr, "\n%d line(s) matched '%s'\n", matches, pattern.c_str());
return 0;
feat(editor): add --validate-cli-help self-check for documentation drift Self-check that every flag in kArgRequired (the master list of commands needing positional args) appears in the help text emitted by printUsage. Catches drift where a handler+arg-check pair gets added but the help line is forgotten: wowee_editor --validate-cli-help CLI help self-check kArgRequired entries : 126 PASSED — every kArgRequired flag is documented If it ever fails, the missing flags are listed: FAILED — 2 flag(s) missing from help text: - --new-thing-i-forgot-to-document - --another-undocumented-flag CI integration: add this to the test target so a PR that adds a new command without docs can't merge. The --info-cli-stats command gives the surface-size view; this gives the surface-completeness view. Verified: ran on the current binary (126 kArgRequired entries), PASSED — every flag is documented.
2026-05-06 17:04:57 -07:00
} else if (std::strcmp(argv[i], "--validate-cli-help") == 0) {
// Self-check: every flag we declare in kArgRequired (the list
// of commands needing positional args) must appear in the
// help text printUsage emits. Catches drift where someone
// adds a handler + argument check but forgets the help line.
bool jsonOut = (i + 1 < argc &&
std::strcmp(argv[i + 1], "--json") == 0);
if (jsonOut) i++;
// Capture printUsage's stdout.
FILE* old = stdout;
FILE* tmp = std::tmpfile();
if (!tmp) { std::fprintf(stderr, "validate-cli-help: tmpfile failed\n"); return 1; }
stdout = tmp;
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
wowee::editor::cli::printUsage(argv[0]);
feat(editor): add --validate-cli-help self-check for documentation drift Self-check that every flag in kArgRequired (the master list of commands needing positional args) appears in the help text emitted by printUsage. Catches drift where a handler+arg-check pair gets added but the help line is forgotten: wowee_editor --validate-cli-help CLI help self-check kArgRequired entries : 126 PASSED — every kArgRequired flag is documented If it ever fails, the missing flags are listed: FAILED — 2 flag(s) missing from help text: - --new-thing-i-forgot-to-document - --another-undocumented-flag CI integration: add this to the test target so a PR that adds a new command without docs can't merge. The --info-cli-stats command gives the surface-size view; this gives the surface-completeness view. Verified: ran on the current binary (126 kArgRequired entries), PASSED — every flag is documented.
2026-05-06 17:04:57 -07:00
stdout = old;
std::fseek(tmp, 0, SEEK_SET);
std::string helpText;
char chunk[1024];
while (std::fgets(chunk, sizeof(chunk), tmp)) helpText += chunk;
std::fclose(tmp);
// Walk kArgRequired and check each appears in the help.
std::vector<std::string> missing;
for (const char* opt : kArgRequired) {
if (helpText.find(opt) == std::string::npos) {
missing.push_back(opt);
}
}
if (jsonOut) {
nlohmann::json j;
j["totalArgRequired"] = sizeof(kArgRequired) / sizeof(kArgRequired[0]);
j["missing"] = missing;
j["passed"] = missing.empty();
std::printf("%s\n", j.dump(2).c_str());
return missing.empty() ? 0 : 1;
}
std::printf("CLI help self-check\n");
std::printf(" kArgRequired entries : %zu\n",
sizeof(kArgRequired) / sizeof(kArgRequired[0]));
if (missing.empty()) {
std::printf(" PASSED — every kArgRequired flag is documented\n");
return 0;
}
std::printf(" FAILED — %zu flag(s) missing from help text:\n", missing.size());
for (const auto& m : missing) std::printf(" - %s\n", m.c_str());
return 1;
feat(editor): add --list-commands and --gen-completion for shell ergonomics The CLI surface is now 103 commands. Tab completion is no longer a nice-to-have: source <(wowee_editor --gen-completion bash) # one-time setup wowee_editor --info-<TAB> # all info-* offered Two complementary commands: --list-commands: parses printUsage's own output to extract every '--flag' it documents, dedupes, sorts. Auto-tracks new commands as they're added (no parallel list to maintain). --gen-completion bash|zsh: emits a completion script that re-execs --list-commands at completion time, so newly-added flags light up without regenerating the script. Bash version uses compgen with per-session caching in ; zsh version uses the _arguments + compdef framework. Both completion scripts also fall back to file-path completion in arg slots (the common case for --info-/--validate-/--export- commands that take a path). Verified: - --list-commands: 103 unique flags emitted alphabetically - --gen-completion bash: well-formed script using full binary path for the cached --list-commands invocation - --gen-completion zsh: same shape, _arguments-based - Unknown shell: clear error + exit 1
2026-05-06 13:59:54 -07:00
} else if (std::strcmp(argv[i], "--gen-completion") == 0 && i + 1 < argc) {
// Emit a bash or zsh completion script. Re-execs the editor's
// own --list-commands at completion time so newly-added flags
// light up automatically without regenerating the script.
std::string shell = argv[++i];
if (shell != "bash" && shell != "zsh") {
std::fprintf(stderr,
"gen-completion: shell must be 'bash' or 'zsh', got '%s'\n",
shell.c_str());
return 1;
}
// Use argv[0] as the binary name in the completion so it
// works whether the user installed it as 'wowee_editor' or
// a custom alias. Strip directory components for the
// completion-name registration (bash 'complete -F' expects
// a basename).
std::string self = argv[0];
auto slash = self.find_last_of('/');
std::string baseName = (slash != std::string::npos)
? self.substr(slash + 1)
: self;
if (shell == "bash") {
std::printf(
"# wowee_editor bash completion — source from ~/.bashrc:\n"
"# source <(%s --gen-completion bash)\n"
"_wowee_editor_complete() {\n"
" local cur prev cmds\n"
" COMPREPLY=()\n"
" cur=\"${COMP_WORDS[COMP_CWORD]}\"\n"
" prev=\"${COMP_WORDS[COMP_CWORD-1]}\"\n"
" # Cache the command list per shell session.\n"
" if [[ -z \"$_WOWEE_EDITOR_CMDS\" ]]; then\n"
" _WOWEE_EDITOR_CMDS=$(%s --list-commands 2>/dev/null)\n"
" fi\n"
" if [[ \"$cur\" == --* ]]; then\n"
" COMPREPLY=( $(compgen -W \"$_WOWEE_EDITOR_CMDS\" -- \"$cur\") )\n"
" return 0\n"
" fi\n"
" # Default: complete file paths for arg slots.\n"
" COMPREPLY=( $(compgen -f -- \"$cur\") )\n"
"}\n"
"complete -F _wowee_editor_complete %s\n",
self.c_str(), self.c_str(), baseName.c_str());
} else {
// zsh — simpler descriptor-based completion.
std::printf(
"# wowee_editor zsh completion — source from ~/.zshrc:\n"
"# source <(%s --gen-completion zsh)\n"
"_wowee_editor_complete() {\n"
" local -a cmds\n"
" if [[ -z \"$_WOWEE_EDITOR_CMDS\" ]]; then\n"
" export _WOWEE_EDITOR_CMDS=$(%s --list-commands 2>/dev/null)\n"
" fi\n"
" cmds=( ${(f)_WOWEE_EDITOR_CMDS} )\n"
" _arguments \"*: :($cmds)\"\n"
"}\n"
"compdef _wowee_editor_complete %s\n",
self.c_str(), self.c_str(), baseName.c_str());
}
return 0;
feat(editor): add standalone world editor (rough/WIP) Standalone wowee_editor tool for creating custom WoW zones. This is a rough initial implementation — many features work but M2/WMO rendering still has issues (frame sync, texture layout transitions) and needs further polish. Terrain: - Create new blank terrain with 10 biome types (Grassland, Forest, Jungle, Desert, Barrens, Snow, Swamp, Rocky, Beach, Volcanic) - Load existing ADT tiles from extracted game data - Sculpt brushes: Raise, Lower, Smooth, Flatten, Level - Chunk edge stitching prevents seams between tiles - Undo/redo (100-deep stack, Ctrl+Z/Ctrl+Shift+Z) - Save to WoW ADT/WDT format Texture Painting: - Paint/Erase/Replace Base modes - Full tileset texture browser (1285 textures from manifest) - Per-zone directory filtering and search - Alpha map editing with 4-layer limit (auto-replaces weakest) Object Placement: - M2 and WMO model placement with full manifest browser (11k M2s, 2k WMOs) - M2Renderer + WMORenderer integrated (loads .skin files for WotLK) - Ghost preview follows cursor before placing - Ctrl+click selection, right-click context menu - Transform gizmo (Move/Rotate/Scale with axis constraints) - Position/rotation/scale editing in properties panel NPC/Monster System: - 631 creature presets scanned from manifest, categorized (Critters, Beasts, Humanoids, Undead, Demons, etc.) - Stats editor: level, health, mana, damage, armor, faction - Behavior: Stationary, Patrol, Wander, Scripted - Aggro/leash radius, respawn time, flags (hostile/vendor/etc.) - Save creature spawns to JSON Water: - Place water at configurable height per chunk - Liquid types: Water, Ocean, Magma, Slime - Rendered as translucent colored quads - Saved in ADT MH2O format Infrastructure: - Free-fly camera (WASD/QE, right-drag look, scroll speed) - 5-mode toolbar: Sculpt | Paint | Objects | Water | NPCs - Asset browser indexes full manifest on startup - Editor water/marker shaders (pos+color vertex format) - forceNoCull added to M2Renderer for editor use - AssetManifest::getEntries() and AssetManager::getManifest() exposed Known issues: - M2/WMO rendering may not display on first placement (frame index sync between update/render was misaligned — now fixed but untested end-to-end) - Validation layer errors on shutdown (resource cleanup ordering) - Object placement on steep terrain can miss raycast - No undo for texture painting or object placement yet
2026-05-05 03:47:03 -07:00
} else if (std::strcmp(argv[i], "--help") == 0 || std::strcmp(argv[i], "-h") == 0) {
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
wowee::editor::cli::printUsage(argv[0]);
feat(editor): add standalone world editor (rough/WIP) Standalone wowee_editor tool for creating custom WoW zones. This is a rough initial implementation — many features work but M2/WMO rendering still has issues (frame sync, texture layout transitions) and needs further polish. Terrain: - Create new blank terrain with 10 biome types (Grassland, Forest, Jungle, Desert, Barrens, Snow, Swamp, Rocky, Beach, Volcanic) - Load existing ADT tiles from extracted game data - Sculpt brushes: Raise, Lower, Smooth, Flatten, Level - Chunk edge stitching prevents seams between tiles - Undo/redo (100-deep stack, Ctrl+Z/Ctrl+Shift+Z) - Save to WoW ADT/WDT format Texture Painting: - Paint/Erase/Replace Base modes - Full tileset texture browser (1285 textures from manifest) - Per-zone directory filtering and search - Alpha map editing with 4-layer limit (auto-replaces weakest) Object Placement: - M2 and WMO model placement with full manifest browser (11k M2s, 2k WMOs) - M2Renderer + WMORenderer integrated (loads .skin files for WotLK) - Ghost preview follows cursor before placing - Ctrl+click selection, right-click context menu - Transform gizmo (Move/Rotate/Scale with axis constraints) - Position/rotation/scale editing in properties panel NPC/Monster System: - 631 creature presets scanned from manifest, categorized (Critters, Beasts, Humanoids, Undead, Demons, etc.) - Stats editor: level, health, mana, damage, armor, faction - Behavior: Stationary, Patrol, Wander, Scripted - Aggro/leash radius, respawn time, flags (hostile/vendor/etc.) - Save creature spawns to JSON Water: - Place water at configurable height per chunk - Liquid types: Water, Ocean, Magma, Slime - Rendered as translucent colored quads - Saved in ADT MH2O format Infrastructure: - Free-fly camera (WASD/QE, right-drag look, scroll speed) - 5-mode toolbar: Sculpt | Paint | Objects | Water | NPCs - Asset browser indexes full manifest on startup - Editor water/marker shaders (pos+color vertex format) - forceNoCull added to M2Renderer for editor use - AssetManifest::getEntries() and AssetManager::getManifest() exposed Known issues: - M2/WMO rendering may not display on first placement (frame index sync between update/render was misaligned — now fixed but untested end-to-end) - Validation layer errors on shutdown (resource cleanup ordering) - Object placement on steep terrain can miss raycast - No undo for texture painting or object placement yet
2026-05-05 03:47:03 -07:00
return 0;
}
}
feat: complete client integration for all 6 open formats - Wire WOB buildings into WMO render pipeline (loads→converts→renders) - Implement JSON DBC loading in DBCFile::loadJSON() with nlohmann/json - Wire JSON DBC override into AssetManager (custom_zones/output scan) - Add WMO→WOB conversion with full geometry (fromWMO) - Replace placeholder WOB export with real WMO→WOB conversion in editor - Add --convert-wmo CLI flag for batch WMO→WOB conversion - Store discovered custom zones on Renderer with getCustomZones() accessor - Add isCustomZone_ member to TerrainManager All 6 Blizzard format replacements now fully load in the client: ADT→WOT/WHM, WDT→zone.json, BLP→PNG, DBC→JSON, M2→WOM, WMO→WOB
2026-05-05 12:41:19 -07:00
feat(editor): add standalone world editor (rough/WIP) Standalone wowee_editor tool for creating custom WoW zones. This is a rough initial implementation — many features work but M2/WMO rendering still has issues (frame sync, texture layout transitions) and needs further polish. Terrain: - Create new blank terrain with 10 biome types (Grassland, Forest, Jungle, Desert, Barrens, Snow, Swamp, Rocky, Beach, Volcanic) - Load existing ADT tiles from extracted game data - Sculpt brushes: Raise, Lower, Smooth, Flatten, Level - Chunk edge stitching prevents seams between tiles - Undo/redo (100-deep stack, Ctrl+Z/Ctrl+Shift+Z) - Save to WoW ADT/WDT format Texture Painting: - Paint/Erase/Replace Base modes - Full tileset texture browser (1285 textures from manifest) - Per-zone directory filtering and search - Alpha map editing with 4-layer limit (auto-replaces weakest) Object Placement: - M2 and WMO model placement with full manifest browser (11k M2s, 2k WMOs) - M2Renderer + WMORenderer integrated (loads .skin files for WotLK) - Ghost preview follows cursor before placing - Ctrl+click selection, right-click context menu - Transform gizmo (Move/Rotate/Scale with axis constraints) - Position/rotation/scale editing in properties panel NPC/Monster System: - 631 creature presets scanned from manifest, categorized (Critters, Beasts, Humanoids, Undead, Demons, etc.) - Stats editor: level, health, mana, damage, armor, faction - Behavior: Stationary, Patrol, Wander, Scripted - Aggro/leash radius, respawn time, flags (hostile/vendor/etc.) - Save creature spawns to JSON Water: - Place water at configurable height per chunk - Liquid types: Water, Ocean, Magma, Slime - Rendered as translucent colored quads - Saved in ADT MH2O format Infrastructure: - Free-fly camera (WASD/QE, right-drag look, scroll speed) - 5-mode toolbar: Sculpt | Paint | Objects | Water | NPCs - Asset browser indexes full manifest on startup - Editor water/marker shaders (pos+color vertex format) - forceNoCull added to M2Renderer for editor use - AssetManifest::getEntries() and AssetManager::getManifest() exposed Known issues: - M2/WMO rendering may not display on first placement (frame index sync between update/render was misaligned — now fixed but untested end-to-end) - Validation layer errors on shutdown (resource cleanup ordering) - Object placement on steep terrain can miss raycast - No undo for texture painting or object placement yet
2026-05-05 03:47:03 -07:00
if (dataPath.empty()) {
dataPath = "Data";
LOG_INFO("No --data path specified, using default: ", dataPath);
}
wowee::editor::EditorApp app;
if (!app.initialize(dataPath)) {
LOG_ERROR("Failed to initialize editor");
return 1;
}
if (!adtMap.empty()) {
app.loadADT(adtMap, adtX, adtY);
}
app.run();
app.shutdown();
return 0;
}
Reference in a new issue Copy permalink