Paragon: cross-class stance exclusivity + cancel, hunter ammo soft-fail, Feral Cat scaling, Pestilence DP spread

Server-side batch following v0.7.18, all gated to Paragon (or applied
server-wide where the design discussion called for it):

* Cross-class stance / form / presence / aspect exclusivity (server-wide).
  New `IsFracturedExclusiveStanceSpell()` (`Unit.cpp`/`Unit.h`) returns
  true for the union of warrior stances + druid forms (combat AND utility:
  Travel, Aquatic, Flight, Swift Flight) + Ghost Wolf + base Stealth +
  Shadowform + Metamorphosis + DK Presences + Hunter Aspects (combat AND
  utility: Cheetah, Pack). `Aura::CanStackWith` (`SpellAuras.cpp`) refuses
  to stack two spells from this set, which routes through
  `_RemoveNoStackAurasDueToAura` to drop the older aura -- the same
  mechanism Battle Elixirs / Curses use. Plugs the stock-AC gap where DK
  Presences and Hunter Aspects (regular auras, just rendered in the
  stance bar) coexisted with engine-shapeshifts.

* Stances / Presences / Aspects cancellable like Druid forms.
  `SpellInfoCorrections.cpp` now zeroes `CategoryEntry` on warrior
  stances, DK presences, and every rank of every hunter aspect (moves
  them out of SpellCategory 47 "Combat States", which gates the client's
  right-click / `/cancelaura` path), AND clears `AttributesEx6` bit
  `0x1000` on warrior stances + DK presences (a second client-UI gate
  surfaced via DBC diff -- aspects don't have it set). Mirrored client-
  side by `_patch_spell_dbc_presences_cancelable.py`. Aspects / presences
  do NOT swap action bars (those are owned by `SPELL_AURA_MOD_SHAPESHIFT`,
  not by Category / AttrEx6) -- only warrior stances and druid forms keep
  the bar swap, matching the design requirement that presences/aspects
  not change the player's action bar.

* Hunter ammo soft-fail (server-wide).
  Replaced both `SPELL_FAILED_NO_AMMO` returns in `Spell::CheckCast` with
  `break;` so ranged + thrown abilities cast through with zero ammo;
  `_ApplyAmmoBonuses` continues to gate the actual arrow/bullet DPS bonus
  on a non-empty stack, so equipping ammo still pays off. New programmatic
  `ApplySpellFix`-style block in `SpellInfoCorrections.cpp` iterates every
  Hunter-family spell whose `EquippedItemClass == ITEM_CLASS_WEAPON` and
  `EquippedItemSubClassMask` includes Bow/Gun/Crossbow and sets
  `EquippedItemClass = -1` (skipping a small DENYLIST of Quiver / Ammo
  Pouch passive haste auras + Aynasha's Bow + Legendary Bow Haste -- those
  are item-equip-driven and must keep gating on the ranged weapon being
  equipped). Server log: ">> Fractured: dropped EquippedItemClass on 196
  hunter shot abilities". Mirrored client-side by the new
  `_patch_spell_dbc_hunter_ammo.py` so the 3.3.5a client preflight stops
  blocking the cast packet with "Ammo needs to be in the paper doll ammo
  slot before it can be fired." `Spell::TakeAmmo` no longer clears
  `PLAYER_AMMO_ID` to 0 when the bag empties (defense in depth so a half-
  deployed pair degrades to soft-fail rather than hard-reject). Adds
  `#include "ItemTemplate.h"` for `ITEM_SUBCLASS_WEAPON_*`.

* Feral Cat scaling (server-wide, cat-only).
  `StatSystem.cpp` `UpdateAttackPowerAndDamage` FORM_CAT branch doubles
  the AGI coefficient (1.0 -> 2.0). `SpellAuraEffects.cpp` Master
  Shapeshifter FORM_CAT branch doubles the talent's bp before triggering
  48420 (R1: 2% -> 4% crit, R2: 4% -> 8%). FORM_BEAR / FORM_DIREBEAR /
  FORM_MOONKIN / FORM_TREE branches all left untouched so bear stays
  "already fine" per the resident Feral expert. Client tooltip drift on
  Cat Form (768) + Master Shapeshifter (48411 / 48412) + Pestilence
  (50842) handled by `_patch_spell_dbc_feral_tooltips.py`.

* Pestilence spreads / refreshes Devouring Plague for Paragon casters.
  `spell_dk.cpp` `spell_dk_pestilence::HandleScriptEffect` now also
  spreads (and Glyph-of-Disease refreshes) Priest Devouring Plague when
  `IsParagonWildcardCaller(caster)`. Uses `GetAuraOfRankedSpell(2944)` so
  the spread copy carries the caster's actual rank. Stock DKs cannot
  cast Devouring Plague at all, so this branch is a no-op for them.

* Dancing Rune Weapon: Paragon copies melee, not casts.
  `spell_dk.cpp` `spell_dk_dancing_rune_weapon::CheckProc` for Paragon
  callers requires `eventInfo.GetDamageInfo()` and
  `spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MELEE`, so the ghostly
  weapon now copies cross-class melee strikes (Hamstring, Sinister Strike,
  Heart Strike, Frost Strike, ...) and auto-attacks instead of re-casting
  the DK's nukes. Stock DK gating below is untouched.

* Maelstrom Weapon: drop Arcane Blast from the allowlist.
  `SpellInfo.cpp` and `spell_shaman.cpp` allowlists now match Fireball
  and Frostbolt only -- Arcane Blast stacked with its own self-buff was
  too potent.

* `BALANCE-TODO.md` added under `contrib/fractured-dev-extras/` to
  capture the resident Feral expert's recommendation, the levers we
  considered, and the cat-only Master-Shapeshifter / AGI-doubling
  resolution we shipped, plus the next-lever knobs if field reports
  still flag cat as weak.

DBC patcher pipeline (lives outside the repo in `fractured-tooling/`)
documented run order: runes -> reagents -> stances -> presences_cancelable
-> hunter_ammo -> feral_tooltips -> _make_paragon_dbc_patch.

No SQL migrations.

Co-authored-by: Cursor <cursoragent@cursor.com>

contrib/fractured-dev-extras/BALANCE-TODO.md

@@ -0,0 +1,94 @@
+# Fractured / Paragon — Balance Backlog
+
+Open balance / scaling questions surfaced by play-testers that have not yet
+been actioned. Each entry should record the *symptom*, the *suspected cause*
+based on a quick code dive, the *option set* we discussed, and any *links*
+to relevant code. Knock items off as they ship.
+
+---
+
+## Feral Cat scaling feels weak (2026-05-11)
+
+**Reporter feedback:**
+
+> "Weapons don't automatically feature feral AP on this server and nothing
+> is currently rescaled resulting in a super low feral scale. We can either
+> rescale their abilities or add the AP back to all weapons."
+>
+> Resident Feral expert: "this is not a bear issue unfortunately, I have
+> 11k AP" / "Stam > AP and Armor > AP means this is completely a cat issue."
+
+**What's actually happening on the server:**
+
+Feral AP *is* being granted on weapons — `ItemTemplate::getFeralBonus`
+(`src/server/game/Entities/Item/ItemTemplate.h`) synthesises it from the
+weapon's DPS for any weapon with `INVTYPE_WEAPON / 2HWEAPON / WEAPONMAINHAND
+/ WEAPONOFFHAND`:
+
+```cpp
+int32 bonus = int32((extraDPS + getDPS()) * 14.0f) - 767;
+```
+
+That's then routed through `Player::ApplyFeralAPBonus` (Player.cpp ~6896)
+into `m_baseFeralAP`, which `Player::UpdateAttackPowerAndDamage` adds into
+the cat / bear formulas in `src/server/game/Entities/Unit/StatSystem.cpp`
+(~line 477):
+
+```cpp
+case FORM_CAT:
+    val2 = (level * mLevelMult) + STR*2 + AGI - 20 + weapon_bonus + m_baseFeralAP;
+    break;
+case FORM_BEAR:
+case FORM_DIREBEAR:
+    val2 = (level * mLevelMult) + STR*2          - 20 + weapon_bonus + m_baseFeralAP;
+    break;
+```
+
+So bear and cat get the same `m_baseFeralAP` — the only delta is `+ AGI` for
+cat. The "bears feel fine, cats feel weak" complaint is real; it's because
+bear damage is rage / proc / mitigation driven (Lacerate stack, Savage
+Defense, Pulverize-style talents) while cat damage is much more
+AP-coefficient driven (Shred, Mangle, Rake, Rip, FB).
+
+**Options discussed (pick when we revisit):**
+
+| ID | Lever | Pros | Cons |
+|----|-------|------|------|
+| A  | Bump the cat AP formula (e.g. `+ AGI*1.5`) | Cleanest, very tunable, hits both auto-attacks and abilities | Blunt instrument, also affects PvP |
+| B  | Boost cat-form ability coefficients (Shred / Rake / Rip / Mangle / FB) via spellmod auras | Most retail-faithful, surgical | More moving parts, harder to communicate |
+| C  | Increase `getFeralBonus` payout for druid weapons (e.g. `* 18.0f` or drop the `-767` floor) | Single-line change | Buffs bears too — bears are already fine, would over-buff |
+| D  | New Cat-only passive "Predator's Edge" = `+X% physical damage in Cat Form` | Easy to balance, easy to communicate, easy to undo | Adds another aura to track |
+
+**Recommendation when we pick this back up:** start with **D + small A** —
+D is the readable "+15-20% cat damage" knob, A is a backup if AP-scaling
+abilities (Mangle / FB) still feel weak relative to bleeds. Both are
+trivially tunable via a single config knob during play-testing.
+
+Do **not** pick C — it over-buffs bears, which the Feral expert explicitly
+said are already fine.
+
+**Resolution (2026-05-11, second pass):** Per the resident Feral expert
+("instead of adding a new passive, you could probably just increase Cat
+Form's Master Shapeshifter value along with its tooltip, alongside buffing
+the agi scaling") we shipped a hybrid of **A** and a *cat-only* knob that
+sits next to **D** but reuses an existing aura instead of inventing a new
+one:
+
+* `StatSystem.cpp` `UpdateAttackPowerAndDamage` FORM_CAT branch now
+  reads `+ GetStat(STAT_AGILITY) * 2.0f` (stock 1.0). FORM_BEAR /
+  FORM_DIREBEAR / FORM_MOONKIN are untouched, so bear's "already fine"
+  state is preserved.
+* `SpellAuraEffects.cpp` Master Shapeshifter FORM_CAT branch multiplies
+  the talent's value by 2 before triggering 48420 (cat-form aura).
+  Talent ranks: 2% -> 4% (R1), 4% -> 8% (R2) crit chance in Cat Form.
+  Bear / Moonkin / Tree branches still pass `bp` through unchanged.
+* Client tooltip drift handled by
+  `fractured-tooling/from-workspace-root/_patch_spell_dbc_feral_tooltips.py`,
+  which appends a `[Fractured]` paragraph to the Description column of
+  Cat Form (768) and Master Shapeshifter ranks (48411 / 48412).
+
+If field reports after this lands still say cat is weak, the next levers
+are (in order): bump `2.0f` to `2.5f` in StatSystem.cpp, then bump the
+Master Shapeshifter cat multiplier from `* 2` to `* 3` in
+SpellAuraEffects.cpp, then -- only if those are exhausted -- revisit
+**B** (per-ability spellmod coefficients).

contrib/fractured-dev-extras/README.txt

@@ -6,6 +6,9 @@ AzerothCore. Upstream AzerothCore does not ship these paths.
 
 Contents:
 - BUILD-NATIVE.md — fork-specific native build notes (moved from repo root).
+- BALANCE-TODO.md — open balance / scaling questions raised by play-testers
+  that have not yet been actioned (e.g. Feral Cat scaling). Knock items off
+  as they ship.
 - CLAUDE.md — optional AI assistant context (moved from repo root).
 - CLIENT-PATCHES.md — what ships in a Fractured client release (MPQs +
   patched Wow.exe), where to download them (Releases page), and how

modules/mod-paragon/data/sql/db-world/base/paragon_spell_ae_cost.sql

@@ -472,6 +472,7 @@ INSERT INTO `paragon_spell_ae_cost` (`spell_id`, `ae_cost`) VALUES
     (61999, 1),
     (62078, 1),
     (62124, 1),
+    (62600, 1),
     (62757, 1),
     (64382, 1),
     (64843, 1),

modules/mod-paragon/data/sql/db-world/updates/2026_05_11_05.sql

@@ -0,0 +1,19 @@
+-- mod-paragon: surface Savage Defense (62600) on the Druid Feral spell tab
+-- of the Character Advancement panel.
+--
+-- The bake (tools/_gen_paragon_advancement_spells_lua.py) used to drop every
+-- SPELL_ATTR0_PASSIVE spell up front, even when the trainer explicitly sells
+-- it. That filter was correct for class-internal triggers (Feline Grace, etc.)
+-- but kicked out Savage Defense -- a passive that DRUID trainer 33 sells at
+-- level 40 (trainer_spell.sql line 2457). Bake now carves out a small
+-- PASSIVE_TRAINER_ALLOWLIST so legitimate trainer-taught passives survive.
+--
+-- The base file (data/sql/db-world/base/paragon_spell_ae_cost.sql) was
+-- regenerated alongside this migration so fresh deployments already have
+-- this row. Existing servers do not re-run base files on content change,
+-- so this update inserts the new (spell_id, ae_cost) pair idempotently.
+-- INSERT IGNORE keeps any per-row tuning a server operator may have already
+-- applied.
+
+INSERT IGNORE INTO `paragon_spell_ae_cost` (`spell_id`, `ae_cost`) VALUES
+    (62600, 1);  -- Savage Defense (Druid, trainer 33, level 40)

modules/mod-paragon/src/Paragon_Essence.cpp

@@ -987,6 +987,89 @@ void CollectSpellChainIds(uint32 baseSpellId, std::unordered_set<uint32>& out)
     }
 }
 
+// Riding-skill gating for spells whose effective rank in the spellbook
+// depends on the player's flying skill (currently the Druid forms
+// Flight Form 33943 / Swift Flight Form 40120). Returns true when the
+// player is allowed to learn this specific spell id at this moment.
+//
+//   33943 (Flight Form, 150% flight)        requires 34090 Expert Riding.
+//   40120 (Swift Flight Form, 280% flight)  requires 34091 Artisan Riding.
+//
+// Any other spell id is always allowed (returns true). Used by
+// `PanelLearnSpellChain` so a Paragon panel purchase / level-up cascade
+// silently skips the unaffordable rank but keeps walking the chain --
+// e.g. a player with Expert Riding only gets Flight Form, never Swift,
+// even though both ranks are in the same SpellChain.dbc graph.
+[[nodiscard]] bool IsParagonSpellAllowedByRidingSkill(Player* pl, uint32 spellId)
+{
+    if (!pl)
+        return true;
+    if (spellId == 33943)
+        return pl->HasSpell(34090) || pl->HasSpell(34091); // expert OR artisan
+    if (spellId == 40120)
+        return pl->HasSpell(34091); // artisan required for swift
+    return true;
+}
+
+// Walk a rank chain and learn every rank up to the player's current
+// level (and not past riding-skill gates), without any of the
+// PanelLearnSpellChain panel/AE bookkeeping. Used by talent-grant
+// cascades (Mangle / Feral Charge / Mutilate / etc.) where the talent
+// LEARN_SPELL effect grants the rank-1 ability and stock would have
+// upgraded it via Player::learnSkillRewardedSpells -- but the Paragon
+// class-skill cascade is intentionally disabled (Player.cpp guard), so
+// nothing else picks up the higher ranks. Idempotent: skips ranks the
+// player already has, so safe to re-run on level-up / login.
+void TeachLevelGatedAbilityChainNoPanel(Player* pl, uint32 chainHead)
+{
+    if (!pl || !chainHead)
+        return;
+    uint32 const playerLevel = pl->GetLevel();
+    uint32 const firstId = sSpellMgr->GetFirstSpellInChain(chainHead);
+    uint32 cur = firstId ? firstId : chainHead;
+    while (cur)
+    {
+        SpellInfo const* info = sSpellMgr->GetSpellInfo(cur);
+        if (!info)
+            break;
+
+        uint32 const reqLv = GetParagonPanelSpellRequiredLevel(info);
+        if (playerLevel < reqLv)
+            break;
+
+        if (!pl->HasSpell(cur) && IsParagonSpellAllowedByRidingSkill(pl, cur))
+            pl->learnSpell(cur, false);
+
+        uint32 const next = sSpellMgr->GetNextSpellInChain(cur);
+        if (!next || next == cur)
+            break;
+        cur = next;
+    }
+}
+
+// Walk every SPELL_EFFECT_LEARN_SPELL on `talentRankSpellId` (the
+// `TalentEntry::RankID[r]` of a talent rank) and, for each granted
+// spell, run TeachLevelGatedAbilityChainNoPanel so the player ends up
+// with the highest rank their level can support. Mangle, Feral Charge,
+// Mutilate, etc. all fit this pattern.
+void CascadeRanksForTalentLearnSpellEffects(Player* pl, uint32 talentRankSpellId)
+{
+    if (!pl || !talentRankSpellId)
+        return;
+    SpellInfo const* rankInfo = sSpellMgr->GetSpellInfo(talentRankSpellId);
+    if (!rankInfo)
+        return;
+    for (uint8 e = 0; e < MAX_SPELL_EFFECTS; ++e)
+    {
+        if (rankInfo->Effects[e].Effect != SPELL_EFFECT_LEARN_SPELL)
+            continue;
+        uint32 const grantId = rankInfo->Effects[e].TriggerSpell;
+        if (!grantId)
+            continue;
+        TeachLevelGatedAbilityChainNoPanel(pl, grantId);
+    }
+}
+
 // True when `depSpellId` (any rank in its chain) is the target of a
 // SPELL_EFFECT_LEARN_SPELL on any rank of the anchor purchase chain
 // (`anchorChainHead` is the chain head / panel_spells.spell_id).
@@ -1103,7 +1186,7 @@ void PanelLearnSpellChain(Player* pl, uint32 baseSpellId)
         if (playerLevel < reqLv)
             break;
 
-        if (!pl->HasSpell(cur))
+        if (!pl->HasSpell(cur) && IsParagonSpellAllowedByRidingSkill(pl, cur))
         {
             std::unordered_set<uint32> before = SnapshotKnownSpells(pl);
             if (diag)
@@ -2085,7 +2168,23 @@ bool HandleCommit(Player* pl, std::string const& body, std::string* err)
 
         uint32 const targetRank = std::min<uint32>(currentRank + delta, MAX_TALENT_RANK);
         for (uint32 r = currentRank; r < targetRank; ++r)
+        {
             pl->LearnTalent(tid, r, /*command=*/true);
+
+            // Fractured / Paragon: talents that LEARN_SPELL an ability
+            // (Mangle, Feral Charge, Mutilate, ...) only directly grant the
+            // rank-1 ability spell. Stock classes auto-rank-up the granted
+            // spell via Player::learnSkillRewardedSpells on level-up, but
+            // that path is intentionally disabled for Paragon class skill
+            // lines (Player.cpp guard) -- so without this cascade the
+            // ability stays at rank 1 forever (Mangle Bear 33878 instead
+            // of 33986 / 33987 / 48563 / 48564). Walk every LEARN_SPELL
+            // target on this rank's RankID spell and grant the highest
+            // rank the player's level allows.
+            if (TalentEntry const* freshTe = sTalentStore.LookupEntry(tid))
+                if (uint32 rankSpell = freshTe->RankID[r])
+                    CascadeRanksForTalentLearnSpellEffects(pl, rankSpell);
+        }
     }
 
     for (auto const& [tid, delta] : talentDeltas)
@@ -4013,6 +4112,45 @@ public:
         ReconcileEssenceForPlayer(player);
         SaveCurrencyToDb(player);
         PushCurrency(player);
+
+        // Fractured / Paragon: rank-up cascade for level-up. Without this,
+        // higher ranks of panel-purchased spells AND talent-LEARN_SPELL
+        // granted abilities (Mangle, Feral Charge, Mutilate, ...) never
+        // appear on ding because Player::learnSkillRewardedSpells is
+        // disabled for the class skill line on Paragon (intentional, to
+        // keep the panel as the sole authority over class abilities).
+        //
+        // Cheap re-walks: PanelLearnSpellChain / TeachLevelGated... both
+        // skip ranks the player already has, so the only real work each
+        // level-up is adding the one new rank the player just qualified
+        // for (if any).
+        if (QueryResult r = CharacterDatabase.Query(
+                "SELECT spell_id FROM character_paragon_panel_spells WHERE guid = {}", lowGuid))
+        {
+            do
+            {
+                uint32 const head = r->Fetch()[0].Get<uint32>();
+                PanelLearnSpellChain(player, head);
+            } while (r->NextRow());
+        }
+
+        if (QueryResult tr = CharacterDatabase.Query(
+                "SELECT talent_id, `rank` FROM character_paragon_panel_talents WHERE guid = {}", lowGuid))
+        {
+            do
+            {
+                Field* f = tr->Fetch();
+                uint32 const talentId = f[0].Get<uint32>();
+                uint32 const rank     = f[1].Get<uint32>();
+                TalentEntry const* te = sTalentStore.LookupEntry(talentId);
+                if (!te)
+                    continue;
+                uint32 const cap = std::min<uint32>(rank, MAX_TALENT_RANK);
+                for (uint32 i = 0; i < cap; ++i)
+                    if (uint32 rankSpell = te->RankID[i])
+                        CascadeRanksForTalentLearnSpellEffects(player, rankSpell);
+            } while (tr->NextRow());
+        }
     }
 
     bool OnPlayerCanLearnTalent(Player* player, TalentEntry const* talent, uint32 /*rank*/) override

scripts/start-azeroth-servers.sh

@@ -7,13 +7,15 @@
 #   AZEROTH_BIN=/path/to/azeroth-server/bin bash scripts/start-azeroth-servers.sh
 #
 # Environment:
-#   AZEROTH_BIN      — directory with authserver and worldserver (default: /root/azeroth-server/bin)
+#   AZEROTH_BIN      — directory with authserver and worldserver (default: /home/fractured-panel/azeroth-server/bin)
 #   AZEROTH_LOG_DIR  — log directory (default: <parent of bin>/logs)
 
 set -euo pipefail
 
-BIN_DIR="${AZEROTH_BIN:-/root/azeroth-server/bin}"
+BIN_DIR="${AZEROTH_BIN:-/home/fractured-panel/azeroth-server/bin}"
-LOG_DIR="${AZEROTH_LOG_DIR:-$(cd "$(dirname "$BIN_DIR")" && pwd)/logs}"
+BASE_DIR="$(cd "$(dirname "$BIN_DIR")" && pwd)"
+LOG_DIR="${AZEROTH_LOG_DIR:-${BASE_DIR}/logs}"
+CONF_DIR="${BASE_DIR}/etc"
 
 AUTH_BIN="${BIN_DIR}/authserver"
 WORLD_BIN="${BIN_DIR}/worldserver"
@@ -35,15 +37,16 @@ mkdir -p "$LOG_DIR"
 
 cd "$BIN_DIR"
 
-nohup "$AUTH_BIN" >>"$LOG_DIR/authserver.log" 2>&1 &
+nohup "$AUTH_BIN" -c "${CONF_DIR}/authserver.conf" >>"$LOG_DIR/authserver.log" 2>&1 &
 disown || true
 
 sleep 2
 
-nohup "$WORLD_BIN" >>"$LOG_DIR/worldserver.log" 2>&1 &
+nohup "$WORLD_BIN" -c "${CONF_DIR}/worldserver.conf" >>"$LOG_DIR/worldserver.log" 2>&1 &
 disown || true
 
 echo "Started authserver and worldserver (survives SSH disconnect)."
 echo "Bin:    $BIN_DIR"
+echo "Config: $CONF_DIR"
 echo "Logs:   $LOG_DIR/authserver.log"
 echo "        $LOG_DIR/worldserver.log"

scripts/vps-update-server.sh

@@ -35,6 +35,7 @@ FULL_BUILD=0
 COMPILE_ONLY=0
 DRY_RUN=0
 DO_RUN_AFTER=0
+INSTALL_PREFIX=""
 POST_UPDATE_CMD="${FRACTURED_POST_UPDATE_CMD:-}"
 GIT_REMOTE="${FRACTURED_GIT_REMOTE:-origin}"
 
@@ -49,6 +50,7 @@ Options:
   --no-pull       Skip git pull (only compile current tree).
   --full          ./acore.sh compiler all (clean + configure + compile).
   --compile-only  ./acore.sh compiler compile (incremental).
+  --prefix PATH   Override CMAKE_INSTALL_PREFIX (updates conf/config.sh BINPATH).
   --dry-run       Print commands without running them.
   --run-after [CMD]  Run shell command after successful compile. If CMD is omitted,
                   uses FRACTURED_POST_UPDATE_CMD from the environment.
@@ -87,6 +89,15 @@ while [[ $# -gt 0 ]]; do
       COMPILE_ONLY=1
       shift
       ;;
+    --prefix)
+      shift
+      if [[ $# -eq 0 || "$1" == -* ]]; then
+        echo "error: --prefix requires a path argument" >&2
+        exit 2
+      fi
+      INSTALL_PREFIX="$1"
+      shift
+      ;;
     --dry-run)
       DRY_RUN=1
       shift
@@ -129,6 +140,16 @@ fi
 
 cd "$ROOT"
 
+if [[ -n "$INSTALL_PREFIX" ]]; then
+  echo "==> updating conf/config.sh BINPATH to: $INSTALL_PREFIX"
+  if grep -q '^BINPATH=' conf/config.sh; then
+    run sed -i "s|^BINPATH=.*|BINPATH=\"$INSTALL_PREFIX\"|" conf/config.sh
+  else
+    echo "BINPATH=\"$INSTALL_PREFIX\"" >> conf/config.sh
+  fi
+  export BINPATH="$INSTALL_PREFIX"
+fi
+
 if [[ "$DO_RUN_AFTER" -eq 1 && -z "${POST_UPDATE_CMD// }" ]]; then
   echo "error: --run-after needs a command or FRACTURED_POST_UPDATE_CMD set in the environment." >&2
   exit 2

src/server/game/Entities/Player/Player.cpp

@@ -7143,6 +7143,18 @@ bool Player::CheckAttackFitToAuraRequirement(WeaponAttackType attackType, AuraEf
     if (spellInfo->EquippedItemClass == -1)
         return true;
 
+    // Fractured / Paragon: cross-class wildcard relaxes the weapon-subclass
+    // gate ONLY for the curated allowlist of cross-class proc talents
+    // (currently just Maelstrom Weapon 51528-51532). Weapon-specialization
+    // talents like Sword Specialization, Mace Specialization, Hack and
+    // Slash, Two-Handed Weapon Specialization etc. deliberately stay
+    // weapon-gated for Paragon -- the player picks a weapon and the
+    // matching specialization passive activates, same as any class.
+    if (spellInfo->EquippedItemClass == ITEM_CLASS_WEAPON
+        && IsParagonWildcardCaller(this)
+        && IsParagonWeaponSubclassWildcardSpell(spellInfo->Id))
+        return GetWeaponForAttack(attackType, true) != nullptr;
+
     Item* item = GetWeaponForAttack(attackType, true);
     if (!item || !item->IsFitToSpellRequirements(spellInfo))
         return false;
@@ -12581,6 +12593,31 @@ bool Player::HasItemFitToSpellRequirements(SpellInfo const* spellInfo, Item cons
     if (spellInfo->EquippedItemClass < 0)
         return true;
 
+    // Fractured / Paragon: cross-class wildcard relaxes the weapon-subclass
+    // gate ONLY for the curated allowlist of cross-class proc talents
+    // (currently just Maelstrom Weapon 51528-51532) so the passive talent
+    // aura attaches when the player wields a non-stock weapon. Weapon-
+    // specialization talents (Sword/Mace Specialization, Hack and Slash,
+    // Two-Handed Weapon Specialization, etc.) deliberately stay weapon-
+    // gated -- they're meant to bind to a specific weapon type. Still
+    // requires *some* weapon equipped (unarmed Paragons don't auto-activate
+    // weapon talents). ITEM_CLASS_ARMOR (shield) is left alone -- shield-
+    // gated talents still need an actual shield.
+    if (spellInfo->EquippedItemClass == ITEM_CLASS_WEAPON
+        && IsParagonWildcardCaller(this)
+        && IsParagonWeaponSubclassWildcardSpell(spellInfo->Id))
+    {
+        for (uint8 i = EQUIPMENT_SLOT_MAINHAND; i < EQUIPMENT_SLOT_TABARD; ++i)
+            if (Item const* item = GetUseableItemByPos(INVENTORY_SLOT_BAG_0, i))
+                if (item != ignoreItem)
+                    if (ItemTemplate const* proto = item->GetTemplate())
+                        if (proto->Class == ITEM_CLASS_WEAPON)
+                            return true;
+        // No weapon equipped at all -- fall through to stock logic, which
+        // returns false for passive talent auras (correct: an unarmed
+        // Paragon shouldn't have weapon talents active).
+    }
+
     // scan other equipped items for same requirements (mostly 2 daggers/etc)
     // for optimize check 2 used cases only
     switch (spellInfo->EquippedItemClass)

src/server/game/Entities/Unit/StatSystem.cpp

@@ -474,7 +474,25 @@ void Player::UpdateAttackPowerAndDamage(bool ranged)
             switch (GetShapeshiftForm())
             {
             case FORM_CAT:
-                val2 = (GetLevel() * mLevelMult) + GetStat(STAT_STRENGTH) * 2.0f + GetStat(STAT_AGILITY) - 20.0f + weapon_bonus + m_baseFeralAP;
+                // Fractured: Cat Form gets 2 AP per Agility instead of stock 1.
+                // Field reports said "weapons dont automatically feature feral
+                // AP on this server and nothing is currently rescaled, super
+                // low feral scale" -- specifically a CAT issue, not a bear
+                // issue (the resident bear had 11k AP, the resident cat was
+                // miles behind because Stam > AP and Armor > AP for bears
+                // hides the missing weapon-AP for them but cat's whole
+                // mainline is melee crits scaling off AP). The cleanest knob
+                // that does NOT touch bear is the AGI multiplier in this
+                // switch -- bears get STR*2 with no AGI term, so doubling
+                // the AGI coefficient lifts cat's primary scaling stat
+                // without re-buffing bear. Also pairs with the cat-form
+                // Master Shapeshifter buff in SpellAuraEffects.cpp's
+                // FORM_CAT branch (bp doubled there). Together that lands
+                // the resident Feral expert's recommendation
+                // ("instead of adding a new passive, you could probably
+                // just increase Cat Form's Master Shapeshifter value along
+                // with its tooltip, alongside buffing the agi scaling").
+                val2 = (GetLevel() * mLevelMult) + GetStat(STAT_STRENGTH) * 2.0f + GetStat(STAT_AGILITY) * 2.0f - 20.0f + weapon_bonus + m_baseFeralAP;
                 break;
             case FORM_BEAR:
             case FORM_DIREBEAR:

src/server/game/Entities/Unit/Unit.cpp

@@ -103,6 +103,112 @@ bool ParagonFamilyMatches(Unit const* listener, uint32 expectedFamily, uint32 ac
     return expectedFamily == actualFamily;
 }
 
+bool IsParagonWeaponSubclassWildcardSpell(uint32 spellId)
+{
+    if (!spellId)
+        return false;
+
+    // Resolve to the first-rank id so callers can pass any rank.
+    uint32 firstRankId = spellId;
+    if (SpellInfo const* info = sSpellMgr->GetSpellInfo(spellId))
+        if (SpellInfo const* first = info->GetFirstRankSpell())
+            firstRankId = first->Id;
+
+    switch (firstRankId)
+    {
+        // Maelstrom Weapon (talent ranks 51528 / 51529 / 51530 / 51531 / 51532).
+        // Cross-class proc talent that should fire off any equipped weapon
+        // for a Paragon caster (1H sword, polearm, staff, fist, dagger, etc.).
+        case 51528:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool IsFracturedExclusiveStanceSpell(uint32 spellId)
+{
+    if (!spellId)
+        return false;
+
+    // Resolve to the first-rank id so callers can pass any rank. This means
+    // every rank of Aspect of the Hawk / Wild / Pack / Dragonhawk is covered
+    // by listing only the rank-1 id below; same for druid forms that have
+    // multiple ranks via talent (none in WotLK actually, but kept consistent).
+    uint32 firstRankId = spellId;
+    if (SpellInfo const* info = sSpellMgr->GetSpellInfo(spellId))
+        if (SpellInfo const* first = info->GetFirstRankSpell())
+            firstRankId = first->Id;
+
+    switch (firstRankId)
+    {
+        // -- Warrior stances (engine-shapeshifts; engine already mutually
+        //    excludes them with each other and with druid forms via
+        //    AuraEffect::HandleAuraModShapeshift's RemoveAurasByType, but we
+        //    list them here so they participate in the union with presences /
+        //    aspects).
+        case 2457:  // Battle Stance
+        case 71:    // Defensive Stance
+        case 2458:  // Berserker Stance
+
+        // -- Druid combat forms (engine-shapeshifts).
+        case 5487:  // Bear Form
+        case 9634:  // Dire Bear Form
+        case 768:   // Cat Form
+        case 24858: // Moonkin Form
+        case 33891: // Tree of Life Form
+
+        // -- Druid utility forms (engine-shapeshifts; included per design
+        //    decision 2026-05-11 -- player must drop Travel/Aquatic/Flight to
+        //    apply Hawk / Frost Presence / Berserker Stance, and vice versa).
+        case 783:   // Travel Form
+        case 1066:  // Aquatic Form
+        case 33943: // Flight Form
+        case 40120: // Swift Flight Form
+
+        // -- Shaman utility form (engine-shapeshift FORM_GHOSTWOLF).
+        case 2645:  // Ghost Wolf
+
+        // -- Rogue base stealth (engine-shapeshift FORM_STEALTH). Shadow
+        //    Dance (51713) is intentionally NOT listed -- it is a 6s
+        //    stealth-burst on a 60s CD, gating it would defeat its purpose.
+        case 1784:  // Stealth
+
+        // -- Priest combat form (engine-shapeshift FORM_SHADOW).
+        case 15473: // Shadowform
+
+        // -- Warlock combat form (engine-shapeshift FORM_METAMORPHOSIS).
+        case 47241: // Metamorphosis
+
+        // -- Death Knight Presences. NOT engine-shapeshifts in stock AC --
+        //    they are regular auras that the client just renders in the
+        //    stance bar -- which is exactly why stock DK can stack them on
+        //    top of Bear Form / Defensive Stance / Aspect of the Hawk on a
+        //    Paragon character. Listing them here is what plugs the gap.
+        case 48266: // Blood Presence
+        case 48263: // Frost Presence
+        case 48265: // Unholy Presence
+
+        // -- Hunter Aspects (combat). Like presences, these are regular
+        //    auras stock AC, not engine-shapeshifts; rank-1 ids cover all
+        //    ranks via GetFirstRankSpell. Cheetah / Pack are the utility
+        //    aspects -- included per design decision so a hunter must pick
+        //    between Hawk and Cheetah (no more "always Hawk while running",
+        //    matches Ascension's nerf rationale for Monkey).
+        case 13165: // Aspect of the Hawk (rank 1; ranks 14318/14319/14320/14321/14322/25296/27044 covered via first-rank)
+        case 5118:  // Aspect of the Cheetah
+        case 13159: // Aspect of the Pack (rank 1; rank 27047 covered via first-rank)
+        case 20043: // Aspect of the Wild (rank 1; ranks 20190/27045 covered via first-rank)
+        case 13161: // Aspect of the Beast
+        case 13163: // Aspect of the Monkey
+        case 34074: // Aspect of the Viper
+        case 61846: // Aspect of the Dragonhawk (rank 1; rank 61847 covered via first-rank)
+            return true;
+        default:
+            return false;
+    }
+}
+
 float baseMoveSpeed[MAX_MOVE_TYPE] =
 {
     2.5f,                  // MOVE_WALK

src/server/game/Entities/Unit/Unit.h

@@ -2287,6 +2287,47 @@ private:
 // beyond what they already include via Unit.h's transitive headers.
 [[nodiscard]] bool ParagonFamilyMatches(Unit const* listener, uint32 expectedFamily, uint32 actualFamily);
 
+// Fractured / Paragon: returns true iff `spellId` is on the curated allowlist
+// of cross-class proc talents whose `EquippedItemSubClassMask` should be
+// bypassed for Paragon casters (e.g. Maelstrom Weapon ranks 51528-51532).
+// Used by `Player::HasItemFitToSpellRequirements`,
+// `Player::CheckAttackFitToAuraRequirement`, and
+// `Aura::IsProcTriggeredOnEvent` to let these specific talents fire from
+// any equipped weapon while keeping weapon-specialization talents
+// (Sword Specialization, Mace Specialization, Hack and Slash, Two-Handed
+// Weapon Specialization, etc.) gated by their stock weapon-class mask.
+// The allowlist is matched against `SpellInfo::GetFirstRankSpell()`'s id
+// so all ranks of a talent are covered by listing the rank-1 id.
+[[nodiscard]] bool IsParagonWeaponSubclassWildcardSpell(uint32 spellId);
+
+// Fractured: returns true iff `spellId` is one of the cross-class
+// "stance-like" auras that we treat as mutually exclusive on this server,
+// regardless of the caster's class. Stock AC engine-shapeshifts (warrior
+// stances, druid forms, Shadowform, Metamorphosis) already auto-replace
+// each other via `RemoveAurasByType(SPELL_AURA_MOD_SHAPESHIFT)` in
+// `AuraEffect::HandleAuraModShapeshift`, but DK Presences and Hunter
+// Aspects are regular auras (the client just renders them in the stance
+// bar), so they coexist with shapeshifts in stock AC. The Fractured rule
+// makes the entire union mutually exclusive: warrior stances + druid
+// forms (combat AND utility -- Travel/Aquatic/Flight/Swift Flight) +
+// Ghost Wolf + Stealth + Shadowform + Metamorphosis + DK Presences +
+// Hunter Aspects (combat AND utility -- Cheetah/Pack). Casting any of
+// them removes any other from the same set, so e.g. a Paragon DK can no
+// longer stack Frost Presence on top of Bear Form, and a hunter must
+// pick between Hawk and Cheetah even out of combat.
+//
+// The set is matched against `SpellInfo::GetFirstRankSpell()`'s id so
+// every rank of every aspect / form is covered by listing the rank-1 id.
+// Server-wide -- this is *not* gated on CLASS_PARAGON because the only
+// stock-class-only effect of the rule (a DK losing Travel Form when
+// they cast Frost Presence) is impossible: stock DKs cannot shapeshift.
+// Used by `Aura::CanStackWith` to refuse stacking, which then drives
+// `Unit::_RemoveNoStackAurasDueToAura` to drop the older aura -- the
+// same mechanism Battle Elixirs / Curses already use (spell_group rule
+// SPELL_GROUP_STACK_RULE_EXCLUSIVE), implemented in C++ here so we do
+// not have to enumerate every rank of every aspect / form in SQL.
+[[nodiscard]] bool IsFracturedExclusiveStanceSpell(uint32 spellId);
+
 namespace Acore
 {
     // Binary predicate for sorting Units based on percent value of a power

src/server/game/Spells/Auras/SpellAuraEffects.cpp

@@ -1545,7 +1545,21 @@ void AuraEffect::HandleShapeshiftBoosts(Unit* target, bool apply) const
                     // Master Shapeshifter - Cat
                     if (AuraEffect const* aurEff = target->GetDummyAuraEffect(SPELLFAMILY_GENERIC, 2851, 0))
                     {
-                        int32 bp = aurEff->GetAmount();
+                        // Fractured: cat-only Master Shapeshifter bonus is
+                        // doubled (rank 1: 2% -> 4%, rank 2: 4% -> 8%) to
+                        // make Feral Cat builds feel less "super low feral
+                        // scale" without touching bear / moonkin / tree (the
+                        // FORM_BEAR / FORM_MOONKIN / FORM_TREE branches
+                        // below pass `bp` straight through, unchanged). The
+                        // talent's own SpellInfo Effects[].BasePoints is
+                        // intentionally NOT bumped -- aurEff->GetAmount()
+                        // returns the per-rank talent value (2 / 4) shared
+                        // across all four forms, so we apply the cat
+                        // multiplier here at the cast site, leaving every
+                        // other form on the stock value. Pairs with the
+                        // Cat-Form AGI doubling in StatSystem.cpp's
+                        // UpdateAttackPowerAndDamage FORM_CAT branch.
+                        int32 bp = aurEff->GetAmount() * 2;
                         target->CastCustomSpell(target, 48420, &bp, nullptr, nullptr, true);
                     }
                     break;

src/server/game/Spells/Auras/SpellAuras.cpp

@@ -1973,6 +1973,31 @@ bool Aura::CanStackWith(Aura const* existingAura) const
             || (sameCaster && m_spellInfo->IsAuraExclusiveBySpecificPerCasterWith(existingSpellInfo)))
         return false;
 
+    // Fractured: cross-class stance / form / presence / aspect exclusivity.
+    // Stock AC's engine-shapeshift removal in HandleAuraModShapeshift only
+    // covers warrior stances, druid forms, Shadowform, Metamorphosis, etc.
+    // -- DK Presences and Hunter Aspects are regular auras (the client just
+    // happens to render them in the stance bar) and therefore stack with
+    // engine-shapeshifts in stock AC. The Fractured rule (server-wide --
+    // see IsFracturedExclusiveStanceSpell in Unit.h for the curated set
+    // and the design rationale) treats the union of stances + forms (combat
+    // AND utility) + presences + aspects as mutually exclusive. Refusing
+    // to stack here triggers the same _RemoveNoStackAurasDueToAura cleanup
+    // path that Battle Elixirs / Curses already use, so the older aura
+    // drops and the newly-cast one applies cleanly. Different ranks of the
+    // same talent (e.g. Hawk rank 4 -> Hawk rank 7) are NOT treated as
+    // exclusive with each other -- IsFracturedExclusiveStanceSpell resolves
+    // to first-rank ids, so we compare those.
+    if (IsFracturedExclusiveStanceSpell(m_spellInfo->Id) && IsFracturedExclusiveStanceSpell(existingSpellInfo->Id))
+    {
+        SpellInfo const* newFirst = m_spellInfo->GetFirstRankSpell();
+        SpellInfo const* oldFirst = existingSpellInfo->GetFirstRankSpell();
+        uint32 newFirstId = newFirst ? newFirst->Id : m_spellInfo->Id;
+        uint32 oldFirstId = oldFirst ? oldFirst->Id : existingSpellInfo->Id;
+        if (newFirstId != oldFirstId)
+            return false;
+    }
+
     // check spell group stack rules
     switch (sSpellMgr->CheckSpellGroupStackRules(m_spellInfo, existingSpellInfo))
     {
@@ -2251,8 +2276,23 @@ uint8 Aura::GetProcEffectMask(AuraApplication* aurApp, ProcEventInfo& eventInfo,
                 item = target->ToPlayer()->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
             }
 
-            if (!item || item->IsBroken() || !item->IsFitToSpellRequirements(GetSpellInfo()))
+            if (!item || item->IsBroken())
                 return 0;
+            if (!item->IsFitToSpellRequirements(GetSpellInfo()))
+            {
+                // Fractured / Paragon: cross-class wildcard relaxes the
+                // weapon-subclass gate ONLY for the curated allowlist of
+                // cross-class proc talents (currently just Maelstrom Weapon
+                // 51528-51532). Weapon-specialization talents (Sword/Mace
+                // Specialization, Hack and Slash, Two-Handed Weapon
+                // Specialization, etc.) deliberately stay weapon-gated for
+                // Paragon. Restricted to ITEM_CLASS_WEAPON so shield-gated
+                // talents still need an actual shield.
+                if (!(GetSpellInfo()->EquippedItemClass == ITEM_CLASS_WEAPON
+                      && IsParagonWildcardCaller(target)
+                      && IsParagonWeaponSubclassWildcardSpell(GetSpellInfo()->Id)))
+                    return 0;
+            }
         }
     }
 

src/server/game/Spells/Spell.cpp

@@ -7732,56 +7732,64 @@ SpellCastResult Spell::CheckItems(uint32* param1, uint32* param2)
                     switch (pItem->GetTemplate()->SubClass)
                     {
                         case ITEM_SUBCLASS_WEAPON_THROWN:
-                            {
+                        {
-                                uint32 ammo = pItem->GetEntry();
+                            // Fractured: thrown abilities behave like DK runes -- they
-                                if (!m_caster->ToPlayer()->HasItemCount(ammo))
+                            // remain usable even when the player has run out of the
-                                    return SPELL_FAILED_NO_AMMO;
+                            // throwing item. Stock AC returned SPELL_FAILED_NO_AMMO
-                            };
+                            // here; we just drop the gate. Spell::TakeAmmo's stack
+                            // decrement is wrapped in a HasItemCount check via
+                            // DestroyItemCount and will silently no-op at zero. The
+                            // ranged-DPS bonus naturally vanishes when the stack runs
+                            // out, so the player still throws but loses the per-shot
+                            // damage contribution from the throwing item.
                             break;
+                        };
                         case ITEM_SUBCLASS_WEAPON_GUN:
                         case ITEM_SUBCLASS_WEAPON_BOW:
                         case ITEM_SUBCLASS_WEAPON_CROSSBOW:
-                            {
+                        {
-                                uint32 ammo = m_caster->ToPlayer()->GetUInt32Value(PLAYER_AMMO_ID);
+                            // Fractured: ranged abilities behave like DK runes -- they
-                                if (!ammo)
+                            // remain usable when the player has no ammo loaded or the
-                                {
+                            // quiver / pouch is empty. The DPS-bonus path (StatSystem.cpp:
-                                    // Requires No Ammo
+                            // `weaponMin/MaxDamage += GetAmmoDPS() * attackSpeedMod`)
-                                    if (m_caster->HasAura(46699))
+                            // reads `m_ammoDPS`, which is 0 when no ammo is loaded and
-                                        break;                      // skip other checks
+                            // recomputed via Player::_ApplyAmmoBonuses on equip / stack
-
+                            // exhaustion, so a hunter with an empty bag still casts
-                                    return SPELL_FAILED_NO_AMMO;
+                            // Steady Shot / Aimed Shot etc. -- they just lose the arrow
-                                }
+                            // / bullet DPS contribution.
-
+                            //
-                                ItemTemplate const* ammoProto = sObjectMgr->GetItemTemplate(ammo);
+                            // We deliberately do NOT clear PLAYER_AMMO_ID when the bag
-                                if (!ammoProto)
+                            // empties. Defense in depth alongside the data-side fix:
-                                    return SPELL_FAILED_NO_AMMO;
+                            //
-
+                            //   * The primary client-side fix lives in Spell.dbc --
-                                if (ammoProto->Class != ITEM_CLASS_PROJECTILE)
+                            //     SpellInfoCorrections.cpp's "drop EquippedItemClass on
-                                    return SPELL_FAILED_NO_AMMO;
+                            //     hunter shot abilities" block (mirrored client-side by
-
+                            //     fractured-tooling/_patch_spell_dbc_hunter_ammo.py)
-                                // check ammo ws. weapon compatibility
+                            //     sets EquippedItemClass = -1 on every player-castable
-                                switch (pItem->GetTemplate()->SubClass)
+                            //     hunter shot, which removes the 3.3.5a client's
-                                {
+                            //     "ranged weapon AND ammo slot non-empty" preflight
-                                    case ITEM_SUBCLASS_WEAPON_BOW:
+                            //     gate entirely. After that, ammo is purely a
-                                    case ITEM_SUBCLASS_WEAPON_CROSSBOW:
+                            //     server-side DPS bonus, never a hard requirement.
-                                        if (ammoProto->SubClass != ITEM_SUBCLASS_ARROW)
+                            //
-                                            return SPELL_FAILED_NO_AMMO;
+                            //   * Keeping the (now-stale) ammo id in PLAYER_AMMO_ID
-                                        break;
+                            //     field is harmless: TakeAmmo's DestroyItemCount
-                                    case ITEM_SUBCLASS_WEAPON_GUN:
+                            //     silently no-ops when HasItemCount is 0, and
-                                        if (ammoProto->SubClass != ITEM_SUBCLASS_BULLET)
+                            //     _ApplyAmmoBonuses already recomputes m_ammoDPS to 0
-                                            return SPELL_FAILED_NO_AMMO;
+                            //     when the proto can no longer be found / the stack is
-                                        break;
+                            //     empty. So the StatSystem.cpp ammo-DPS path gracefully
-                                    default:
+                            //     degrades to "no bonus" the moment the bag goes empty.
-                                        return SPELL_FAILED_NO_AMMO;
+                            //
-                                }
+                            //   * Player un-equipping the ammo via the paper-doll
-
+                            //     right-click still routes through RemoveAmmo() and
-                                if (!m_caster->ToPlayer()->HasItemCount(ammo))
+                            //     zeroes the field -- that is the player's explicit
-                                {
+                            //     action and we leave it alone.
-                                    m_caster->ToPlayer()->SetUInt32Value(PLAYER_AMMO_ID, 0);
+                            //
-                                    return SPELL_FAILED_NO_AMMO;
+                            // Net result: hunter has bow + ammo -> full DPS; bow only ->
-                                }
+                            // shots still fire, no ammo DPS; no bow -> client engine's
-                            };
+                            // own ranged-weapon gate still blocks (Auto Shot timer
+                            // simply never spins up without a ranged weapon equipped).
                             break;
+                        };
                         case ITEM_SUBCLASS_WEAPON_WAND:
                             break;
                         default:

src/server/game/Spells/SpellInfo.cpp

@@ -1395,15 +1395,16 @@ bool SpellInfo::IsAffectedBySpellMod(SpellModifier const* mod, Unit const* liste
         {
             case 53817: // Shaman: Maelstrom Weapon
             {
-                // Allow any rank of Mage Fireball / Frostbolt / Arcane Blast to
+                // Allow any rank of Mage Fireball / Frostbolt to benefit from
-                // benefit from the cast-time + cost reduction spellmod.
+                // the cast-time + cost reduction spellmod. Arcane Blast was on
+                // the allowlist briefly but proved too potent stacked with its
+                // own self-buff -- removed.
                 if (SpellFamilyName == SPELLFAMILY_MAGE)
                 {
                     SpellInfo const* first = GetFirstRankSpell();
                     uint32 firstId = first ? first->Id : Id;
                     if (firstId == 133 /*Fireball*/
-                        || firstId == 116 /*Frostbolt*/
+                        || firstId == 116 /*Frostbolt*/)
-                        || firstId == 30451 /*Arcane Blast*/)
                         return true;
                 }
                 break;

src/server/game/Spells/SpellInfoCorrections.cpp

@@ -18,6 +18,7 @@
 #include "DBCStores.h"
 #include "DBCStructure.h"
 #include "GameGraveyard.h"
+#include "ItemTemplate.h"
 #include "SpellInfo.h"
 #include "SpellMgr.h"
 
@@ -5380,6 +5381,118 @@ void SpellMgr::LoadSpellInfoCorrections()
         spellInfo->Attributes |= SPELL_ATTR0_PASSIVE;
     });
 
+    // Fractured: move Death Knight Presences and Hunter Aspects out of
+    // SpellCategory 47 ("Combat States") so they cancel/toggle the same
+    // way Druid shapeshift forms do.
+    //
+    // Category 47 is the "stance bar" category. The 3.3.5a client UI
+    // explicitly disables right-click-cancel and `/cancelaura <name>` for
+    // any aura whose Spell.dbc Category column points at a SpellCategory
+    // entry that is "Combat States" (47). Druid forms (Bear Form, Cat
+    // Form, Travel Form, Moonkin, Tree of Life, etc.) sit in Category 0
+    // and are therefore freely cancellable -- right-click drops the form,
+    // /cancelaura drops it, recasting from the action bar drops it.
+    // Warrior stances, DK Presences and Hunter Aspects all live in
+    // Category 47, which is why none of them are cancellable in stock.
+    //
+    // For the cross-class stance / form / presence / aspect exclusivity
+    // rule (see IsFracturedExclusiveStanceSpell in Unit.cpp), a Paragon
+    // hybrid often wants to drop their active presence/aspect so they can
+    // apply a different stance/form *without* first switching to a
+    // different presence/aspect. Setting Category to 0 here mirrors what
+    // Druid forms already do, gives the cancel/toggle UX the user
+    // explicitly asked for, and -- importantly -- does NOT change the
+    // action bar (presences and aspects are not engine-shapeshifts, the
+    // bar swap behavior is owned by SPELL_AURA_MOD_SHAPESHIFT, not by
+    // SpellCategory). The matching client-side Spell.dbc edit ships in
+    // patch-enUS-4.MPQ via _patch_spell_dbc_presences_cancelable.py.
+    //
+    // Warrior stances are also included per design decision 2026-05-11
+    // ("you could make Warrior Stances toggleable as well, it should be
+    // okay"). The previously-shipped Stances=0 client patch already lets
+    // Paragon non-warriors cast every warrior ability without picking up
+    // a stance, so a stock warrior who right-clicks their stance just
+    // ends up at "no stance" -- which on this server still leaves all
+    // their warrior abilities available. Stock warriors who like the
+    // never-cancel UX can simply not right-click; nothing forces them.
+    //
+    // Tradeoff: stances / presences / aspects lose the 1s SpellCategory
+    // GCD that Category 47 enforces between same-category spells. This
+    // matches the Druid-form UX (Bear -> Cat -> Bear has no shared GCD),
+    // and the cross-class exclusivity rule in Aura::CanStackWith already
+    // prevents stacking, so the only thing actually possible at "0s GCD"
+    // is rapid-toggling the same stance on and off, which is harmless.
+    ApplySpellFix({
+        // Warrior Stances.
+        2457,  // Battle Stance
+        71,    // Defensive Stance
+        2458,  // Berserker Stance
+
+        // Death Knight Presences.
+        48266, // Blood Presence
+        48263, // Frost Presence
+        48265, // Unholy Presence
+
+        // Hunter Aspects -- every rank, since AC stores the per-rank
+        // SpellInfo as separate objects and `Category` lives on each.
+        // Rank-1 ids are the same ones listed in
+        // IsFracturedExclusiveStanceSpell; trailing ids are higher ranks.
+        13165, 14318, 14319, 14320, 14321, 14322, 25296, 27044, // Aspect of the Hawk r1..r8
+        5118,                                                    // Aspect of the Cheetah
+        13159,                                                   // Aspect of the Pack (only one rank in WotLK; 27047 is "Growl", do NOT add)
+        20043, 20190, 27045,                                     // Aspect of the Wild r1..r3
+        13161,                                                    // Aspect of the Beast
+        13163,                                                    // Aspect of the Monkey
+        34074,                                                    // Aspect of the Viper
+        61846, 61847,                                             // Aspect of the Dragonhawk r1..r2
+    }, [](SpellInfo* spellInfo)
+    {
+        spellInfo->CategoryEntry = nullptr;
+    });
+
+    // Fractured: clear AttributesEx6 bit 0x1000 on Warrior Stances and DK
+    // Presences so the 3.3.5 client UI lets right-click and `/cancelaura`
+    // drop them, the same way Druid forms / Hunter Aspects already cancel.
+    //
+    // Empirical finding (see fractured-tooling/inspect_stance_attr6.py for
+    // the diff script): when only `SpellCategory` is cleared (the Combat-
+    // States gate at column 1), Hunter Aspects become cancellable but
+    // Warrior Stances and DK Presences still aren't. Diffing the Spell.dbc
+    // rows of working vs broken stance-bar buffs across patched-Aspects and
+    // unpatched-Stances/Presences identifies a SECOND gating column:
+    // `AttributesEx6` (col 10) bit `0x1000`. It is set on every Warrior
+    // Stance (Battle/Defensive/Berserker) and every DK Presence
+    // (Blood/Frost/Unholy) but NOT on any Hunter Aspect (and not on Druid
+    // forms / Ghost Wolf / Stealth / Shadowform). Clearing the bit removes
+    // the secondary client-UI gate without changing how the action bar /
+    // shapeshift system works (those are owned by SPELL_AURA_MOD_SHAPESHIFT,
+    // not by attribute bits).
+    //
+    // AC names this bit `SPELL_ATTR6_ALLOW_WHILE_RIDING_VEHICLE`. That name
+    // is from a different role of the same bit -- when set on a regular
+    // ability, AC's `Spell::CheckCast` vehicle-passenger gate uses it to
+    // grant "this spell is castable from a vehicle seat". Stripping it from
+    // Warrior Stances / DK Presences is harmless because those aren't cast
+    // from vehicle seats anyway (the player is `IsCharmed()` in a seat and
+    // the stance / presence wouldn't apply meaningfully). The matching
+    // client-side Spell.dbc edit ships in patch-enUS-4.MPQ via
+    // _patch_spell_dbc_presences_cancelable.py.
+    //
+    // Hunter Aspects intentionally NOT included -- their AttributesEx6 is
+    // already 0 (or 0x04000000 for Pack/Wild, which is a different bit
+    // unrelated to cancel gating), and listing them here would be a no-op.
+    ApplySpellFix({
+        2457,  // Battle Stance
+        71,    // Defensive Stance
+        2458,  // Berserker Stance
+        48266, // Blood Presence
+        48263, // Frost Presence
+        48265, // Unholy Presence
+    }, [](SpellInfo* spellInfo)
+    {
+        spellInfo->AttributesEx6 &= ~SPELL_ATTR6_ALLOW_WHILE_RIDING_VEHICLE;
+    });
+
     // Fractured: strip reagent requirements from every player-class spell at
     // load time. Filtered by SpellFamilyName != 0 so that profession spells
     // (cooking, alchemy, enchanting, blacksmithing, jewelcrafting, leatherworking,
@@ -5418,6 +5531,76 @@ void SpellMgr::LoadSpellInfoCorrections()
         LOG_INFO("server.loading", ">> Fractured: cleared reagents on {} class spells", fixedClassSpells);
     }
 
+    // Fractured: drop EquippedItemClass on hunter shot abilities at load time
+    // so the server agrees with the matching client-side Spell.dbc patch
+    // (fractured-tooling/_patch_spell_dbc_hunter_ammo.py). Both surfaces have
+    // to agree -- if only the client patch shipped, the server's stock
+    // EquippedItemClass check would still reject mid-cast; if only the server
+    // mirror shipped, the 3.3.5a client preflight would still block the cast
+    // packet from leaving the box with "Ammo needs to be in the paper doll
+    // ammo slot before it can be fired." The Spell::CheckCast soft-fail
+    // (Spell.cpp 7741..) and the never-clear-PLAYER_AMMO_ID change there are
+    // still in place as defense in depth so a half-deployed client / server
+    // pair degrades to the soft-fail behavior rather than to hard rejects.
+    //
+    // Filter mirrors the Python patcher byte-for-byte:
+    //   SpellFamilyName == SPELLFAMILY_HUNTER (9)
+    //   AND EquippedItemClass == ITEM_CLASS_WEAPON (2)
+    //   AND EquippedItemSubClassMask & ((1<<BOW)|(1<<GUN)|(1<<XBOW)) != 0
+    // with a small DENYLIST of item-equip-driven passive auras (Quiver /
+    // Ammo Pouch haste ranks, Legendary Bow Haste, Aynasha's Bow proc) whose
+    // entire purpose is "have a ranged weapon equipped" -- those keep their
+    // stock EquippedItemClass = 2.
+    //
+    // Effect: after this fix, hunter shots leave the client preflight without
+    // hitting the ammo-slot gate AND pass the server's EquippedItemClass
+    // check unconditionally. _ApplyAmmoBonuses still gates the arrow / bullet
+    // DPS bonus on actually having a stack in the quiver, so equipping ammo
+    // continues to give the DPS bump and an empty quiver no longer bricks
+    // abilities -- "you still get the DPS increase from arrows but aren't
+    // completely neutered if you run out", per the resident hunter expert.
+    {
+        constexpr uint32 RANGED_SUBCLASS_MASK =
+              (1u << ITEM_SUBCLASS_WEAPON_BOW)
+            | (1u << ITEM_SUBCLASS_WEAPON_GUN)
+            | (1u << ITEM_SUBCLASS_WEAPON_CROSSBOW);
+
+        // Keep in sync with DENYLIST in
+        // fractured-tooling/_patch_spell_dbc_hunter_ammo.py.
+        static const std::unordered_set<uint32> hunterAmmoDenylist = {
+            // Quiver / Ammo Pouch ranged-attack-speed haste passives (gun).
+            14824, 14825, 14826, 14827, 14828, 14829,
+            // Quiver passive haste (bow + crossbow).
+            29413, 29414, 29415, 29416, 29417, 29418,
+            // Late-rank quiver haste, gun-only.
+            44333,
+            // Legendary Bow Haste (item proc on a specific bow).
+            44972,
+            // Aynasha's Bow item proc.
+            19767,
+        };
+
+        uint32 fixedShots = 0;
+        for (uint32 spellId = 1; spellId < sSpellMgr->GetSpellInfoStoreSize(); ++spellId)
+        {
+            SpellInfo const* info = sSpellMgr->GetSpellInfo(spellId);
+            if (!info || info->SpellFamilyName != SPELLFAMILY_HUNTER)
+                continue;
+            if (info->EquippedItemClass != ITEM_CLASS_WEAPON)
+                continue;
+            if (info->EquippedItemSubClassMask <= 0
+                || (uint32(info->EquippedItemSubClassMask) & RANGED_SUBCLASS_MASK) == 0)
+                continue;
+            if (hunterAmmoDenylist.find(spellId) != hunterAmmoDenylist.end())
+                continue;
+
+            SpellInfo* mut = const_cast<SpellInfo*>(info);
+            mut->EquippedItemClass = -1;
+            ++fixedShots;
+        }
+        LOG_INFO("server.loading", ">> Fractured: dropped EquippedItemClass on {} hunter shot abilities", fixedShots);
+    }
+
     LOG_INFO("server.loading", ">> Loading spell dbc data corrections  in {} ms", GetMSTimeDiffToNow(oldMSTime));
     LOG_INFO("server.loading", " ");
 }

src/server/scripts/Spells/spell_dk.cpp

@@ -664,6 +664,23 @@ class spell_dk_dancing_rune_weapon : public AuraScript
             return false;
 
         SpellInfo const* spellInfo = eventInfo.GetSpellInfo();
+
+        // Fractured / Paragon: Paragon owners get a "ghostly weapon copies
+        // your swings" identity instead of the stock magical-doppelganger
+        // (which also re-cast Death Coil / Icy Touch / Howling Blast /
+        // etc.). For Paragon callers only, accept auto-attacks and
+        // melee-class abilities (Hamstring, Sinister Strike, Heart Strike,
+        // Frost Strike, Mortal Strike, ...) and reject magic / ranged
+        // spells. Stock DK gating below is left untouched.
+        if (IsParagonWildcardCaller(eventInfo.GetActor()))
+        {
+            if (!eventInfo.GetDamageInfo())
+                return false;
+            if (spellInfo && spellInfo->DmgClass != SPELL_DAMAGE_CLASS_MELEE)
+                return false;
+            return true;
+        }
+
         if (!spellInfo)
             return true;
 
@@ -1916,6 +1933,20 @@ class spell_dk_pestilence : public SpellScript
         if (!target)
             return;
 
+        // Fractured / Paragon: when the Pestilence caster is a Paragon and
+        // wildcard family matching is on, also spread (or refresh) Priest
+        // Devouring Plague. Devouring Plague's Dispel field is DISPEL_DISEASE
+        // and Unit::GetDiseasesByCaster already counts it for Paragon callers
+        // (see Unit.cpp), so it is conceptually a disease; stock Pestilence
+        // just hard-codes Blood Plague + Frost Fever and so silently drops it.
+        // GetAuraOfRankedSpell with the rank-1 id (2944) covers every rank of
+        // Devouring Plague the player has on the target -- we re-cast that
+        // exact same rank so the spread copy carries the caster's actual
+        // damage tier rather than always rank 1. Stock DKs cannot cast
+        // Devouring Plague at all, so the GetAuraOfRankedSpell will return
+        // null for them and this branch is a no-op there.
+        bool const paragonSpread = IsParagonWildcardCaller(caster);
+
         // Spread on others
         if (target != hitUnit)
         {
@@ -1926,6 +1957,11 @@ class spell_dk_pestilence : public SpellScript
             // Frost Fever
             if (target->GetAura(SPELL_DK_FROST_FEVER, caster->GetGUID()))
                 caster->CastSpell(hitUnit, SPELL_DK_FROST_FEVER, true);
+
+            // Fractured / Paragon: Devouring Plague spread.
+            if (paragonSpread)
+                if (Aura const* dp = target->GetAuraOfRankedSpell(2944 /* Devouring Plague r1 */, caster->GetGUID()))
+                    caster->CastSpell(hitUnit, dp->GetId(), true);
         }
         // Refresh on target
         else if (caster->GetAura(SPELL_DK_GLYPH_OF_DISEASE))
@@ -1946,6 +1982,11 @@ class spell_dk_pestilence : public SpellScript
                 disease->RefreshDuration();
             else if (Aura* disease = target->GetAuraOfRankedSpell(SPELL_DK_CRYPT_FEVER_R1, caster->GetGUID()))
                 disease->RefreshDuration();
+
+            // Fractured / Paragon: Devouring Plague Glyph-of-Disease refresh.
+            if (paragonSpread)
+                if (Aura* dp = target->GetAuraOfRankedSpell(2944 /* Devouring Plague r1 */, caster->GetGUID()))
+                    dp->RefreshDuration();
         }
     }
 

src/server/scripts/Spells/spell_shaman.cpp

@@ -1793,8 +1793,10 @@ class spell_sha_maelstrom_weapon : public AuraScript
     // Fractured / Paragon: spell_proc row 53817 is data-relaxed (wildcard
     // family/mask) so cross-class spells can reach this CheckProc. We
     // restore the original Shaman gating here for stock callers and add
-    // the Paragon-only Mage Fireball / Frostbolt / Arcane Blast allowlist
+    // the Paragon-only Mage Fireball / Frostbolt allowlist mirroring the
-    // mirroring the IsAffectedBySpellMod hook in SpellInfo.cpp.
+    // IsAffectedBySpellMod hook in SpellInfo.cpp. Arcane Blast was on the
+    // allowlist briefly but proved too potent stacked with its own
+    // self-buff -- removed.
     bool CheckProc(ProcEventInfo& eventInfo)
     {
         SpellInfo const* procSpell = eventInfo.GetSpellInfo();
@@ -1820,8 +1822,7 @@ class spell_sha_maelstrom_weapon : public AuraScript
             SpellInfo const* first = procSpell->GetFirstRankSpell();
             uint32 firstId = first ? first->Id : procSpell->Id;
             if (firstId == 133 /*Fireball*/
-                || firstId == 116 /*Frostbolt*/
+                || firstId == 116 /*Frostbolt*/)
-                || firstId == 30451 /*Arcane Blast*/)
                 return true;
         }