mirror of
https://github.com/Kelsidavis/WoWee.git
synced 2026-05-07 09:33:51 +00:00
a0480dc3a2
Mirrors the other --info-* family inspectors. Accepts either a zone directory or the zone.json path directly. Prints every manifest field: name, mapId, biome, baseHeight, tiles, flags, audio config. Useful when diffing two zones or auditing the audio/flag setup before packing.
856 lines
44 KiB
C++
856 lines
44 KiB
C++
#include "editor_app.hpp"
|
|
#include "content_pack.hpp"
|
|
#include "npc_spawner.hpp"
|
|
#include "object_placer.hpp"
|
|
#include "quest_editor.hpp"
|
|
#include "wowee_terrain.hpp"
|
|
#include "zone_manifest.hpp"
|
|
#include "terrain_editor.hpp"
|
|
#include "terrain_biomes.hpp"
|
|
#include <filesystem>
|
|
#include "pipeline/wowee_model.hpp"
|
|
#include "pipeline/wowee_building.hpp"
|
|
#include "pipeline/wowee_collision.hpp"
|
|
#include "pipeline/wowee_terrain_loader.hpp"
|
|
#include "pipeline/wmo_loader.hpp"
|
|
#include "pipeline/asset_manager.hpp"
|
|
#include "pipeline/custom_zone_discovery.hpp"
|
|
#include "core/logger.hpp"
|
|
#include <string>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <unordered_map>
|
|
#include <algorithm>
|
|
|
|
static void printUsage(const char* argv0) {
|
|
std::printf("Usage: %s --data <path> [options]\n\n", argv0);
|
|
std::printf("Options:\n");
|
|
std::printf(" --data <path> Path to extracted WoW data (manifest.json)\n");
|
|
std::printf(" --adt <map> <x> <y> Load an ADT tile on startup\n");
|
|
std::printf(" --convert-m2 <path> Convert M2 model to WOM open format (no GUI)\n");
|
|
std::printf(" --convert-wmo <path> Convert WMO building to WOB open format (no GUI)\n");
|
|
std::printf(" --list-zones List discovered custom zones and exit\n");
|
|
std::printf(" --scaffold-zone <name> [tx ty] Create a blank zone in custom_zones/<name>/ and exit\n");
|
|
std::printf(" --build-woc <wot-base> Generate a WOC collision mesh from WHM/WOT and exit\n");
|
|
std::printf(" --regen-collision <zoneDir> Rebuild every WOC under a zone dir and exit\n");
|
|
std::printf(" --export-png <wot-base> Render heightmap, normal-map, and zone-map PNG previews\n");
|
|
std::printf(" --validate <zoneDir> Score zone open-format completeness and exit\n");
|
|
std::printf(" --zone-summary <zoneDir> One-shot validate + creature/object/quest counts and exit\n");
|
|
std::printf(" --info <wom-base> Print WOM file metadata (version, counts) and exit\n");
|
|
std::printf(" --info-wob <wob-base> Print WOB building metadata (groups, portals, doodads) and exit\n");
|
|
std::printf(" --info-woc <woc-path> Print WOC collision metadata (triangle counts, bounds) and exit\n");
|
|
std::printf(" --info-wot <wot-base> Print WOT/WHM terrain metadata (tile, chunks, height range) and exit\n");
|
|
std::printf(" --info-zone <dir|json> Print zone.json fields (manifest, tiles, audio, flags) and exit\n");
|
|
std::printf(" --info-creatures <p> Print creatures.json summary (counts, behaviors) and exit\n");
|
|
std::printf(" --info-objects <p> Print objects.json summary (counts, types, scale range) and exit\n");
|
|
std::printf(" --info-quests <p> Print quests.json summary (counts, rewards, chain errors) and exit\n");
|
|
std::printf(" --info-wcp <wcp-path> Print WCP archive metadata (name, files) and exit\n");
|
|
std::printf(" --list-wcp <wcp-path> Print every file inside a WCP archive (sorted by path) and exit\n");
|
|
std::printf(" --diff-wcp <a> <b> Compare two WCPs file-by-file; exit 0 if identical, 1 otherwise\n");
|
|
std::printf(" --pack-wcp <zone> [dst] Pack a zone dir/name into a .wcp archive and exit\n");
|
|
std::printf(" --unpack-wcp <wcp> [dst] Extract a WCP archive (default dst=custom_zones/) and exit\n");
|
|
std::printf(" --version Show version and format info\n\n");
|
|
std::printf("Wowee World Editor v1.0.0 — by Kelsi Davis\n");
|
|
std::printf("Novel open formats: WOT/WHM/WOM/WOB/WOC/WCP + PNG/JSON\n");
|
|
}
|
|
|
|
int main(int argc, char* argv[]) {
|
|
std::string dataPath;
|
|
std::string adtMap;
|
|
int adtX = -1, adtY = -1;
|
|
|
|
// 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[] = {
|
|
"--data", "--info", "--info-wob", "--info-woc", "--info-wot",
|
|
"--info-creatures", "--info-objects", "--info-quests",
|
|
"--info-zone", "--info-wcp", "--list-wcp", "--unpack-wcp", "--pack-wcp",
|
|
"--validate", "--zone-summary",
|
|
"--scaffold-zone", "--build-woc", "--regen-collision", "--export-png",
|
|
"--convert-m2", "--convert-wmo",
|
|
};
|
|
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;
|
|
}
|
|
if (std::strcmp(argv[i], "--diff-wcp") == 0 && i + 2 >= argc) {
|
|
std::fprintf(stderr, "--diff-wcp requires two paths\n");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
for (int i = 1; i < argc; i++) {
|
|
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]);
|
|
} else if (std::strcmp(argv[i], "--info") == 0 && i + 1 < argc) {
|
|
std::string base = argv[++i];
|
|
// Allow either "/path/to/file.wom" or "/path/to/file"; load() expects no extension.
|
|
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, "WOM not found: %s.wom\n", base.c_str());
|
|
return 1;
|
|
}
|
|
auto wom = wowee::pipeline::WoweeModelLoader::load(base);
|
|
std::printf("WOM: %s.wom\n", base.c_str());
|
|
std::printf(" version : %u%s\n", wom.version,
|
|
wom.version == 3 ? " (multi-batch)" :
|
|
wom.version == 2 ? " (animated)" : " (static)");
|
|
std::printf(" name : %s\n", wom.name.c_str());
|
|
std::printf(" vertices : %zu\n", wom.vertices.size());
|
|
std::printf(" indices : %zu (%zu tris)\n", wom.indices.size(), wom.indices.size() / 3);
|
|
std::printf(" textures : %zu\n", wom.texturePaths.size());
|
|
std::printf(" bones : %zu\n", wom.bones.size());
|
|
std::printf(" animations : %zu\n", wom.animations.size());
|
|
std::printf(" batches : %zu\n", wom.batches.size());
|
|
std::printf(" boundRadius: %.2f\n", wom.boundRadius);
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--info-wob") == 0 && i + 1 < argc) {
|
|
std::string base = argv[++i];
|
|
if (base.size() >= 4 && base.substr(base.size() - 4) == ".wob")
|
|
base = base.substr(0, base.size() - 4);
|
|
if (!wowee::pipeline::WoweeBuildingLoader::exists(base)) {
|
|
std::fprintf(stderr, "WOB not found: %s.wob\n", base.c_str());
|
|
return 1;
|
|
}
|
|
auto bld = wowee::pipeline::WoweeBuildingLoader::load(base);
|
|
std::printf("WOB: %s.wob\n", base.c_str());
|
|
std::printf(" name : %s\n", bld.name.c_str());
|
|
std::printf(" groups : %zu\n", bld.groups.size());
|
|
std::printf(" portals : %zu\n", bld.portals.size());
|
|
std::printf(" doodads : %zu\n", bld.doodads.size());
|
|
std::printf(" boundRadius : %.2f\n", bld.boundRadius);
|
|
size_t totalVerts = 0, totalIdx = 0, totalMats = 0;
|
|
for (const auto& g : bld.groups) {
|
|
totalVerts += g.vertices.size();
|
|
totalIdx += g.indices.size();
|
|
totalMats += g.materials.size();
|
|
}
|
|
std::printf(" total verts : %zu\n", totalVerts);
|
|
std::printf(" total tris : %zu\n", totalIdx / 3);
|
|
std::printf(" total mats : %zu (across all groups)\n", totalMats);
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--info-quests") == 0 && i + 1 < argc) {
|
|
std::string path = argv[++i];
|
|
wowee::editor::QuestEditor qe;
|
|
if (!qe.loadFromFile(path)) {
|
|
std::fprintf(stderr, "Failed to load quests.json: %s\n", path.c_str());
|
|
return 1;
|
|
}
|
|
const auto& quests = qe.getQuests();
|
|
int chained = 0, withReward = 0, withItems = 0;
|
|
int objKill = 0, objCollect = 0, objTalk = 0;
|
|
uint32_t totalXp = 0;
|
|
for (const auto& q : quests) {
|
|
if (q.nextQuestId != 0) chained++;
|
|
if (q.reward.xp > 0 || q.reward.gold > 0 ||
|
|
q.reward.silver > 0 || q.reward.copper > 0) withReward++;
|
|
if (!q.reward.itemRewards.empty()) withItems++;
|
|
totalXp += q.reward.xp;
|
|
using OT = wowee::editor::QuestObjectiveType;
|
|
for (const auto& obj : q.objectives) {
|
|
if (obj.type == OT::KillCreature) objKill++;
|
|
else if (obj.type == OT::CollectItem) objCollect++;
|
|
else if (obj.type == OT::TalkToNPC) objTalk++;
|
|
}
|
|
}
|
|
std::vector<std::string> errors;
|
|
qe.validateChains(errors);
|
|
std::printf("quests.json: %s\n", path.c_str());
|
|
std::printf(" total : %zu\n", quests.size());
|
|
std::printf(" chained : %d (have nextQuestId)\n", chained);
|
|
std::printf(" with reward : %d\n", withReward);
|
|
std::printf(" with items : %d\n", withItems);
|
|
std::printf(" total XP : %u (avg %.0f per quest)\n", totalXp,
|
|
quests.empty() ? 0.0 : double(totalXp) / quests.size());
|
|
std::printf(" objectives : %d kill, %d collect, %d talk\n",
|
|
objKill, objCollect, objTalk);
|
|
if (!errors.empty()) {
|
|
std::printf(" chain errors: %zu\n", errors.size());
|
|
for (const auto& e : errors) std::printf(" - %s\n", e.c_str());
|
|
}
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--info-objects") == 0 && i + 1 < argc) {
|
|
std::string path = argv[++i];
|
|
wowee::editor::ObjectPlacer placer;
|
|
if (!placer.loadFromFile(path)) {
|
|
std::fprintf(stderr, "Failed to load objects.json: %s\n", path.c_str());
|
|
return 1;
|
|
}
|
|
const auto& objs = placer.getObjects();
|
|
int m2Count = 0, wmoCount = 0;
|
|
std::unordered_map<std::string, int> pathHist;
|
|
float minScale = 1e30f, maxScale = -1e30f;
|
|
for (const auto& o : objs) {
|
|
if (o.type == wowee::editor::PlaceableType::M2) m2Count++;
|
|
else if (o.type == wowee::editor::PlaceableType::WMO) wmoCount++;
|
|
pathHist[o.path]++;
|
|
if (o.scale < minScale) minScale = o.scale;
|
|
if (o.scale > maxScale) maxScale = o.scale;
|
|
}
|
|
std::printf("objects.json: %s\n", path.c_str());
|
|
std::printf(" total : %zu\n", objs.size());
|
|
std::printf(" M2 doodads : %d\n", m2Count);
|
|
std::printf(" WMO buildings: %d\n", wmoCount);
|
|
std::printf(" unique paths: %zu\n", pathHist.size());
|
|
if (!objs.empty()) {
|
|
std::printf(" scale range : [%.2f, %.2f]\n", minScale, maxScale);
|
|
}
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--info-zone") == 0 && i + 1 < argc) {
|
|
// Parse a zone.json and print every manifest field. Useful when
|
|
// diffing two zones or auditing the audio/flag setup before
|
|
// packing into a WCP.
|
|
std::string zonePath = argv[++i];
|
|
namespace fs = std::filesystem;
|
|
// Accept either a directory or the zone.json itself.
|
|
if (fs::is_directory(zonePath)) zonePath += "/zone.json";
|
|
wowee::editor::ZoneManifest manifest;
|
|
if (!manifest.load(zonePath)) {
|
|
std::fprintf(stderr, "Failed to load zone.json: %s\n", zonePath.c_str());
|
|
return 1;
|
|
}
|
|
std::printf("zone.json: %s\n", zonePath.c_str());
|
|
std::printf(" mapName : %s\n", manifest.mapName.c_str());
|
|
std::printf(" displayName : %s\n", manifest.displayName.c_str());
|
|
std::printf(" mapId : %u\n", manifest.mapId);
|
|
std::printf(" biome : %s\n", manifest.biome.c_str());
|
|
std::printf(" baseHeight : %.2f\n", manifest.baseHeight);
|
|
std::printf(" hasCreatures: %s\n", manifest.hasCreatures ? "yes" : "no");
|
|
std::printf(" description : %s\n", manifest.description.c_str());
|
|
std::printf(" tiles : %zu\n", manifest.tiles.size());
|
|
for (const auto& t : manifest.tiles)
|
|
std::printf(" (%d, %d)\n", t.first, t.second);
|
|
std::printf(" flags : %s%s%s%s\n",
|
|
manifest.allowFlying ? "fly " : "",
|
|
manifest.pvpEnabled ? "pvp " : "",
|
|
manifest.isIndoor ? "indoor " : "",
|
|
manifest.isSanctuary ? "sanctuary" : "");
|
|
if (!manifest.musicTrack.empty() || !manifest.ambienceDay.empty()) {
|
|
std::printf(" audio :\n");
|
|
if (!manifest.musicTrack.empty())
|
|
std::printf(" music : %s (vol=%.2f)\n",
|
|
manifest.musicTrack.c_str(), manifest.musicVolume);
|
|
if (!manifest.ambienceDay.empty())
|
|
std::printf(" ambience : %s (vol=%.2f)\n",
|
|
manifest.ambienceDay.c_str(), manifest.ambienceVolume);
|
|
if (!manifest.ambienceNight.empty())
|
|
std::printf(" night amb : %s\n", manifest.ambienceNight.c_str());
|
|
}
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--info-creatures") == 0 && i + 1 < argc) {
|
|
std::string path = argv[++i];
|
|
wowee::editor::NpcSpawner spawner;
|
|
if (!spawner.loadFromFile(path)) {
|
|
std::fprintf(stderr, "Failed to load creatures.json: %s\n", path.c_str());
|
|
return 1;
|
|
}
|
|
const auto& spawns = spawner.getSpawns();
|
|
int hostile = 0, vendor = 0, questgiver = 0, trainer = 0;
|
|
int patrol = 0, wander = 0, stationary = 0;
|
|
std::unordered_map<uint32_t, int> displayIdHist;
|
|
for (const auto& s : spawns) {
|
|
if (s.hostile) hostile++;
|
|
if (s.vendor) vendor++;
|
|
if (s.questgiver) questgiver++;
|
|
if (s.trainer) trainer++;
|
|
using B = wowee::editor::CreatureBehavior;
|
|
if (s.behavior == B::Patrol) patrol++;
|
|
else if (s.behavior == B::Wander) wander++;
|
|
else if (s.behavior == B::Stationary) stationary++;
|
|
displayIdHist[s.displayId]++;
|
|
}
|
|
std::printf("creatures.json: %s\n", path.c_str());
|
|
std::printf(" total : %zu\n", spawns.size());
|
|
std::printf(" hostile : %d\n", hostile);
|
|
std::printf(" questgiver : %d\n", questgiver);
|
|
std::printf(" vendor : %d\n", vendor);
|
|
std::printf(" trainer : %d\n", trainer);
|
|
std::printf(" behavior : %d stationary, %d wander, %d patrol\n",
|
|
stationary, wander, patrol);
|
|
std::printf(" unique displayIds: %zu\n", displayIdHist.size());
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--diff-wcp") == 0 && i + 2 < argc) {
|
|
// Print which files differ between two WCP archives. Useful
|
|
// when verifying that an authoring tweak only changed what
|
|
// it claimed to change, or when comparing pack-WCP output
|
|
// across editor versions for regression detection.
|
|
std::string aPath = argv[++i];
|
|
std::string bPath = argv[++i];
|
|
wowee::editor::ContentPackInfo aInfo, bInfo;
|
|
if (!wowee::editor::ContentPacker::readInfo(aPath, aInfo) ||
|
|
!wowee::editor::ContentPacker::readInfo(bPath, bInfo)) {
|
|
std::fprintf(stderr, "Failed to read WCP info\n");
|
|
return 1;
|
|
}
|
|
std::unordered_map<std::string, uint64_t> aFiles, bFiles;
|
|
for (const auto& f : aInfo.files) aFiles[f.path] = f.size;
|
|
for (const auto& f : bInfo.files) bFiles[f.path] = f.size;
|
|
|
|
int onlyA = 0, onlyB = 0, sizeChanged = 0, identical = 0;
|
|
std::vector<std::string> onlyAList, onlyBList, changedList;
|
|
for (const auto& [p, sz] : aFiles) {
|
|
auto it = bFiles.find(p);
|
|
if (it == bFiles.end()) { onlyA++; onlyAList.push_back(p); }
|
|
else if (it->second != sz) {
|
|
sizeChanged++;
|
|
changedList.push_back(p + " (" + std::to_string(sz) + " -> " +
|
|
std::to_string(it->second) + ")");
|
|
} else identical++;
|
|
}
|
|
for (const auto& [p, sz] : bFiles) {
|
|
if (aFiles.find(p) == aFiles.end()) { onlyB++; onlyBList.push_back(p); }
|
|
}
|
|
std::sort(onlyAList.begin(), onlyAList.end());
|
|
std::sort(onlyBList.begin(), onlyBList.end());
|
|
std::sort(changedList.begin(), changedList.end());
|
|
std::printf("Diff: %s vs %s\n", aPath.c_str(), bPath.c_str());
|
|
std::printf(" identical : %d\n", identical);
|
|
std::printf(" changed : %d\n", sizeChanged);
|
|
std::printf(" only in A : %d\n", onlyA);
|
|
std::printf(" only in B : %d\n", onlyB);
|
|
for (const auto& s : changedList) std::printf(" ~ %s\n", s.c_str());
|
|
for (const auto& s : onlyAList) std::printf(" - %s\n", s.c_str());
|
|
for (const auto& s : onlyBList) std::printf(" + %s\n", s.c_str());
|
|
return (onlyA + onlyB + sizeChanged) == 0 ? 0 : 1;
|
|
} else if (std::strcmp(argv[i], "--list-wcp") == 0 && i + 1 < argc) {
|
|
// Like --info-wcp but prints every file path. Useful for spotting
|
|
// missing or unexpected entries before unpacking.
|
|
std::string path = argv[++i];
|
|
wowee::editor::ContentPackInfo info;
|
|
if (!wowee::editor::ContentPacker::readInfo(path, info)) {
|
|
std::fprintf(stderr, "Failed to read WCP: %s\n", path.c_str());
|
|
return 1;
|
|
}
|
|
std::printf("WCP: %s — %zu files\n", path.c_str(), info.files.size());
|
|
// Sort by path so identical packs produce identical output (the
|
|
// packer order depends on the directory_iterator implementation).
|
|
auto files = info.files;
|
|
std::sort(files.begin(), files.end(),
|
|
[](const auto& a, const auto& b) { return a.path < b.path; });
|
|
for (const auto& f : files) {
|
|
std::printf(" %-10s %10llu %s\n",
|
|
f.category.c_str(),
|
|
static_cast<unsigned long long>(f.size),
|
|
f.path.c_str());
|
|
}
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--info-wcp") == 0 && i + 1 < argc) {
|
|
std::string path = argv[++i];
|
|
wowee::editor::ContentPackInfo info;
|
|
if (!wowee::editor::ContentPacker::readInfo(path, info)) {
|
|
std::fprintf(stderr, "Failed to read WCP: %s\n", path.c_str());
|
|
return 1;
|
|
}
|
|
std::printf("WCP: %s\n", path.c_str());
|
|
std::printf(" name : %s\n", info.name.c_str());
|
|
std::printf(" author : %s\n", info.author.c_str());
|
|
std::printf(" description : %s\n", info.description.c_str());
|
|
std::printf(" version : %s\n", info.version.c_str());
|
|
std::printf(" format : %s\n", info.format.c_str());
|
|
std::printf(" mapId : %u\n", info.mapId);
|
|
std::printf(" files : %zu\n", info.files.size());
|
|
// Per-category file totals
|
|
std::unordered_map<std::string, size_t> byCat;
|
|
uint64_t totalSize = 0;
|
|
for (const auto& f : info.files) {
|
|
byCat[f.category]++;
|
|
totalSize += f.size;
|
|
}
|
|
for (const auto& [cat, count] : byCat) {
|
|
std::printf(" %-10s : %zu\n", cat.c_str(), count);
|
|
}
|
|
std::printf(" total bytes : %.2f MB\n", totalSize / (1024.0 * 1024.0));
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--info-wot") == 0 && i + 1 < argc) {
|
|
std::string base = argv[++i];
|
|
// Accept "/path/file.wot", "/path/file.whm", or "/path/file"; the
|
|
// loader pairs both extensions from the same base path.
|
|
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 WOT/WHM: %s\n", base.c_str());
|
|
return 1;
|
|
}
|
|
int chunksWithHeights = 0, chunksWithLayers = 0, chunksWithWater = 0;
|
|
float minH = 1e30f, maxH = -1e30f;
|
|
for (int ci = 0; ci < 256; ci++) {
|
|
const auto& c = terrain.chunks[ci];
|
|
if (c.hasHeightMap()) {
|
|
chunksWithHeights++;
|
|
for (float h : c.heightMap.heights) {
|
|
float total = c.position[2] + h;
|
|
if (total < minH) minH = total;
|
|
if (total > maxH) maxH = total;
|
|
}
|
|
}
|
|
if (!c.layers.empty()) chunksWithLayers++;
|
|
if (terrain.waterData[ci].hasWater()) chunksWithWater++;
|
|
}
|
|
std::printf("WOT/WHM: %s\n", base.c_str());
|
|
std::printf(" tile : (%d, %d)\n", terrain.coord.x, terrain.coord.y);
|
|
std::printf(" chunks : %d/256 with heightmap\n", chunksWithHeights);
|
|
std::printf(" layers : %d/256 chunks with texture layers\n", chunksWithLayers);
|
|
std::printf(" water : %d/256 chunks with water\n", chunksWithWater);
|
|
std::printf(" textures : %zu\n", terrain.textures.size());
|
|
std::printf(" doodads : %zu\n", terrain.doodadPlacements.size());
|
|
std::printf(" WMOs : %zu\n", terrain.wmoPlacements.size());
|
|
if (chunksWithHeights > 0) {
|
|
std::printf(" height range : [%.2f, %.2f]\n", minH, maxH);
|
|
}
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--info-woc") == 0 && i + 1 < argc) {
|
|
std::string path = argv[++i];
|
|
if (path.size() < 4 || path.substr(path.size() - 4) != ".woc")
|
|
path += ".woc";
|
|
auto col = wowee::pipeline::WoweeCollisionBuilder::load(path);
|
|
if (!col.isValid()) {
|
|
std::fprintf(stderr, "WOC not found or invalid: %s\n", path.c_str());
|
|
return 1;
|
|
}
|
|
std::printf("WOC: %s\n", path.c_str());
|
|
std::printf(" tile : (%u, %u)\n", col.tileX, col.tileY);
|
|
std::printf(" triangles : %zu\n", col.triangles.size());
|
|
std::printf(" walkable : %zu\n", col.walkableCount());
|
|
std::printf(" steep : %zu\n", col.steepCount());
|
|
std::printf(" bounds.min : (%.1f, %.1f, %.1f)\n",
|
|
col.bounds.min.x, col.bounds.min.y, col.bounds.min.z);
|
|
std::printf(" bounds.max : (%.1f, %.1f, %.1f)\n",
|
|
col.bounds.max.x, col.bounds.max.y, col.bounds.max.z);
|
|
return 0;
|
|
} 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];
|
|
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);
|
|
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);
|
|
// Creature stats
|
|
std::string creaturesPath = zoneDir + "/creatures.json";
|
|
if (fs::exists(creaturesPath)) {
|
|
wowee::editor::NpcSpawner sp;
|
|
if (sp.loadFromFile(creaturesPath)) {
|
|
int hostile = 0, qg = 0, vendor = 0;
|
|
for (const auto& s : sp.getSpawns()) {
|
|
if (s.hostile) hostile++;
|
|
if (s.questgiver) qg++;
|
|
if (s.vendor) vendor++;
|
|
}
|
|
std::printf(" creatures : %zu (%d hostile, %d quest, %d vendor)\n",
|
|
sp.getSpawns().size(), hostile, qg, vendor);
|
|
}
|
|
}
|
|
// Object stats
|
|
std::string objectsPath = zoneDir + "/objects.json";
|
|
if (fs::exists(objectsPath)) {
|
|
wowee::editor::ObjectPlacer op;
|
|
if (op.loadFromFile(objectsPath)) {
|
|
int m2 = 0, wmo = 0;
|
|
for (const auto& o : op.getObjects()) {
|
|
if (o.type == wowee::editor::PlaceableType::M2) m2++;
|
|
else wmo++;
|
|
}
|
|
std::printf(" objects : %zu (%d M2, %d WMO)\n",
|
|
op.getObjects().size(), m2, wmo);
|
|
}
|
|
}
|
|
// Quest stats
|
|
std::string questsPath = zoneDir + "/quests.json";
|
|
if (fs::exists(questsPath)) {
|
|
wowee::editor::QuestEditor qe;
|
|
if (qe.loadFromFile(questsPath)) {
|
|
std::vector<std::string> errors;
|
|
qe.validateChains(errors);
|
|
std::printf(" quests : %zu (%zu chain warnings)\n",
|
|
qe.getQuests().size(), errors.size());
|
|
}
|
|
}
|
|
return v.openFormatScore() == 7 ? 0 : 1;
|
|
} else if (std::strcmp(argv[i], "--validate") == 0 && i + 1 < argc) {
|
|
std::string zoneDir = argv[++i];
|
|
auto v = wowee::editor::ContentPacker::validateZone(zoneDir);
|
|
int score = v.openFormatScore();
|
|
std::printf("Zone: %s\n", zoneDir.c_str());
|
|
std::printf("Open format score: %d/7\n", score);
|
|
std::printf("Formats: %s\n", v.summary().c_str());
|
|
std::printf("Files present:\n");
|
|
std::printf(" WOT (terrain meta) : %s (%d)\n",
|
|
v.hasWot ? "yes" : "no", v.wotCount);
|
|
std::printf(" WHM (heightmap) : %s (%d)%s\n",
|
|
v.hasWhm ? "yes" : "no", v.whmCount,
|
|
v.hasWhm && !v.whmValid ? " (BAD MAGIC)" : "");
|
|
std::printf(" WOM (models) : %s (%d)%s\n",
|
|
v.hasWom ? "yes" : "no", v.womCount,
|
|
v.womInvalidCount > 0 ?
|
|
(" (" + std::to_string(v.womInvalidCount) + " invalid)").c_str() : "");
|
|
std::printf(" WOB (buildings) : %s (%d)%s\n",
|
|
v.hasWob ? "yes" : "no", v.wobCount,
|
|
v.wobInvalidCount > 0 ?
|
|
(" (" + std::to_string(v.wobInvalidCount) + " invalid)").c_str() : "");
|
|
std::printf(" WOC (collision) : %s (%d)%s\n",
|
|
v.hasWoc ? "yes" : "no", v.wocCount,
|
|
v.wocInvalidCount > 0 ?
|
|
(" (" + std::to_string(v.wocInvalidCount) + " invalid)").c_str() : "");
|
|
std::printf(" PNG (textures) : %s (%d)\n",
|
|
v.hasPng ? "yes" : "no", v.pngCount);
|
|
std::printf(" zone.json : %s\n", v.hasZoneJson ? "yes" : "no");
|
|
std::printf(" creatures.json : %s\n", v.hasCreatures ? "yes" : "no");
|
|
std::printf(" quests.json : %s\n", v.hasQuests ? "yes" : "no");
|
|
std::printf(" objects.json : %s\n", v.hasObjects ? "yes" : "no");
|
|
return score == 7 ? 0 : 1;
|
|
} 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());
|
|
return 0;
|
|
} 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;
|
|
} 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;
|
|
} else if (std::strcmp(argv[i], "--scaffold-zone") == 0 && i + 1 < argc) {
|
|
// Generate a minimal valid empty zone — useful for kickstarting
|
|
// a new authoring session without needing to launch the GUI.
|
|
std::string rawName = argv[++i];
|
|
int sx = 32, sy = 32;
|
|
if (i + 2 < argc) {
|
|
int parsedX = std::atoi(argv[i + 1]);
|
|
int parsedY = std::atoi(argv[i + 2]);
|
|
if (parsedX >= 0 && parsedX <= 63 &&
|
|
parsedY >= 0 && parsedY <= 63) {
|
|
sx = parsedX; sy = parsedY;
|
|
i += 2;
|
|
}
|
|
}
|
|
// Slugify name to match unpackZone / server module rules.
|
|
std::string slug;
|
|
for (char c : rawName) {
|
|
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
|
|
(c >= '0' && c <= '9') || c == '_' || c == '-') {
|
|
slug += c;
|
|
} else if (c == ' ') {
|
|
slug += '_';
|
|
}
|
|
}
|
|
if (slug.empty()) {
|
|
std::fprintf(stderr, "--scaffold-zone: name '%s' has no valid characters\n",
|
|
rawName.c_str());
|
|
return 1;
|
|
}
|
|
namespace fs = std::filesystem;
|
|
std::string dir = "custom_zones/" + slug;
|
|
if (fs::exists(dir)) {
|
|
std::fprintf(stderr, "--scaffold-zone: directory already exists: %s\n",
|
|
dir.c_str());
|
|
return 1;
|
|
}
|
|
fs::create_directories(dir);
|
|
|
|
// Blank flat terrain at the requested tile.
|
|
auto terrain = wowee::editor::TerrainEditor::createBlankTerrain(
|
|
sx, sy, 100.0f, wowee::editor::Biome::Grassland);
|
|
std::string base = dir + "/" + slug + "_" +
|
|
std::to_string(sx) + "_" + std::to_string(sy);
|
|
wowee::editor::WoweeTerrain::exportOpen(terrain, base, sx, sy);
|
|
|
|
// Minimal zone.json
|
|
wowee::editor::ZoneManifest manifest;
|
|
manifest.mapName = slug;
|
|
manifest.displayName = rawName;
|
|
manifest.mapId = 9000;
|
|
manifest.baseHeight = 100.0f;
|
|
manifest.tiles.push_back({sx, sy});
|
|
manifest.save(dir + "/zone.json");
|
|
|
|
std::printf("Scaffolded zone: %s\n", dir.c_str());
|
|
std::printf(" tile : (%d, %d)\n", sx, sy);
|
|
std::printf(" files : %s.wot, %s.whm, zone.json\n",
|
|
slug.c_str(), slug.c_str());
|
|
std::printf(" next step: run editor without args, then File → Open Zone\n");
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--pack-wcp") == 0 && i + 1 < argc) {
|
|
// Pack a zone directory into a .wcp archive.
|
|
// Usage: --pack-wcp <zoneDirOrName> [destPath]
|
|
// If <zoneDirOrName> looks like a path (contains '/' or starts
|
|
// with '.'), use it directly; otherwise resolve under
|
|
// custom_zones/ then output/ (matching the discovery search
|
|
// order).
|
|
std::string nameOrDir = argv[++i];
|
|
std::string destPath;
|
|
if (i + 1 < argc && argv[i + 1][0] != '-') {
|
|
destPath = argv[++i];
|
|
}
|
|
namespace fs = std::filesystem;
|
|
std::string outputDir, mapName;
|
|
if (nameOrDir.find('/') != std::string::npos || nameOrDir[0] == '.') {
|
|
fs::path p = fs::absolute(nameOrDir);
|
|
outputDir = p.parent_path().string();
|
|
mapName = p.filename().string();
|
|
} else {
|
|
mapName = nameOrDir;
|
|
if (fs::exists("custom_zones/" + mapName)) outputDir = "custom_zones";
|
|
else if (fs::exists("output/" + mapName)) outputDir = "output";
|
|
else {
|
|
std::fprintf(stderr,
|
|
"--pack-wcp: zone '%s' not found in custom_zones/ or output/\n",
|
|
mapName.c_str());
|
|
return 1;
|
|
}
|
|
}
|
|
if (destPath.empty()) destPath = mapName + ".wcp";
|
|
wowee::editor::ContentPackInfo info;
|
|
info.name = mapName;
|
|
info.format = "wcp-1.0";
|
|
if (!wowee::editor::ContentPacker::packZone(outputDir, mapName, destPath, info)) {
|
|
std::fprintf(stderr, "WCP pack failed for %s/%s\n",
|
|
outputDir.c_str(), mapName.c_str());
|
|
return 1;
|
|
}
|
|
std::printf("WCP packed: %s\n", destPath.c_str());
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--unpack-wcp") == 0 && i + 1 < argc) {
|
|
std::string wcpPath = argv[++i];
|
|
std::string destDir = "custom_zones";
|
|
if (i + 1 < argc && argv[i + 1][0] != '-') {
|
|
destDir = argv[++i];
|
|
}
|
|
if (!wowee::editor::ContentPacker::unpackZone(wcpPath, destDir)) {
|
|
std::fprintf(stderr, "WCP unpack failed: %s\n", wcpPath.c_str());
|
|
return 1;
|
|
}
|
|
std::printf("WCP unpacked to: %s\n", destDir.c_str());
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--list-zones") == 0) {
|
|
auto zones = wowee::pipeline::CustomZoneDiscovery::scan({"custom_zones", "output"});
|
|
if (zones.empty()) {
|
|
std::printf("No custom zones found in custom_zones/ or output/\n");
|
|
} else {
|
|
std::printf("Custom zones found:\n");
|
|
for (const auto& z : zones) {
|
|
std::printf(" %s — %s%s%s\n", z.name.c_str(), z.directory.c_str(),
|
|
z.hasCreatures ? " [NPCs]" : "",
|
|
z.hasQuests ? " [Quests]" : "");
|
|
}
|
|
}
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--version") == 0 || std::strcmp(argv[i], "-v") == 0) {
|
|
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");
|
|
return 0;
|
|
} else if (std::strcmp(argv[i], "--help") == 0 || std::strcmp(argv[i], "-h") == 0) {
|
|
printUsage(argv[0]);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Batch convert mode: --convert <m2path> converts M2 to WOM
|
|
for (int i = 1; i < argc; i++) {
|
|
if (std::strcmp(argv[i], "--convert-m2") == 0 && i + 1 < argc) {
|
|
std::string m2Path = argv[++i];
|
|
std::printf("Converting M2→WOM: %s\n", m2Path.c_str());
|
|
if (dataPath.empty()) dataPath = "Data";
|
|
wowee::pipeline::AssetManager am;
|
|
if (am.initialize(dataPath)) {
|
|
auto wom = wowee::pipeline::WoweeModelLoader::fromM2(m2Path, &am);
|
|
if (wom.isValid()) {
|
|
std::string outPath = m2Path;
|
|
auto dot = outPath.rfind('.');
|
|
if (dot != std::string::npos) outPath = outPath.substr(0, dot);
|
|
wowee::pipeline::WoweeModelLoader::save(wom, "output/models/" + outPath);
|
|
std::printf("OK: output/models/%s.wom (v%u, %zu verts, %zu bones, %zu batches)\n",
|
|
outPath.c_str(), wom.version, wom.vertices.size(),
|
|
wom.bones.size(), wom.batches.size());
|
|
} else {
|
|
std::fprintf(stderr, "FAILED: %s\n", m2Path.c_str());
|
|
am.shutdown();
|
|
return 1;
|
|
}
|
|
am.shutdown();
|
|
} else {
|
|
std::fprintf(stderr, "FAILED: cannot initialize asset manager\n");
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Batch convert mode: --convert-wmo converts WMO to WOB
|
|
for (int i = 1; i < argc; i++) {
|
|
if (std::strcmp(argv[i], "--convert-wmo") == 0 && i + 1 < argc) {
|
|
std::string wmoPath = argv[++i];
|
|
std::printf("Converting WMO→WOB: %s\n", wmoPath.c_str());
|
|
if (dataPath.empty()) dataPath = "Data";
|
|
wowee::pipeline::AssetManager am;
|
|
if (am.initialize(dataPath)) {
|
|
auto wmoData = am.readFile(wmoPath);
|
|
if (!wmoData.empty()) {
|
|
auto wmoModel = wowee::pipeline::WMOLoader::load(wmoData);
|
|
if (wmoModel.nGroups > 0) {
|
|
std::string wmoBase = wmoPath;
|
|
if (wmoBase.size() > 4) wmoBase = wmoBase.substr(0, wmoBase.size() - 4);
|
|
for (uint32_t gi = 0; gi < wmoModel.nGroups; gi++) {
|
|
char suffix[16];
|
|
snprintf(suffix, sizeof(suffix), "_%03u.wmo", gi);
|
|
auto gd = am.readFile(wmoBase + suffix);
|
|
if (!gd.empty()) wowee::pipeline::WMOLoader::loadGroup(gd, wmoModel, gi);
|
|
}
|
|
}
|
|
auto wob = wowee::pipeline::WoweeBuildingLoader::fromWMO(wmoModel, wmoPath);
|
|
if (wob.isValid()) {
|
|
std::string outPath = wmoPath;
|
|
auto dot = outPath.rfind('.');
|
|
if (dot != std::string::npos) outPath = outPath.substr(0, dot);
|
|
wowee::pipeline::WoweeBuildingLoader::save(wob, "output/buildings/" + outPath);
|
|
std::printf("OK: output/buildings/%s.wob (%zu groups)\n",
|
|
outPath.c_str(), wob.groups.size());
|
|
} else {
|
|
std::fprintf(stderr, "FAILED: %s\n", wmoPath.c_str());
|
|
am.shutdown();
|
|
return 1;
|
|
}
|
|
} else {
|
|
std::fprintf(stderr, "FAILED: file not found: %s\n", wmoPath.c_str());
|
|
am.shutdown();
|
|
return 1;
|
|
}
|
|
am.shutdown();
|
|
} else {
|
|
std::fprintf(stderr, "FAILED: cannot initialize asset manager\n");
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|