Preview: watch it on YouTube.
One AzerothCore module for scaling, with a Simple and an Advanced setting wherever it applies.
| Where | Simple | Advanced |
|---|---|---|
| Instances (dungeons, raids) | Players get stats and spell power for every missing player (SoloCraft style) | Creatures get less health, damage and mana for fewer players (AutoBalance style) |
| Open world (each player picks) | Creatures trail behind your level anywhere, 3 levels by default (Ascension style) | Creatures trail behind you inside each zone's level window, with per row trail, health, damage and XP floor |
Extras:
- Level scaling in instances: creature levels move with the group, inside a level window per instance. Every creature moves by the same amount, so bosses stay above their trash.
- Enter at any level: per instance
entry_level_minreplaces the core level requirement (1 = any level). - Dungeon respawn (DungeonRespawn style): release your spirit inside an instance and you come back alive
at the instance entrance. The entrance comes from
areatrigger_teleport, so no coordinates need typing. A map row can set manual coordinates instead. - XP always awarded: gray kills and low quests still give some XP in scaled zones.
- Player choice: each player picks
.scaling simple,.scaling advancedor.scaling offfor the open world; the server decides if they may and the default (Simple). With scaling off, creatures keep their levels, and those 5 or more levels below you give no quest progress or quest items (World.Off.NoQuestCreditLevels). - Quest level requirements: by a quest giver in a scaled place, Simple players can take quests at any level and
Advanced players from the zone's
level_min. This uses theOnPlayerGetQuestMinLevelcore hook when CMake finds it (mod-dynamic-scaling.cmake); without it, quests of scaled zones are lowered in memory for everyone at startup, followingPlayerToggle.Default. - Rewards follow the scaled level: within a margin (3 levels by default) rewards stay normal. Beyond it, quests far above you give the XP and money of a quest at the margin, a creature's gold follows its scaled level, its level range loot tables ("Vanilla Greens 8-12 Level Range") swap to those of its scaled level, and a creature scaled down drops no items far above it.
- Cooldown resets: defeating a boss, or wiping on it after 30 seconds, resets
everyone's cooldowns and clears Sated / Exhaustion. Per instance kind (dungeons, heroic dungeons, 10 / 25 player
raids, heroic raids) and per creature kind (bosses, world bosses, elites, rares), in the config or the database.
Battlegrounds (when the gates open), arenas (on entering) and duels (when one ends, only the cooldowns used in it)
can reset cooldowns too, and
dynamic_scaling_cooldown_spellsays which spells are always or never reset where. - No level up effect: a creature changing level is sent again to whoever sees it, instead of "dinging"
(
World.SilentLevelChange).
When both modules run and both collective switches are on (DynamicScaling.Collective.WorldRandomizer here,
Randomizer.Collective.DynamicScaling there, both on by default), each module reads the other's settings from the
config, and they split the work:
- the randomizer writes each dungeon's bracket (from its entrance zone) to
world_randomizer_dungeon_bracketat startup and stops shifting dungeon levels itself, - this module reads it at startup and scales those dungeons in Simple mode, to the group's level but inside that bracket: Ragefire Chasm in a 31-40 bracket scales between 31 and 40,
- the open world scales inside each zone's bracket (
DynamicScaling.Collective.WorldScaling, on by default): creatures follow each player's level and.scalingchoice but never leave the bracket the randomizer gave the zone, and the randomizer stops remapping open world levels. With it off, open world scaling here is off and the randomizer sets zone levels.
Turn either switch off and the two modules ignore each other.
After updating the module, the
config update page brings your
mod-dynamic-scaling.conf to the newest layout: drop the file on it, your values are kept, new settings get their
default, and you download the new file plus the old one as a backup. It runs in your browser; nothing is uploaded.
It is part of the mod-world-randomizer website
(to run it locally, see that repository).
The most specific row wins:
dynamic_scaling_zonerow for the area (for example Northshire Valley)dynamic_scaling_zonerow for the zone (for example Elwynn Forest)dynamic_scaling_maprow for the map: an instance (per difficulty, or 255 for all) or a whole continent- The defaults in
mod-dynamic-scaling.conf
level_min / level_max work the same in both tables:
| Value | Meaning |
|---|---|
N |
Creatures never go below / above level N |
0 |
Creatures never go below / above their own level |
0 and 0 |
Creatures keep their own level (cities, starting areas) |
So level_min = 0, level_max = 80 means "only scale up", and level_min = 1, level_max = 0 means "only scale down".
dynamic_scaling_map(world DB): per instance + difficulty, or per continent. Instances with no row use the config defaults, which scale every instance from level 1 to 80 in Simple mode.dynamic_scaling_zone(world DB): per zone or area. Ships with every outdoor zone and its level range taken from your aowow (Stuff/zone-extract), with cities, starting areas, Wintergrasp and the Scarlet Enclave at0/0.dynamic_scaling_creature(world DB): creature entries that always (scale1) or never (0) scale in the open world, over every category rule.dynamic_scaling_category(world DB): which kinds of creature scale, used instead ofWorld.NeverScalewhenWorld.UseDBOverride = 1.dynamic_scaling_cooldown_rule(world DB): the cooldown reset switches, used instead of the config whenCooldownReset.UseDBOverride = 1.dynamic_scaling_cooldown_reset(world DB): creatures that always (reset1) or never (0) reset cooldowns, and encounters that don't.dynamic_scaling_cooldown_spell(world DB): spells and spell categories always (reset_in) or never (never_in) reset, per place: 1 instance, 2 battleground, 4 arena, 8 duel, added up.dynamic_scaling_player(characters DB): each player's.scalingchoice (enabled: 0 off, 1 Simple, 2 Advanced).spell_dbc150100: the server side aura that carries the Simple mode stat buff.
The SQL in data/sql is applied by the core's DB updater (or dbimport) like any module.
| Command | Who | What |
|---|---|---|
.scaling [simple|advanced|off] |
players | Show or change your own open world scaling |
.dscale info |
GM | Settings for your map / zone, and for the selected creature |
.dscale reload |
admin | Reload both tables; creatures rescale once out of combat |
.dscale rescale |
GM | Rescale the selected creature on its next update |
.dscale lootswap <reference> [level] |
GM | Which level range loot table a scaled creature rolls instead |
Config changes need .reload config.
tools/DynamicScaling_Curve_Worksheet.xlsx (like AutoBalance's Curve Worksheet): change the yellow cells to see
the Advanced instance multipliers for every group size (curve or straight line, bosses too), the Simple buff, and
open world creature levels and rewards for every player level. It uses the same math as the module.
Google Sheets version: make your own copy.
addon/DynamicScaling is a client addon (3.3.5): copy it to Interface/AddOns, or unzip
DynamicScaling.zip from the repository's Releases there. New addon versions are released by hand: Actions >
Addon release > Run workflow with the version (a whole number), which writes it to the .toc, the addon's
ADDON_VERSION and the module's DS_ADDON_VERSION, commits that, then makes the v<version> release with the zip
(.github/workflows/addon-release.yml; leave the version empty to release the current one). If the addon and the
module expect different versions, the addon shows a popup with the link to the right release. On login it asks which
leveling
experience you want (No Scaling, Simple or Advanced), with "Do not ask again on next login" (this character) and "Do not
ask on new characters" (every character). /dscale opens a window with your choice and the creatures around you: their
own level, and what they would be for you in Simple and Advanced. It talks to the server with addon whispers (prefix
DSCALE, see src/DynamicScalingAddon.cpp). If the server doesn't answer within 10 seconds of logging in (no module,
or it's off), the addon turns itself off until the next login. The addon and the module share a version number
(ADDON_VERSION in the addon, DS_ADDON_VERSION in src/DynamicScalingAddon.cpp); a player with another version is
told in chat to update. A minimap button (drag it around; right-click for
options) opens the window, and the addon has a page in Interface > AddOns (minimap button on / off).
- Creature levels go through the core's
SelectLevel(). The module only picks the level, so health, mana, damage, attack power and armor come fromcreature_classlevelstatsexactly like an unscaled creature of that level. Multipliers go on top. - Instance creatures rescale (out of combat) when players join, leave or level up.
- Open world creatures check for players nearby every
World.UpdateIntervalms and only change while out of combat, at most once perWorld.RescaleCooldown. Creatures with NPC flags, civilians, critters, triggers and unattackable creatures are left alone. - A creature's level is shared by everyone who sees it (3.3.5 clients get one level per creature), so the reference player is the nearest one by default, or the group average, and that player's choice (Simple or Advanced) decides how it scales.
- Creatures look for players within
World.Rangeyards; 0 (the default) means the map's visibility distance, so every creature you can see scales to you. - In a zone row,
mode0 or a0/0window means "never scaled"; any other row is scaled the way the player chose. Simple ignores the window; Advanced uses it and the row's other fields.
data/sql/drop_remove_uninstall/ has a world.sql and a characters.sql that take the module back out: they drop its
tables, remove its custom spells (and any saved auras of them) and its rows in updates, so a later reinstall starts
clean. Creature levels and stats, instance entry levels and respawn points are only changed in memory, so they are the
core's again once the module is gone.
- Take the module out of the build (move it out of
modules/, or add it to-DDISABLED_AC_MODULES) and rebuild. With the module still built, the DB updater installs everything again on the next start. - Run
world.sqlon the world database andcharacters.sqlon the characters database.
- Scaling works however you enter an instance (walking in or the Dungeon Finder).
entry_level_minandInstance.DefaultEntryLevelopen a dungeon both at the entrance and in the Dungeon Finder, but the "Random Dungeon" queues keepLFGDungeons.dbc's level ranges, and raids aren't in the 3.3.5 Dungeon Finder at all. - The client hides the Dungeon Finder below level 15.
Instance.LFG.UILevellowers that only for players with the DynamicScaling addon. - Entry levels are written over the access requirements the core loaded, in memory. A core
.reloadof those requirements undoes them until.dscale reload. - A creature has one level for everyone (the 3.3.5 client shows one level per creature): it follows the player it is fighting, or the nearest player / group average out of combat.
- Spell hit chance and aggro range still follow the creature's level, as in the core.
- The loot swap only replaces the "... Level Range" reference tables; creature specific drops stay, and items in equal chance loot groups skip the item level filter.
- Gray kill XP goes to the killer and nearby group members only, split evenly.
Ideas and mechanisms from:
- mod-solocraft: the per-missing-player stat buff and the "flat spell power only" rule.
- mod-autobalance: scaling creatures through the
SelectLevelhooks and the damage hooks. - DungeonRespawn by AnchyDev: respawning inside the instance after releasing.
- sogladev: the cooldown reset mechanic (boss encounter and wipe triggers, the wipe timer, what gets reset) and the list of raid bosses and encounters.
- TrinityCore's level scaling (
Creature::GetLevelForTarget/ content tuning) was read for comparison; it needs per-player levels that a 3.3.5 client can't show, so this module uses one level per creature instead.
Made with the help of Claude, Anthropic's AI assistant: written and reviewed together with it, then tested and published by Ryan Turner (TheSCREWEDSoftware).
