Closes the JSON round-trip gap on the spell mechanic catalog
format shipped this batch. --export-wsmc-json emits all 9
scalar fields plus dual int + name forms for drCategory (8
values) and dispelType (7 values). --import-wsmc-json accepts
either form. conflictsMask is dumped/parsed as a raw uint32
since it's a free-form bitmask of OTHER mechanic IDs (no
enum to widen). Verified byte-identical round-trip on all
three preset emitters (starter / hard-CC with conflictsMask
bits set / roots with stacking flag). 791 documented CLI flags.
54th open format — replaces SpellMechanic.dbc plus the
AzerothCore-style diminishing-returns (DR) tables. Defines
crowd-control mechanic categories that spells reference:
Stun, Silence, Polymorph, Sleep, Fear, Root, Snare, Slow,
Knockback, etc. Each mechanic carries gameplay metadata
(breaks-on-damage, can-be-dispelled, default duration, max
stacks) plus DR category and dispel type.
8 DR categories (DRNone / DRStun / DRDisorient / DRSilence
/ DRRoot / DRPolymorph / DRControlled / DRMisc) — the
runtime uses these to gate repeated CC on the same target.
7 dispel types (DispelNone / Magic / Curse / Disease /
Poison / Enrage / Stealth) bind which dispel spells can
remove the mechanic. conflictsMask is a bitmask of OTHER
mechanic IDs — only one mechanic from a conflict-group can
apply to a target simultaneously.
Cross-references with prior formats — mechanicId is
referenced by WSPL.spellId entries that apply this CC; this
catalog is referenced from spell tags rather than referencing
out.
CLI: --gen-smc (3 baseline Stun/Silence/Snare), --gen-smc-
hard (5 hard-CC: Stun/Polymorph/Sleep/Fear/Knockback with
conflictsMask wiring), --gen-smc-roots (4 movement-impair:
Root/Snare/Slow stacking 5x/GroundPin breaks-on-damage),
--info-wsmc, --validate-wsmc with --json variants. Validator
catches id+name required, DR category 0..7, dispel type
0..6, maxStacks=0 (mechanic could never apply),
canBeDispelled+DispelNone inconsistency, and self-conflict
bit set in conflictsMask (mechanic blocking itself).
Format graph: 53 → 54 binary formats. CLI flag count: 784
→ 789.
Closes the JSON round-trip gap on the companion pet catalog
format shipped last batch. --export-wcmp-json emits all 9
scalar fields plus dual int + name forms for companionKind
(8 values) / rarity (4 values) / factionRestriction (3 values)
so hand-edits can use either representation.
--import-wcmp-json accepts either form, falling back to the
int when both are present. Verified byte-identical round-trip
on all three preset emitters (starter / rare / faction). 784
documented CLI flags.
53rd open format — replaces the companion-pet portions of
CreatureFamily.dbc plus the AzerothCore-style critter / vanity-
pet SQL data. Distinct from WPET (which covers hunter combat
pets and warlock minions); WCMP covers non-combat "vanity" pets
that follow the player around for cosmetic reasons —
Mechanical Squirrel, Mini Diablo, Panda Cub, dragon hatchlings.
8 companion kinds (Critter, Mechanical, DragonHatchling,
Demonic, Spectral, Elemental, Plush, UndeadCritter), 4
rarity tiers (Common / Uncommon / Rare / Epic), and 3
faction restrictions (AnyFaction / AllianceOnly / HordeOnly).
Cross-references with prior formats — creatureId points at
WCRT.creatureId (the rendered model), learnSpellId at
WSPL.spellId (the spell that summons the pet), itemId at
WIT.itemId (the item that teaches the spell), and
idleSoundId at WSND.soundId (idle ambient noise).
CLI: --gen-cmp (3 common vendor pets), --gen-cmp-rare (4
promo / collector pets at Epic rarity — Mini Diablo,
Panda Cub, Zergling, Murky), --gen-cmp-faction (3 faction-
restricted Alliance Lion Cub / Horde Mottled Boar /
neutral Argent Squire), --info-wcmp, --validate-wcmp with
--json variants. Validator catches id+name+creatureId+
learnSpellId required, kind 0..7 / rarity 0..3 / faction
0..2 range, and Epic-rarity-no-itemId warning (most promo
pets need a redemption-code item).
Format graph: 52 → 53 binary formats. CLI flag count: 777
→ 782.
Closes the JSON round-trip gap on the game tips catalog format
shipped this batch. --export-wgtp-json emits all 11 scalar
fields plus a dual int + name form for displayKind so
hand-edits can use either representation. --import-wgtp-json
defaults audienceFilter to kAudienceAll when omitted (so a
sidecar without that field doesn't accidentally produce a tip
that is never shown). Verified byte-identical round-trip on
all three preset emitters (starter / new-player / advanced).
777 documented CLI flags.
52nd open format — replaces GameTips.dbc plus loading-screen
tutorial hint tables. Defines the rotating tips shown during
world loads, the contextual tutorial hints that fire on first
gameplay events (first quest accept, first death, first
dungeon entry), and the persistent tooltip-help strings that
explain UI elements.
4 display kinds (LoadingScreen / Tutorial / TooltipHelp /
Hint), 7 audience-filter bits (Alliance / Horde / NewPlayer /
Hardcore / PvE / PvP / Roleplay) for pool selection, level
range gating (minLevel + maxLevel), displayWeight for
relative frequency within the pool, optional WPCN condition
cross-ref for further gating, and class-mask restriction
matching WCHC bit positions.
Cross-references with prior formats — conditionId points at
WPCN.conditionId for advanced gating; requiredClassMask uses
the same WCHC.classId bit layout as WGLY/WSET.
CLI: --gen-tips (3 generic loading-screen tips), --gen-tips-
new-player (5 onboarding Tutorial-kind tips for level 1-15,
weighted higher for new players), --gen-tips-advanced (4
endgame tips for level 70+ covering raid mechanics / arena /
daily professions / dungeon finder), --info-wgtp,
--validate-wgtp with --json variants. Validator catches
id/name/text required, kind 0..3, audienceFilter=0 (tip
never shown), invalid level range, displayWeight=0 (in pool
but never picked) warning, and brevity check (>280 chars)
on Tutorial / Hint kinds that need to fit on screen.
Format graph: 51 → 52 binary formats. CLI flag count: 770
→ 775.
Recursively walks a directory, identifies every recognized .w*
file by 4-byte magic, and parses the standard catalog header
(magic + version + length-prefixed name + entryCount) to
confirm the file isn't truncated, corrupted, or otherwise
malformed at the header level. Reports per-file PASS/FAIL +
extension-mismatch warnings (when a file's actual extension
doesn't match what its magic says it should be).
Exits 1 on any FAIL — designed as a CI gate that runs after
content build to catch truncations / write-failures /
disk-full mid-emit. World/asset formats (WOM/WOB/WHM/WOT/WOW)
are recognized by magic but the catalog-header probe is
skipped since their layouts differ.
Implausibility caps: catalog-name length > 1MB or
entryCount > 1M trigger failure as likely corruption signals.
--quiet hides the per-file PASS/FAIL list (summary line only);
--json variant for tooling integration.
Closes the JSON round-trip gap on the item set catalog format
shipped this batch. --export-wset-json emits all 8 scalar
fields plus two nested arrays — itemIds[] (only the populated
slots) and bonuses[{threshold, spellId}] (only the populated
bonus pairs). --import-wset-json derives pieceCount and
bonusCount from the array sizes (the explicit count fields
in the binary header are recomputed on import) and clears any
trailing slots so a 5-piece PvP set imported from JSON
correctly leaves slots 5-7 zero. requiredClassMask is dumped
as a raw uint32 — users hand-edit using WCHC bit positions
(Druid=0x800, Mage=0x100, Paladin=0x04 etc).
Verified byte-identical round-trip on all three preset
emitters (starter / tier / PvP — including the 5-piece PvP
variant with 2/4-piece bonuses). 769 documented CLI flags.
51st open format — replaces ItemSet.dbc + ItemSetSpell.dbc
plus the AzerothCore-style item_set_spell SQL data. Closes
the tier-bonus gap left by WIT (which describes individual
items but not the set bonuses they grant when worn together).
Each entry binds up to 8 piece item IDs to up to 4 bonus
thresholds — at N pieces worn, the matching bonus spell
activates as an aura. Standard 2/4/6/8-piece tier set pattern
is the canonical case; 5-piece PvP sets with 2/4 bonuses are
also supported.
Cross-references with prior formats — itemIds[] point at
WIT.itemId, bonusSpellIds[] point at WSPL.spellId, and
requiredSkillId points at WSKL.skillId. requiredClassMask
is a 32-bit field (uint32_t) so bit positions match WCHC's
classId enum directly — Druid (bit 11 = 0x800) and Mage
(bit 8 = 0x100) wouldn't fit in a uint8_t.
CLI: --gen-itset (2 raid sets — Battlegear of Wrath +
Stormrage Raiment, real WoW item/spell IDs), --gen-itset-tier
(4 tier-1 progression sets covering plate / cloth / leather /
holy plate), --gen-itset-pvp (3 PvP gladiator 5-piece sets
with honor-rank skill thresholds), --info-wset, --validate-wset
with --json variants. Validator catches id+name+pieceCount
required, pieceCount/bonusCount within array bounds, piece-
slot drift (0 IDs within count or non-0 IDs past count),
bonus thresholds strictly ascending, no bonus threshold
exceeding pieceCount (would never trigger), and spellId=0
in any populated bonus slot.
Format graph: 50 → 51 binary formats. CLI flag count: 762
→ 767.
Closes the JSON round-trip gap on the creature equipment
catalog format shipped last batch (50th open format). All
fields are scalar — no enum widening — so the JSON mapping
is a direct dump. Slot fields default to the canonical
attachment-table values (mainhand=16, offhand=17,
ranged=18) when omitted from a sidecar, so hand-edits don't
need to spell out the slot numbers for typical loadouts.
Verified byte-identical round-trip on all three preset
emitters (starter / bosses / ranged). 762 documented CLI
flags.
Replaces the AzerothCore-style creature_equip_template SQL
tables plus the visible-weapon / shield / ranged-slot data
that was traditionally embedded in creature templates. Closes
a long-standing gap in the creature subsystem: until now WCRT
defined a creature's stats, WSPN placed it in the world, and
WLOT defined what it drops — but nothing defined what items
it visibly equips.
Each entry binds a creatureId to up to three equipped items
(main hand / off hand / ranged) plus the visual kit that
fires when the main-hand weapon is brandished. equipFlags
bits encode hidden / dual-wield / shield-offhand /
thrown-ranged / 2H polearm to drive the renderer's
attachment-point selection.
Cross-references with prior formats — creatureId points at
WCRT.creatureId, mainHandItemId / offHandItemId / rangedItemId
all point at WIT.itemId, and mainHandVisualId points at
WSVK.visualKitId so brandished weapons can play their
signature glow / aura.
CLI: --gen-ceq (3 generic guard/hunter/rogue starters),
--gen-ceq-bosses (4 iconic loadouts incl. Frostmourne and
Illidan's warglaives, with WSVK visual cross-refs),
--gen-ceq-ranged (3 ranged-only rifle/bow/crossbow loadouts),
--info-wceq, --validate-wceq with --json variants. Validator
catches id=0/duplicates, missing creatureId, all-empty-slots
warning, kFlagDualWield without both hand items, kFlagShield
without offhand item, mutually-exclusive dual-wield + shield,
and 2H polearm with offhand item filled.
Format graph milestone: 50 distinct binary formats. CLI flag
count: 754 → 760.
Walks a directory tree, identifies every file by 4-byte magic,
and renames each one to use the correct .w* extension.
Counterpart to single-file --rename-by-magic for the case
where a whole asset bundle came in with mangled extensions
(extracted from a tarball that lost suffixes, downloaded with
CDN-rewritten names, dumped from a database BLOB column).
Same safety semantics as the single-file flag: conflicts are
skipped without --force, --dry-run prints the planned moves
without touching the filesystem. Reports per-file PASS/FAIL/
CONFLICT and a final summary (renamed / skipped-conflict /
already-correct / unrecognized counts). Exits 1 if any
rename failed (e.g. permission errors) so it can be wired
into CI as a gate.
Closes the JSON round-trip gap on the trade skill recipe
catalog format shipped last batch. --export-wtsk-json emits
all 14 scalar fields plus a dual int + name form for
profession, plus a nested reagents[] array — only non-empty
slots are emitted to keep hand-edits compact.
--import-wtsk-json zeroes the reagent slots before parsing
(so a 2-element reagents array correctly clears slots 2 and
3) and accepts profession by either int or name. Verified
byte-identical round-trip on all three preset emitters
(starter / blacksmithing / alchemy — including recipes with
3 reagent slots populated). 754 documented CLI flags.
New open format — replaces SkillLineAbility.dbc plus the
recipe portions of SkillLine.dbc plus the AzerothCore
trade_skill SQL tables. Closes the crafting gap left by WSKL
(which carries skill lines but not the recipes that bind to
them).
14 professions (Blacksmithing, Tailoring, Engineering,
Alchemy, Enchanting, Leatherworking, Jewelcrafting,
Inscription, Mining, Skinning, Herbalism, Cooking, FirstAid,
Fishing). Each recipe has 4 skill-up bracket thresholds
(orange / yellow / green / gray) for skill-up probability,
a craft spell cross-ref (WSPL), produced item cross-ref
(WIT) with min/max quantity range, an optional tool item,
and up to 4 reagent slots (itemId + count).
Cross-references with prior formats — craftSpellId points at
WSPL.spellId, producedItemId / toolItemId / reagent[].itemId
all point at WIT.itemId, and skillId points at WSKL.skillId.
CLI: --gen-tsk (3-recipe entry-tier starter), --gen-tsk-
blacksmithing (5-recipe progression rough sharpening through
truesilver champion), --gen-tsk-alchemy (5-recipe progression
minor healing through flask of titans), --info-wtsk,
--validate-wtsk with --json variants. Validator catches
id=0/duplicates, profession out of range, missing craft spell
or produced item, monotonic-bracket check (must be orange <=
yellow <= green <= gray), reagent itemId-without-count
mismatch, and free-recipe warning (no reagents and no tool).
Format graph now exposes 49 distinct binary formats. CLI
flag count: 747 → 752.
Closes the JSON round-trip gap on the player condition catalog
format shipped this batch. --export-wpcn-json emits all 11
scalar fields plus dual int + name forms for conditionKind /
comparisonOp / chainOp so hand-edits can use either
representation. --import-wpcn-json accepts either form,
falling back to the int when both are present. Verified
byte-identical round-trip on all three preset emitters
(starter / quest-gates / composite — including chained
conditions referencing other entries by chainNextId). 747
documented CLI flags.
Closes the JSON round-trip gap on the world-state UI catalog
format shipped last batch. --export-wwui-json emits all 11
scalar fields plus dual int + name forms for displayKind and
panelPosition so hand-edits can use either representation.
--import-wwui-json accepts either form, falling back to the
int when both are present, and defaults iconColorRGBA to
0xFFFFFFFF (opaque white) when omitted. Verified
byte-identical round-trip on all three preset emitters
(starter / wintergrasp / dungeon). 740 documented CLI flags.
48th open format — replaces WorldStateUI.dbc plus the
AzerothCore-style world_state SQL data. Defines on-screen UI
elements that surface server-side world-state variables: BG
scoreboards (flag captures, base controls), Wintergrasp tank
counters, Eye of the Storm flag-carrier indicator, dungeon
boss progress, world-event collection trackers.
Each entry binds a server-side variableIndex to a UI panel
kind (counter / timer / flag-icon / progress-bar / two-sided
score / custom) gated by mapId+areaId, with optional
alwaysVisible and hideWhenZero flags and a chosen panel
position (top / bottom / top-left / top-right / center).
Cross-references with prior formats — mapId points at
WMS.mapId and areaId points at WMS.areaId.
CLI: --gen-wsui (3-entry BG scoreboard starter for WSG/AB/
EotS), --gen-wsui-wintergrasp (4-entry full Wintergrasp UI),
--gen-wsui-dungeon (3-entry boss/keys/treasure hunt UI),
--info-wwui, --validate-wwui with --json variants. Validator
catches id=0/duplicates, kind/position out of range,
variableIndex=0 warning, alwaysVisible+hideWhenZero conflict
warning, and (mapId, variableIndex) collision warning when
two entries would read the same server slot on the same map.
Also extends --list-formats and --info-magic with WWUI.
Reads the 4-byte magic of a file, looks it up in the shared
format table, and renames the file to use the correct .w*
extension. Useful when files have lost their extensions
(downloaded as 'data.bin', extracted from a tarball with
mangled metadata, or copied via a tool that strips suffixes).
Safe by default — refuses to overwrite an existing target;
pass --force to allow overwrite. --dry-run prints the planned
move without touching the filesystem. Files that already have
the correct extension are a no-op. Unrecognized magic exits
1 with the bytes printed for diagnostic context.
Reuses cli_format_table.cpp so any future format addition is
picked up automatically.
Recursively walks a directory, identifies every file by 4-byte
magic, and reports per-format file count, total entries, and
bytes. Useful for content audits ("how many cinematics did
this asset bundle ship?") and for tracking migration progress
("what fraction of zones still lack a holiday catalog?").
Also extracts the format-magic table out of cli_info_magic.cpp
into a shared cli_format_table.{hpp,cpp} so --info-magic and
--summary-dir reuse the same source of truth — adding a new
format now updates one row in one file instead of two. Both
flags use the standard catalog header (magic + version + name
+ entryCount) for catalog formats; asset/world formats are
counted but report 0 entries since their headers differ.
Supports --json variant for tooling integration.
Closes the JSON round-trip gap on the spell visual kit catalog
format shipped this batch. --export-wsvk-json emits all 12
scalar fields and 4 model-path strings. WSVK has no enum
fields, so the JSON mapping is a straight-through dump with
no name-form widening. --import-wsvk-json parses it back,
defaulting unset fields to 0/empty. Verified byte-identical
round-trip on all three preset emitters (starter / combat /
utility). 731 documented CLI flags.
47th open format — replaces SpellVisualKit.dbc +
SpellVisualEffectName.dbc plus the AzerothCore-style spell
visual SQL data. Defines per-spell visual presentations:
cast-bar effect model, projectile model + travel speed +
arc gravity, impact effect model, hand effect on the caster,
and the animations + sounds that fire at cast / channel /
impact time.
Cross-references with prior formats — castAnimId / impactAnimId
/ precastAnimId point at WANI.animationId, castSoundId /
impactSoundId point at WSND.soundId. Spell catalogs (WSPL)
will reference visualKitId here to bind "what mechanically
happens" to "what plays visually."
CLI: --gen-svk (3-kit Frostbolt/Fireball/HealingTouch starter
showing projectile + AoE + heal patterns), --gen-svk-combat
(5 melee/ranged with WANI animation refs), --gen-svk-utility
(4 portal/hearth/mount/resurrect with no projectile),
--info-wsvk, --validate-wsvk with --json variants. Validator
catches id=0/duplicates, missing name, negative speeds/radii,
projectile-model + speed coherence (model without speed =
never travels; speed without model = invisible), and a
no-effect catch-all (no models + no anims + no sounds).
Closes the JSON round-trip gap on the animation catalog format
shipped last batch. --export-wani-json emits all 8 scalar
fields plus a dual int + name form for behaviorTier so
hand-edits can use either representation. --import-wani-json
accepts either form, falling back to the int when both are
present, and defaults weaponFlags to kWeaponAny when omitted
to preserve compatibility with hand-authored sidecars that
forget to specify it. Verified byte-identical round-trip on
all three preset emitters (starter / combat / movement).
724 documented CLI flags.
46th open format — replaces AnimationData.dbc plus the
hard-coded animation-id tables in M2 model loaders. Defines
named animations (Stand, Walk, Run, Cast, Death, MountIdle,
Fly, ...) with fallback chains, behavior tier (default /
mounted / sitting / aerial / swimming), and weapon-flag
bitmasks that select the correct animation variant when the
model wields 1H / 2H / dual / bow / rifle / wand / etc.
Cross-references with prior formats — fallbackId resolves
within the same WANI catalog (graceful degradation when the
requested animation is absent: Run falls back to Walk,
Attack2H falls back to Attack1H).
10 weapon-flag constants + 6 behavior flags (Looped,
BlendableCycle, Interruptable, MovementSync, OneShot,
PreserveAtEnd). 5 behavior tiers. CLI: --gen-animations
(5 essentials), --gen-animations-combat (8 weapon-typed
attacks + parry + channel), --gen-animations-movement (6
locomotion anims with tier transitions). Validator catches
id-uniqueness, fallback-self-loop, looped-without-duration,
mutually-exclusive Looped+OneShot flags, weaponFlags=0
warning, and unresolved fallback warnings.
Also extends --list-formats and --info-magic with WANI.
Reads the first 4 bytes of any file, looks the magic up in
the format table, and reports: format name, file extension,
category, plus the standard catalog header fields (version,
catalog name, entry count) for any of the 33 catalog formats
that share the magic+version+name+entryCount layout.
Also suggests the matching --info-* flag so users who receive
.w* files without context can route to the right inspector
in one step. World/asset formats (WOM/WOB/WHM/WOT/WOW) are
recognized by magic but the catalog-style header probe is
skipped (their layouts differ).
Returns exit 1 + 'unrecognized' message on non-Wowee files.
Supports --json variant for tooling integration.
New top-level CLI flag prints a table of every novel open
format the project ships: 4-char binary magic, file extension,
category label, the proprietary file(s) it replaces, and a
one-line description. 44 formats total covering 5 world/asset
foundations (.wom / .wob / .whm / .wot / .wow) and 39 catalog
DBC/SQL replacements.
Also exposes formats not previously surfaced via --gen-* flags
(WFAC factions, WLCK locks, WSKL skills, WOLA outdoor light,
WOWA weather, WMPX world map) — these are loaded directly by
the engine. Supports --json variant for tooling integration.
Closes the JSON round-trip gap on the liquid catalog format
shipped this batch. --export-wliq-json emits all 14 scalar
fields (incl. 3-byte fog RGB) plus a dual int + name form for
liquidKind so hand-edits can use either representation.
--import-wliq-json accepts either form, falling back to the
int when both are present. Verified byte-identical round-trip
on all three preset emitters (starter / magical / hazardous).
716 documented CLI flags.
Closes the JSON round-trip gap on the holiday catalog format
shipped last batch. --export-whol-json emits all 13 scalar
fields plus dual int + name forms for holidayKind and
recurrence so hand-edits can use either representation.
--import-whol-json accepts either form, falling back to the
int when both are present. Verified byte-identical round-trip
on all three preset emitters (starter / weekly / special).
709 documented CLI flags.
44th open format — replaces Holidays.dbc + HolidayDescriptions.dbc
+ HolidayNames.dbc plus the AzerothCore-style game_event SQL
tables. Defines time-gated world events: seasonal holidays
(Hallow's End / Brewfest / Winter Veil), weekly call-to-arms BG
bonuses, world-PvP windows (Wintergrasp), one-shot specials, and
recurring daily / weekly resets. Each holiday has a recurrence
rule (Annual / Monthly / WeeklyRecur / OneTime), a calendar
window (startMonth + startDay + durationHours), and optional
cross-refs to a feature creature, an intro quest, and a token /
item reward issued during the window.
Cross-references with prior formats — holidayQuestId points at
WQT.questId, bossCreatureId points at WCRT.creatureId,
itemRewardId points at WIT.itemId, and areaIdGate / mapIdGate
point at WMS.areaId / WMS.mapId.
CLI: --gen-holidays (3 seasonal starter), --gen-holidays-weekly
(3 weekly BG call-to-arms windows), --gen-holidays-special (3
world-PvP / lunar / children events), --info-whol, --validate-whol
with --json variants. Validator catches id=0/duplicates, kind /
recurrence out of range, durationHours=0, invalid month/day for
non-weekly recurrence, and calendar-only events (no quest +
boss + reward) as a warning.
Closes the JSON round-trip gap on the vehicle catalog format
shipped last batch. --export-wvhc-json emits all 10 scalar
fields plus a nested array of seats per entry, and dual int +
name forms for vehicleKind / movementKind / powerType so
hand-edits can use either representation. --import-wvhc-json
accepts either form, falling back to the int when both are
present, and reconstructs the seat array preserving seat
flags / attachments / control-spell cross-refs. Verified
byte-identical round-trip on all three preset emitters
(starter / siege / flying), including nested seat data. 702
documented CLI flags.
Closes the JSON round-trip gap on the glyph catalog format
shipped last batch. --export-wgly-json emits all 8 scalar
fields plus a dual int + name form for glyphType so hand-edits
can use either representation. --import-wgly-json accepts
either form, falling back to the int when both are present.
Verified byte-identical round-trip on all three preset emitters
(starter / warrior / universal). 700 documented CLI flags.
43rd open format — replaces Vehicle.dbc + VehicleSeat.dbc plus
the AzerothCore-style vehicle_template SQL tables. Defines
drivable vehicles: tanks, demolishers, motorcycles, gryphons,
choppers, siege weapons, multi-passenger transports. Each entry
pairs a creature template (the rendered model) with a fixed
seat layout — driver / passenger / gunner seats with their own
attachment points, control flags (kSeatDriver / kSeatGunner /
kSeatPassenger / kSeatHidesPlayer / kSeatNoEjectByCC), and
per-seat abilities mounted to the action bar.
Cross-references with prior formats — creatureId points at
WCRT.creatureId (the rendered model), flightCapabilityId points
at WMNT.mountId for shared fly-speed tables, and per-seat
controlSpellId / exitSpellId point at WSPL.spellId.
CLI: --gen-vehicles (3-vehicle starter chopper/wind-rider/tank),
--gen-vehicles-siege (3 siege weapons with control spellIds),
--gen-vehicles-flying (3 flying mounts cross-ref WMNT
flightCapabilityIds), --info-wvhc, --validate-wvhc with --json
variants. Validator catches id=0/duplicates, missing creature,
enum out-of-range, empty seat list, flying-vehicle on wrong
movement (would fall through world), driver-flag exclusivity
(0 or >1 drivers), and duplicate seatIndex within a vehicle.
Closes the JSON round-trip gap on the cinematic catalog format
shipped two batches ago. --export-wcms-json emits all 9 scalar
fields plus dual int + name forms for kind and triggerKind so
hand-edits can use either representation. --import-wcms-json
accepts either form, falling back to the int when both are
present. Verified byte-identical round-trip on all three preset
emitters (starter / intros / quests).
42nd open format — replaces GlyphProperties.dbc + GlyphSlot.dbc
plus the AzerothCore-style glyph_properties SQL table. Defines
the WotLK glyph system: per-class inscribable glyphs that
modify spell behavior. Each entry pairs a glyph item (the
inscriber's craft output) with the spell aura that applies the
modification, tagged with a Major / Minor / Prime slot type and
a classMask of allowed classes.
Cross-references with prior formats — spellId points at
WSPL.spellId (the aura), itemId points at WIT.itemId (the
inscribed item), and classMask bit positions match the WCHC
classId enum (1=Warrior, 2=Paladin, 3=Hunter, etc).
CLI: --gen-glyphs (3-entry per-role starter), --gen-glyphs-warrior
(6-entry full warrior allotment), --gen-glyphs-universal (4
classMask=All utility glyphs), --info-wgly, --validate-wgly with
--json variants. Validator catches id=0/duplicates, empty name,
spellId=0 (glyph applies no aura), classMask=0 (no class can
inscribe), itemId=0 warning, requiredLevel<25 warning (below
WotLK glyph threshold), and glyphType out-of-range.
Closes the JSON round-trip gap on the channels catalog format
shipped last batch. --export-wchn-json emits all 10 scalar fields
plus dual int + name forms for channelType and factionAccess so
hand-edits can use either representation. --import-wchn-json
accepts either form, falling back to the int when both are
present. Verified byte-identical round-trip on all three preset
emitters (starter / city / moderated).
41st open format — replaces Movie.dbc / CinematicCamera.dbc /
CinematicSequences.dbc plus the AzerothCore cinematic_camera SQL
table. Defines pre-rendered videos, in-engine camera flythroughs,
text crawls, and still images, each with a media path, duration,
skippable flag, and a polymorphic trigger that fires on quest
events / class first-login / zone entry / dungeon clear /
achievements / level milestones.
Cross-references with prior formats — triggerTargetId resolves
by triggerKind to WQT.questId / WMS.areaId / WMS.mapId /
WCHC.classId / WACH.achievementId, and soundtrackId points at
WSND.soundId.
CLI: --gen-cinematics (3-entry starter), --gen-cinematics-intros
(4 class intros), --gen-cinematics-quests (3 quest-bound
cinematics referencing demo questIds 1/100/102), --info-wcms,
--validate-wcms with --json variants. Validator catches
id=0/duplicates, empty name/mediaPath, kind/trigger out of
range, missing target id for non-Manual/Login/LevelUp triggers,
zero-duration entries, and non-skippable pre-rendered videos.
Closes the WAUC open-format loop with --export-wauc-json /
--import-wauc-json, mirroring the JSON pairs added for
every other novel binary format. All 33 binary formats
added since WOL now have full JSON round-trip authoring.
Each house round-trips all 14 scalar fields plus the
factionAccess enum dual int + name forms (alliance / horde
/ neutral / both).
Verified byte-identical round-trip on the faction-pair
preset (3 houses including Stormwind/Orgrimmar/Booty Bay
with different cut rates and auctioneer NPC IDs preserved
through the JSON layer).
Adds 2 flags (679 documented total now).
Closes the WPET open-format loop with --export-wpet-json /
--import-wpet-json, mirroring the JSON pairs added for
every other novel binary format. All 32 binary formats
added since WOL now have full JSON round-trip authoring.
Two top-level arrays mirror the binary layout:
• families[] — familyId / name / description / icon /
petType (dual int + name) /
baseAttackSpeed / damageMultiplier /
armorMultiplier / dietMask + name /
abilities[]
• minions[] — minionId / name / summonSpellId /
creatureId / abilities[]
Verified byte-identical round-trip on the starter preset
(2 hunter families with 3 abilities each + 1 warlock Imp
with 2 abilities including autocast preferences preserved
through the JSON layer).
Adds 2 flags (672 documented total now).
Novel open replacement for Blizzard's AuctionHouse.dbc +
the AzerothCore-style auctionhouse / auctionhousebot SQL
tables. The 39th open format added to the editor.
Defines per-house rules for the auction system: faction
access, deposit rate (basis points of buyout price), house
cut on successful sale, three listing duration tiers with
per-tier deposit multipliers, disallowed item-class bitmask,
and the auctioneer NPC.
Cross-references with previously-added formats:
WAUC.entry.auctioneerNpcId -> WCRT.entry.creatureId
(Auctioneer-flagged NPC)
WAUC.entry.disallowedClassMask
bitmask of WIT.Class values
that may not be auctioned at
this house
The faction-pair preset captures the canonical asymmetry:
faction houses charge 5% on a successful sale while neutral
houses charge 15% — the cross-faction tax that makes
neutral AHs profitable for goblins.
Format:
• magic "WAUC", version 1, little-endian
• per house: houseId / auctioneerNpcId / name /
factionAccess / baseDepositRateBp / houseCutRateBp /
maxBidCopper / 3 duration hours + 3 deposit multipliers /
disallowedClassMask
Enums:
• FactionAccess (4): Alliance / Horde / Neutral / Both
• Rates use basis points: 10000 = 100%
API: WoweeAuctionLoader::save / load / exists / findById.
Three preset emitters showcase typical auction setups:
• makeStarter — 1 neutral house with default 12h /
24h / 48h tiers
• makeFactionPair — 3 houses (Stormwind / Orgrimmar /
Booty Bay) with auctioneer NPC IDs
+ canonical faction-vs-neutral cut
rates
• makeRestricted — 1 house disallowing Containers (1) +
Quest items (12) + Keys (13) with
tighter durations + 1000g bid cap
CLI added (5 flags, 670 documented total now):
--gen-auction / --gen-auction-pair / --gen-auction-restricted
--info-wauc / --validate-wauc
Validator catches: houseId=0 + duplicates, empty name,
factionAccess out of range, duration tier=0, durations not
in short<=medium<=long order, houseCutRateBp >= 100% (seller
loses money on a sale), warns on >50% cut.
Closes the WPCD open-format loop with --export-wpcd-json /
--import-wpcd-json, mirroring the JSON pairs added for
every other novel binary format. All 31 binary formats
added since WOL now have full JSON round-trip authoring.
Each condition round-trips all 9 scalar fields. Two
enum-typed fields emit dual int + name forms:
• kind (true / false / quest-done / has-item /
min-level / class / event / area / title / ...)
• aggregator (and / or)
Verified byte-identical round-trip on the gated preset
(5 conditions in 2 groups demonstrating both AND and OR
aggregation, with full polymorphic targetId / minValue /
maxValue payload preserved through the JSON layer).
Adds 2 flags (665 documented total now).
Novel open replacement for AzerothCore-style pet_template +
pet_levelstats SQL + the pet-related subsets of
CreatureFamily.dbc + SpellFamilyName.dbc. The 38th open
format added to the editor.
Defines two related kinds of player-controlled NPCs in
one catalog:
• Pet families — hunter pet families (Wolf / Cat / Bear /
Boar / Raptor / Spider / etc.) with
per-family ability sets, base stat
multipliers, and diet preferences
• Warlock minions — Imp / Voidwalker / Succubus /
Felhunter / Felguard, each with
their own summon spell, creature
template, and ability list
Cross-references with previously-added formats:
WPET.family.familyId -> WCRT.entry.familyId
(matches creature family)
WPET.family.abilities.spellId -> WSPL.entry.spellId
WPET.minion.summonSpellId -> WSPL.entry.spellId
WPET.minion.creatureId -> WCRT.entry.creatureId
(used for stat scaling)
WPET.minion.abilities.spellId -> WSPL.entry.spellId
The starter preset's familyIds (1=Wolf, 2=Cat) match
WCRT::FamilyId enum values, so a hunter taming a wolf via
WCRT links straight through to WPET ability sets.
Format:
• magic "WPET", version 1, little-endian
• families[]: familyId / name / description / icon /
petType / baseAttackSpeed / damageMultiplier /
armorMultiplier / dietMask / abilities[]
• minions[]: minionId / name / summonSpellId / creatureId /
abilities[] (each: spellId / rank / autocastDefault)
Enums:
• PetType (3): Cunning / Ferocity / Tenacity
(WotLK+ talent tree categorization)
• DietFlags: Meat / Fish / Bread / Cheese / Fruit / Fungus
API: WoweePetLoader::save / load / exists +
WoweePet::findFamily / findMinion + dietMaskName helper
that decodes a dietMask into a "meat+fish" string.
Three preset emitters showcase typical pet catalogs:
• makeStarter — 2 hunter families (Wolf + Cat) with full
3-ability sets + 1 warlock Imp
• makeHunter — 8 classic hunter families covering all
3 petType categories with appropriate
diet masks
• makeWarlock — 5 warlock minions each with summon spell
ID and creatureId pointing into WCRT
CLI added (5 flags, 663 documented total now):
--gen-pets / --gen-pets-hunter / --gen-pets-warlock
--info-wpet / --validate-wpet
Validator catches: ids=0 + duplicates, empty name, petType
out of range, baseAttackSpeed<=0 (would divide by zero in
DPS calc), dietMask=0 (pet cannot be fed for happiness),
minion missing summonSpellId / creatureId.
Closes the WGLD open-format loop with --export-wgld-json /
--import-wgld-json, mirroring the JSON pairs added for
every other novel binary format. All 30 binary formats
added since WOL now have full JSON round-trip authoring.
Each guild round-trips header scalars (12 fields) plus the
4 sub-arrays:
• ranks[] — rank ladder with permissions + money cap
• members[] — character roster with rank + notes
• bankTabs[] — per-tab name + 3 permission masks
• perks[] — purchased buffs with WSPL spell refs
factionId emits dual int + name forms (alliance / horde).
Verified byte-identical round-trip on the full preset
(1 guild with 6 ranks + 8 members + 4 bank tabs + 3
perks; all permission masks and per-rank money caps
preserved through the JSON layer).
Adds 2 flags (658 documented total now).
Novel open replacement for Blizzard's PlayerCondition.dbc +
the AzerothCore-style condition_template SQL tables. The
37th open format added to the editor.
Defines reusable boolean conditions that other formats can
reference for gating: "player has quest X completed",
"player level >= N", "player class is mage", "player has
item Y in inventory", "WSEA event Z is active".
Conditions can be grouped and combined with AND/OR
aggregators on a per-group basis: a quest-giver gossip
option that says "show only to level 60 alliance mages
who completed quest 1234" composes 4 conditions sharing
the same groupId with AND aggregation. The runtime walks
each group, applies the group's aggregator, and returns
the boolean result to the caller.
Cross-references with previously-added formats — the
targetId field has a polymorphic interpretation by kind:
WPCD.targetId (kind=QuestCompleted/Active) -> WQT.questId
WPCD.targetId (kind=HasItem) -> WIT.itemId
WPCD.targetId (kind=HasSpell) -> WSPL.spellId
WPCD.targetId (kind=HasAchievement) -> WACH.achievementId
WPCD.targetId (kind=AreaId) -> WMS.areaId
WPCD.targetId (kind=EventActive) -> WSEA.eventId
WPCD.targetId (kind=HasTitle) -> WTIT.titleId
WPCD.targetId (kind=FactionRep) -> WFAC.factionId
WPCD.targetId (kind=Class/Race) -> WCHC class/race id
Future format extensions can reference WPCD.conditionId in
their own gating fields — WTRG triggers gated by player
state, WGSP options visible only when conditions are met,
WMOU summon spells condition-gated by quest progress, etc.
Format:
• magic "WPCD", version 1, little-endian
• per condition: conditionId / groupId (0 = standalone) /
name / description / kind / aggregator / negated /
targetId / minValue / maxValue
Enums:
• Kind (17): AlwaysTrue / AlwaysFalse / QuestCompleted /
QuestActive / HasItem / HasSpell / MinLevel /
MaxLevel / ClassMatch / RaceMatch /
FactionRep / HasAchievement / TeamSize /
GuildLevel / EventActive / AreaId / HasTitle
• Aggregator (2): And / Or
API: WoweeConditionLoader::save / load / exists / findById.
Three preset emitters showcase typical usage:
• makeStarter — 4 standalone conditions covering the most
common kinds (quest-done / has-item /
min-level / class)
• makeGated — 5 conditions in 2 groups demonstrating
AND-aggregation (alliance + mage + lvl 60)
and OR-aggregation (did quest 1 OR quest 100)
• makeEvent — 3 event-gated conditions cross-referencing
WSEA event IDs (Hallow's End / Brewfest /
Winter's Veil)
CLI added (5 flags, 656 documented total now):
--gen-conditions / --gen-conditions-gated / --gen-conditions-event
--info-wpcd / --validate-wpcd
Validator catches: conditionId=0 + duplicates, kind /
aggregator out of range, kinds requiring targetId having
target=0 (skips AlwaysTrue/False, MinLevel/MaxLevel,
TeamSize, GuildLevel which use min/max instead), TeamSize
with min > max.
Closes the WGEM open-format loop with --export-wgem-json /
--import-wgem-json, mirroring the JSON pairs added for
every other novel binary format. All 29 binary formats
added since WOL now have full JSON round-trip authoring.
Two top-level arrays mirror the binary layout:
• gems[] — gemId / itemIdToInsert / name / color
(dual int + name) / statType+Value /
requiredItemQuality / spellId
• enchantments[] — enchantId / name / description / icon /
enchantSlot (dual int + name) /
statType+Value / spellId / duration /
chargeCount
Verified byte-identical round-trip on the enchants preset
(5 enchantments including 3 proc-based with WSPL spellId
cross-refs in the 28000-29000 placeholder range, plus
ring/cloak slot variants with chargeCount preserved).
Adds 2 flags (651 documented total now).
Closes the WMAL open-format loop with --export-wmal-json /
--import-wmal-json, mirroring the JSON pairs added for
every other novel binary format. All 28 binary formats
added since WOL now have full JSON round-trip authoring.
Each template round-trips all 11 scalar fields plus the
variable-length attachments array. categoryId emits dual
int + name forms (quest / auction / gm / achievement /
event / raffle / script / returned).
Verified byte-identical round-trip on the holiday preset
(4 templates with full WIT itemId attachments matching
WTKN seasonal token IDs preserved through the JSON layer).
Adds 2 flags (644 documented total now).
Novel open replacement for Blizzard's ItemEnchantment.dbc +
GemProperties.dbc + SpellItemEnchantment.dbc. The 35th
open format added to the editor.
Defines two related kinds of item enhancement in one
catalog:
• Gems — socketable jewelry pieces with color
(red / blue / yellow / meta) that fit
into gear sockets, granting stats or
triggering passive spells when socketed
• Enchantments — persistent buffs applied to weapon /
armor pieces, either by an enchanter
spell or by an item proc (Mongoose,
Crusader, Berserking)
Cross-references with previously-added formats:
WGEM.gem.itemIdToInsert -> WIT.entry.itemId
WGEM.gem.spellId -> WSPL.entry.spellId
WGEM.enchantment.spellId -> WSPL.entry.spellId
Format:
• magic "WGEM", version 1, little-endian
• gems[]: gemId / itemIdToInsert / name / color /
statType + statValue / requiredItemQuality / spellId
• enchantments[]: enchantId / name / description /
iconPath / enchantSlot / statType + statValue /
spellId / durationSeconds / chargeCount
Enums:
• Color (8): Meta / Red / Yellow / Blue / Purple /
Green / Orange / Prismatic
• EnchantSlot (5): Permanent / Temporary / SocketColor /
Ring / Cloak
API: WoweeGemLoader::save / load / exists +
WoweeGem::findGem / findEnchant.
Three preset emitters showcase common shapes:
• makeStarter — 3 gems (one per primary color) +
2 enchantments (proc + stat)
• makeGemSet — 6-gem full color palette covering
primary + secondary combinations
• makeEnchants — 5 enchant variants spanning slots
(Mongoose / Deadly Poison / stats ring /
cloak / Berserking)
CLI added (5 flags, 642 documented total now):
--gen-gems / --gen-gems-set / --gen-gems-enchants
--info-wgem / --validate-wgem
Validator catches: ids=0 + duplicates, empty name, color /
slot out of range, stat-only entries with statValue=0 (gem
provides nothing), chargeCount > 0 on non-Temporary
enchant slots (charges silently ignored at runtime).
The validator caught a real preset issue on first run —
the proc enchants (Mongoose / Deadly Poison / Berserking)
had spellId=0 and statValue=0, providing nothing. Fixed by
adding placeholder spellIds in the 28000-29000 range, with
a comment noting they resolve to real WSPL proc spells
when the spell catalog is extended.
Closes the WBGD open-format loop with --export-wbgd-json /
--import-wbgd-json, mirroring the JSON pairs added for
every other novel binary format. All 27 binary formats
added since WOL now have full JSON round-trip authoring.
Each battleground round-trips all scalar fields plus the
allianceStart and hordeStart vec3 + facing pairs (positions
become 3-element JSON arrays for natural hand-edit). The
objectiveKind enum emits dual int + name forms.
Verified byte-identical round-trip on the classic preset
(3 BGs spanning CTF / control nodes / resource race
objectives with full WMS map + WTKN markTokenId
cross-refs preserved through the JSON layer).
Adds 2 flags (637 documented total now).
