Docker Build
a1c9172beb
- CONFIG_PARAGON_WILDCARD_FAMILY + Paragon.WildcardFamilyMatching (reloadable) - SpellInfo::IsAffected / IsAffectedBySpellMod(listenerOwner) for Paragon proc/mod wildcard - SpellMgr::CanSpellTriggerProcOnEvent(procOwner) + Aura::IsProcTriggeredOnEvent wiring - Player::IsAffectedBySpellmod passes listener for SpellMod wildcard - ParagonFamilyMatches helper + Nourish / Shred-Maul bleed gate usage in Unit.cpp - Spell::prepare: Paragon consumes 69369 for Nature spells <10s base cast (non-channeled) - spell_paragon_predatory_strikes + SQL 2026_05_11_00.sql (spell_proc + spell_script_names) Co-authored-by: Cursor <cursoragent@cursor.com>
650 lines
27 KiB
C++
650 lines
27 KiB
C++
/*
|
||
* mod-paragon — Paragon (class 12) class hooks
|
||
*
|
||
* See README for design. This file wires Player::IsClass / HasActivePowerType
|
||
* so Paragon can reuse other classes' mechanics in narrowly scoped contexts.
|
||
*/
|
||
|
||
#include "Chat.h"
|
||
#include "Config.h"
|
||
#include "Creature.h"
|
||
#include "CreatureData.h"
|
||
#include "GameTime.h"
|
||
#include "Log.h"
|
||
#include "ObjectGuid.h"
|
||
#include "Pet.h"
|
||
#include "Player.h"
|
||
#include "ScriptMgr.h"
|
||
#include "SharedDefines.h"
|
||
#include "SpellScript.h"
|
||
#include "SpellScriptLoader.h"
|
||
#include "WorldPacket.h"
|
||
#include "WorldSession.h"
|
||
|
||
#include <fmt/format.h>
|
||
#include <string>
|
||
#include <unordered_map>
|
||
|
||
class Paragon_PlayerScript : public PlayerScript
|
||
{
|
||
public:
|
||
Paragon_PlayerScript() : PlayerScript("Paragon_PlayerScript", {
|
||
PLAYERHOOK_ON_PLAYER_IS_CLASS,
|
||
PLAYERHOOK_ON_PLAYER_HAS_ACTIVE_POWER_TYPE,
|
||
PLAYERHOOK_ON_UPDATE,
|
||
PLAYERHOOK_ON_LOGIN,
|
||
PLAYERHOOK_ON_LOGOUT,
|
||
PLAYERHOOK_ON_AFTER_UPDATE_MAX_POWER
|
||
})
|
||
{
|
||
LOG_INFO("module", "[paragon] Paragon_PlayerScript registered "
|
||
"(MultiResource.HasActivePowers={})",
|
||
sConfigMgr->GetOption<bool>("Paragon.MultiResource.HasActivePowers", true));
|
||
}
|
||
|
||
[[nodiscard]] Optional<bool> OnPlayerIsClass(Player const* player, Classes unitClass, ClassContext context) override
|
||
{
|
||
if (!player || player->getClass() != CLASS_PARAGON)
|
||
return std::nullopt;
|
||
|
||
// ============================================================
|
||
// Ability stack -- claim ALL nine vanilla classes.
|
||
// ============================================================
|
||
// CLASS_CONTEXT_ABILITY is read by every class-specific spell
|
||
// gate in core / scripts: DK rune mechanics (Spell.cpp,
|
||
// SpellEffects.cpp, spell_dk.cpp, SpellAuraEffects.cpp),
|
||
// Warrior Titan's Grip / Bladestorm (Player.cpp 3783, 15432,
|
||
// PlayerUpdates.cpp 1547), Paladin Rebuke (Player.cpp 15441),
|
||
// Shaman dual-wield bookkeeping (Player.cpp 5028), Hunter pet
|
||
// / Hunter's Mark gates (spell_item.cpp 3718), Druid Insect
|
||
// Swarm / Wild Growth (SpellAuraEffects.cpp 2153, 2232),
|
||
// Priest Spirit of Redemption out-of-bounds check (Unit.cpp
|
||
// 14238), Rogue pickpocketing (LootHandler.cpp 86/165/385,
|
||
// Vehicle.cpp 80). Paragon learns abilities from every class
|
||
// through Character Advancement, so claiming all of them lets
|
||
// every gated spell script execute its class-specific branch
|
||
// for our players. The only downside is double-pathed scripts
|
||
// (e.g. a spell with both warrior and rogue branches) will
|
||
// pick whichever the script tests first -- acceptable.
|
||
if (context == CLASS_CONTEXT_ABILITY)
|
||
return true;
|
||
|
||
// ============================================================
|
||
// Reactive melee states.
|
||
// ============================================================
|
||
// Warrior dodge -> AURA_STATE_DEFENSE (Overpower window).
|
||
// Hunter parry -> AURA_STATE_HUNTER_PARRY (Counterattack).
|
||
// We intentionally do NOT claim CLASS_ROGUE here:
|
||
// Unit::ProcDamageAndSpellFor (Unit.cpp 12824) skips the
|
||
// generic AURA_STATE_DEFENSE update on dodge for rogues so
|
||
// Riposte can take over. Claiming rogue would silently kill
|
||
// Overpower for Paragon, and Riposte already works for us via
|
||
// the warrior-style state we already grant.
|
||
if (context == CLASS_CONTEXT_ABILITY_REACTIVE)
|
||
{
|
||
if (unitClass == CLASS_WARRIOR || unitClass == CLASS_HUNTER)
|
||
return true;
|
||
}
|
||
|
||
// ============================================================
|
||
// Pet ownership contexts.
|
||
// ============================================================
|
||
// CLASS_CONTEXT_PET is read by Pet::AddToWorld, Pet::CreateBase
|
||
// AtCreatureInfo, Pet::InitStatsForLevel (twice -- the
|
||
// MAX_PET_TYPE bootstrap branch and the per-class attack-time
|
||
// scaling), Pet::IsPermanentPetFor, Player::SummonPet,
|
||
// Player::CanResummonPet, Spell::EffectTameCreature,
|
||
// SpellEffects.cpp (CreateTamedPet debug effects, Eyes of the
|
||
// Beast), spell_generic.cpp 1760 (charm-as-pet conversion),
|
||
// and PlayerGossip.cpp's hunter stable check.
|
||
//
|
||
// The cleanest disambiguation is by the *active pet's* shape:
|
||
// HUNTER_PET -> hunter (beast tame)
|
||
// SUMMON_PET + DEMON type -> warlock (Imp/VW/Succ/...)
|
||
// SUMMON_PET + UNDEAD type -> DK ghoul / Army of Dead
|
||
// SUMMON_PET + ELEMENTAL type -> mage water / shaman fire
|
||
// For HUNTER specifically the no-pet case is also claimed so
|
||
// Tame Beast's EffectTameCreature gate passes during cast.
|
||
if (context == CLASS_CONTEXT_PET)
|
||
{
|
||
Pet const* activePet = const_cast<Player*>(player)->GetPet();
|
||
|
||
// Hunter beast: claim during taming OR when a HUNTER_PET is
|
||
// already active. This is what makes Tame Beast / Call Pet
|
||
// / pet stable / Counterattack pet aura feedback work.
|
||
if (unitClass == CLASS_HUNTER)
|
||
{
|
||
if (!activePet || activePet->getPetType() == HUNTER_PET)
|
||
return true;
|
||
return std::nullopt;
|
||
}
|
||
|
||
// All other classes only claim when an active SUMMON_PET is
|
||
// present. We then disambiguate by the creature's type
|
||
// because warlock / DK / mage / shaman all use SUMMON_PET.
|
||
if (!activePet || activePet->getPetType() != SUMMON_PET)
|
||
return std::nullopt;
|
||
|
||
CreatureTemplate const* tmpl = activePet->GetCreatureTemplate();
|
||
if (!tmpl)
|
||
return std::nullopt;
|
||
|
||
switch (unitClass)
|
||
{
|
||
case CLASS_WARLOCK:
|
||
// Drives Master Demonologist / Demonic Knowledge /
|
||
// Demonic Pact propagation, last-pet-spell tracking
|
||
// (Pet.cpp 112), and IsPermanentPetFor (Pet.cpp
|
||
// 2288) so demon pets persist across logins.
|
||
if (tmpl->type == CREATURE_TYPE_DEMON)
|
||
return true;
|
||
break;
|
||
case CLASS_DEATH_KNIGHT:
|
||
// Risen Ghoul + Army of the Dead. Player.cpp 14354
|
||
// and Pet.cpp 243 / 1046 / 2290 read this; without
|
||
// it the ghoul is invisible to the owner mid-load
|
||
// and ScriptedAI hooks on the ghoul mis-route.
|
||
if (tmpl->type == CREATURE_TYPE_UNDEAD)
|
||
return true;
|
||
break;
|
||
case CLASS_MAGE:
|
||
// Glyph-of-Eternal-Water permanent Water Elemental
|
||
// (entry 510, 37994). Used by Pet.cpp 1047/2292.
|
||
if (tmpl->type == CREATURE_TYPE_ELEMENTAL)
|
||
return true;
|
||
break;
|
||
case CLASS_SHAMAN:
|
||
// Fire Elemental / Earth Elemental. The base
|
||
// engine spawns these as creatures rather than
|
||
// proper Pet instances in most code paths, so the
|
||
// claim mostly matters for the Pet.cpp 1045 stat
|
||
// bootstrap when one is loaded as a SUMMON_PET.
|
||
if (tmpl->type == CREATURE_TYPE_ELEMENTAL)
|
||
return true;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return std::nullopt;
|
||
}
|
||
|
||
// Warlock pet-charm context (Enslave Demon -- Unit.cpp 14828,
|
||
// 14894, 15025). Without this claim, charming a demon as a
|
||
// Paragon doesn't get the warlock-flavor charm semantics
|
||
// (faction-set-on-charm, action-bar layout, charm-break logic).
|
||
if (unitClass == CLASS_WARLOCK && context == CLASS_CONTEXT_PET_CHARM)
|
||
return true;
|
||
|
||
// ============================================================
|
||
// Equipment contexts.
|
||
// ============================================================
|
||
// CLASS_CONTEXT_EQUIP_RELIC: PlayerStorage.cpp 224-240 +
|
||
// 2475-2493. Routes Librams/Idols/Totems/Misc/Sigils into
|
||
// EQUIPMENT_SLOT_RANGED for the matching class. Claim every
|
||
// relic-bearing class so a Paragon can drop any of them into
|
||
// the ranged slot.
|
||
if (context == CLASS_CONTEXT_EQUIP_RELIC)
|
||
{
|
||
switch (unitClass)
|
||
{
|
||
case CLASS_PALADIN:
|
||
case CLASS_DRUID:
|
||
case CLASS_SHAMAN:
|
||
case CLASS_WARLOCK:
|
||
case CLASS_DEATH_KNIGHT:
|
||
return true;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
// CLASS_CONTEXT_EQUIP_ARMOR_CLASS: PlayerStorage.cpp 2326,
|
||
// 2330, 2503-2523. At level 40 each class auto-learns its
|
||
// top armor proficiency. Paragon should pick up plate (via
|
||
// paladin/DK), shields (paladin/warrior/shaman), mail
|
||
// (hunter/shaman), and leather (rogue) so the level-40 train
|
||
// event grants Paragon full proficiency and we don't have to
|
||
// hand-curate it through the Paragon proficiency SQL.
|
||
if (context == CLASS_CONTEXT_EQUIP_ARMOR_CLASS)
|
||
{
|
||
switch (unitClass)
|
||
{
|
||
case CLASS_PALADIN:
|
||
case CLASS_WARRIOR:
|
||
case CLASS_DEATH_KNIGHT:
|
||
case CLASS_HUNTER:
|
||
case CLASS_SHAMAN:
|
||
case CLASS_DRUID:
|
||
case CLASS_ROGUE:
|
||
return true;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
// CLASS_CONTEXT_EQUIP_SHIELDS: PlayerStorage.cpp 2467-2469.
|
||
// Lets a Paragon equip shields without a paladin/warrior/
|
||
// shaman skill gate.
|
||
if (context == CLASS_CONTEXT_EQUIP_SHIELDS)
|
||
{
|
||
switch (unitClass)
|
||
{
|
||
case CLASS_PALADIN:
|
||
case CLASS_WARRIOR:
|
||
case CLASS_SHAMAN:
|
||
return true;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
// CLASS_CONTEXT_WEAPON_SWAP: PlayerStorage.cpp 1920, 2838 --
|
||
// rogue uses cooldown spell 6123 instead of 6119 on weapon
|
||
// swap (Quick Draw / Combat Potency interactions). Claim
|
||
// rogue so Paragon picks up the same cooldown spell.
|
||
if (context == CLASS_CONTEXT_WEAPON_SWAP && unitClass == CLASS_ROGUE)
|
||
return true;
|
||
|
||
// ============================================================
|
||
// Contexts we DELIBERATELY DO NOT claim:
|
||
// ============================================================
|
||
// CLASS_CONTEXT_STATS -- Paragon has its own STR/AGI->AP and
|
||
// INT/SPI->SP curves wired in StatSystem.cpp's CLASS_PARAGON
|
||
// branch (level*2 + STR + AGI - 20 etc.). Claiming any
|
||
// vanilla class here would override our curves with theirs.
|
||
//
|
||
// CLASS_CONTEXT_INIT, _TELEPORT, _QUEST, _TAXI, _SKILL,
|
||
// _GRAVEYARD, _CLASS_TRAINER, _TALENT_POINT_CALC -- all
|
||
// used by DK Ebon Hold / druid Moonglade starting-zone
|
||
// scripts. Paragon doesn't go through those zones and we
|
||
// don't want our players bound to Acherus or trapped in
|
||
// the DK starting quest gates.
|
||
return std::nullopt;
|
||
}
|
||
|
||
[[nodiscard]] bool OnPlayerHasActivePowerType(Player const* player, Powers power) override
|
||
{
|
||
if (!player || player->getClass() != CLASS_PARAGON)
|
||
return false;
|
||
|
||
if (power == POWER_RUNIC_POWER || power == POWER_RUNE)
|
||
return true;
|
||
|
||
if (sConfigMgr->GetOption<bool>("Paragon.MultiResource.HasActivePowers", true))
|
||
{
|
||
switch (power)
|
||
{
|
||
case POWER_MANA:
|
||
case POWER_RAGE:
|
||
case POWER_ENERGY:
|
||
case POWER_FOCUS:
|
||
return true;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// ChrClasses.dbc says POWER_RUNE has no pool (Unit::GetCreatePowers returns 0
|
||
// for POWER_RUNE), so Player::InitStatsForLevel and the level-reset path
|
||
// both clobber MaxPower(POWER_RUNE)=0 every login. The 3.3.5 client greys
|
||
// the action button for any rune-cost spell when UnitPowerMax(player,
|
||
// SPELL_POWER_RUNES) is 0 — visual rune pips can still animate via
|
||
// PLAYER_RUNE_REGEN_*, but the spell stays unusable.
|
||
//
|
||
// Fix: pin POWER_RUNE max=8 (and current=8 in the easy spots) for Paragon
|
||
// anywhere UpdateMaxPower runs. Rune availability is still authoritatively
|
||
// tracked in m_runes; this just keeps the client engine happy.
|
||
void OnPlayerAfterUpdateMaxPower(Player* player, Powers& power, float& value) override
|
||
{
|
||
if (!player || player->getClass() != CLASS_PARAGON)
|
||
return;
|
||
|
||
if (power == POWER_RUNE)
|
||
value = 8.0f;
|
||
else if (power == POWER_RUNIC_POWER)
|
||
value = 1000.0f;
|
||
}
|
||
|
||
// Login: re-claim MaxPower for POWER_RUNE / POWER_RUNIC_POWER and seed
|
||
// the rune state to the client. Player::LoadFromDB runs InitStatsForLevel
|
||
// which calls Unit::SetMaxPower with the value from GetCreatePowers — and
|
||
// GetCreatePowers returns 0 for POWER_RUNE (engine assumption: only DK has
|
||
// runes; class is identified via getClass(), not IsClass()). So we have to
|
||
// overwrite MaxPower here once the player is fully loaded. ResyncRunes is
|
||
// a one-shot push so the rune frame is correct on first appearance.
|
||
void OnPlayerLogin(Player* player) override
|
||
{
|
||
if (!player || player->getClass() != CLASS_PARAGON)
|
||
return;
|
||
|
||
player->SetMaxPower(POWER_RUNE, 8);
|
||
if (player->GetMaxPower(POWER_RUNIC_POWER) <= 0)
|
||
player->SetMaxPower(POWER_RUNIC_POWER, 1000);
|
||
player->ResyncRunes(MAX_RUNES);
|
||
|
||
ParagonRuneSyncState seed;
|
||
seed.lastReadyMask = 0;
|
||
for (uint8 i = 0; i < MAX_RUNES; ++i)
|
||
if (player->GetRuneCooldown(i) == 0)
|
||
seed.lastReadyMask |= (1u << i);
|
||
runeSyncByGuid[player->GetGUID()] = seed;
|
||
}
|
||
|
||
void OnPlayerLogout(Player* player) override
|
||
{
|
||
if (!player)
|
||
return;
|
||
runeSyncByGuid.erase(player->GetGUID());
|
||
}
|
||
|
||
// Per-tick rune state pump for Paragon.
|
||
//
|
||
// Two responsibilities:
|
||
//
|
||
// 1. UNIT_FIELD_POWER5 (POWER_RUNE) tracks the live ready-rune count. The
|
||
// 3.3.5 client's local "is this action usable" check on rune-cost
|
||
// spells reads UnitPower(player, SPELL_POWER_RUNES); for DK that's
|
||
// engine-managed but Paragon must own it.
|
||
//
|
||
// 2. Push SMSG_RESYNC_RUNES *only* on ready-bitmask transitions (rune
|
||
// consumed → on cd, or finished cd → ready). We deliberately do NOT
|
||
// push during the cooldown — Player::ResyncRunes encodes the per-rune
|
||
// "passed cooldown" byte as `255 - cd_ms * 51`, which is monotonic
|
||
// only for cd values in seconds (0..5). With cd in milliseconds the
|
||
// byte oscillates wildly tick-to-tick (cd=10000 → 207, cd=9000 → 7,
|
||
// cd=8000 → 63). Frequent resyncs feed the client garbage and freeze
|
||
// the rune frame. One mask-change resync is enough; sweeps run on the
|
||
// client's own 10s timer started from SMSG_SPELL_GO's CAST_FLAG_RUNE_LIST
|
||
// payload (which uses correct encoding) plus a Lua-side
|
||
// GetRuneCooldown poll in RuneFrame.lua.
|
||
void OnPlayerUpdate(Player* player, uint32 /*p_time*/) override
|
||
{
|
||
if (!player || player->getClass() != CLASS_PARAGON)
|
||
return;
|
||
|
||
uint8 readyMask = 0;
|
||
uint8 readyCount = 0;
|
||
for (uint8 i = 0; i < MAX_RUNES; ++i)
|
||
{
|
||
if (player->GetRuneCooldown(i) == 0)
|
||
{
|
||
readyMask |= (1u << i);
|
||
++readyCount;
|
||
}
|
||
}
|
||
|
||
if (uint32(readyCount) != player->GetPower(POWER_RUNE))
|
||
player->SetPower(POWER_RUNE, readyCount);
|
||
|
||
ParagonRuneSyncState& st = runeSyncByGuid[player->GetGUID()];
|
||
if (readyMask != st.lastReadyMask)
|
||
{
|
||
player->ResyncRunes(MAX_RUNES);
|
||
st.lastReadyMask = readyMask;
|
||
|
||
// Authoritative rune CD pump (PARAA "R RUNES cd0 cd1 ... cd5",
|
||
// ms remaining per slot, 0 = ready). The 3.3.5 client engine
|
||
// class-gates SMSG_RESYNC_RUNES / SMSG_SPELL_GO RUNE_LIST to DK,
|
||
// so the Paragon RuneFrame sim drives the visual entirely off
|
||
// COMBAT_LOG_EVENT_UNFILTERED:SPELL_CAST_SUCCESS. The combat log
|
||
// arrives ~100–200ms after the server already started the
|
||
// cooldown, so the client's local timer trails the server. When
|
||
// the user spams a rune spell, the server's slot refreshes
|
||
// first, accepts the next cast, but the client UI still shows
|
||
// CD remaining → "leak-through" past a greyed icon. Pushing the
|
||
// actual remaining ms on every mask transition keeps the
|
||
// visual locked to server state.
|
||
std::string body = "R RUNES";
|
||
for (uint8 i = 0; i < MAX_RUNES; ++i)
|
||
body += " " + std::to_string(player->GetRuneCooldown(i));
|
||
std::string const payload = std::string(kParagonAddonPrefix) + "\t" + body;
|
||
WorldPacket runePkt;
|
||
ChatHandler::BuildChatPacket(runePkt, CHAT_MSG_WHISPER, LANG_ADDON, player, player, payload);
|
||
player->SendDirectMessage(&runePkt);
|
||
}
|
||
|
||
// Combo point pump: the 3.3.5 client engine class-gates SMSG_UPDATE_COMBO_POINTS
|
||
// to rogue / druid, so the Paragon UI sim never sees CP changes from
|
||
// Honor Among Thieves / Mutilate / etc. via either the engine state or
|
||
// the client-side combat-log inference (HAT's 51699 trigger fires with a
|
||
// null target and doesn't always emit SPELL_CAST_SUCCESS in the log).
|
||
// Push the count over PARAA whenever it changes; the addon's combo
|
||
// simulator listens for "R CP <n>" and overwrites paragonCP, so the
|
||
// ComboFrame on the target frame paints reliably.
|
||
int8 const cp = player->GetComboPoints();
|
||
if (cp != st.lastCp)
|
||
{
|
||
std::string const payload = std::string(kParagonAddonPrefix) + "\t"
|
||
+ fmt::format("R CP {}", int32(cp));
|
||
WorldPacket data;
|
||
ChatHandler::BuildChatPacket(data, CHAT_MSG_WHISPER, LANG_ADDON, player, player, payload);
|
||
player->SendDirectMessage(&data);
|
||
st.lastCp = cp;
|
||
}
|
||
|
||
if (!sConfigMgr->GetOption<bool>("Paragon.Diag.RuneTrace", false))
|
||
return;
|
||
|
||
static thread_local time_t lastLogged = 0;
|
||
time_t const wall = GameTime::GetGameTime().count();
|
||
if (wall - lastLogged < 5)
|
||
return;
|
||
lastLogged = wall;
|
||
|
||
std::string out;
|
||
for (uint8 i = 0; i < MAX_RUNES; ++i)
|
||
{
|
||
char buf[64];
|
||
snprintf(buf, sizeof(buf), "[%u: type=%u cur=%u cd=%u]",
|
||
i,
|
||
uint32(player->GetBaseRune(i)),
|
||
uint32(player->GetCurrentRune(i)),
|
||
uint32(player->GetRuneCooldown(i)));
|
||
out += buf;
|
||
}
|
||
LOG_INFO("module", "[paragon-diag] {} runes: {} mask=0x{:02x}",
|
||
player->GetName(), out, uint32(readyMask));
|
||
}
|
||
|
||
private:
|
||
struct ParagonRuneSyncState
|
||
{
|
||
uint8 lastReadyMask{0xFFu}; // sentinel: no prior snapshot
|
||
int8 lastCp{-1}; // sentinel: no prior snapshot
|
||
};
|
||
|
||
static constexpr char const* kParagonAddonPrefix = "PARAA";
|
||
|
||
static std::unordered_map<ObjectGuid, ParagonRuneSyncState> runeSyncByGuid;
|
||
};
|
||
|
||
std::unordered_map<ObjectGuid, Paragon_PlayerScript::ParagonRuneSyncState> Paragon_PlayerScript::runeSyncByGuid;
|
||
|
||
// Arcane Torrent (28730) for Paragon: Blood Elf racial skill line 756 has
|
||
// three Arcane Torrent variants in stock WotLK (28730 mana, 25046 rogue
|
||
// energy, 50613 DK runic power). For Paragon Blood Elves we keep only 28730
|
||
// (see migration 2026_05_10_03.sql) and turn it into a "combined" version:
|
||
// the stock spell already silences nearby enemies and energizes mana via its
|
||
// own effects; this script adds energy, rage, and runic power energize on
|
||
// top when the caster is class 12, so a single button refunds whichever
|
||
// resource pool the player is actually using. Non-Paragon casters are
|
||
// untouched and keep learning their stock racial variant.
|
||
class spell_paragon_arcane_torrent : public SpellScript
|
||
{
|
||
PrepareSpellScript(spell_paragon_arcane_torrent);
|
||
|
||
void HandleAfterCast()
|
||
{
|
||
Unit* caster = GetCaster();
|
||
if (!caster || !caster->IsPlayer())
|
||
return;
|
||
|
||
Player* player = caster->ToPlayer();
|
||
if (player->getClass() != CLASS_PARAGON)
|
||
return;
|
||
|
||
// Stock energize amounts from spell_dbc:
|
||
// 25046 Arcane Torrent (Energy) -> 15 energy
|
||
// 50613 Arcane Torrent (Runic Power) -> 15 displayed RP (= 150
|
||
// internal; AC stores RP scaled 10x, see Player::SetMaxPower
|
||
// POWER_RUNIC_POWER, 1000).
|
||
// Rage uses the same 10x internal scaling as runic power (see
|
||
// Player.cpp:Regenerate where rage decay is `-20` for "2 rage by
|
||
// tick"), so 15 displayed rage = 150 internal.
|
||
// ModifyPower no-ops on pools the player has no max for, so this is
|
||
// safe even before the Paragon picks up energy/rage/RP abilities.
|
||
constexpr int32 kEnergyGain = 15;
|
||
constexpr int32 kRageGain = 150;
|
||
constexpr int32 kRunicPowerGain = 150;
|
||
|
||
SpellInfo const* spellInfo = GetSpellInfo();
|
||
uint32 const spellId = spellInfo ? spellInfo->Id : 28730u;
|
||
|
||
caster->EnergizeBySpell(player, spellId, kEnergyGain, POWER_ENERGY);
|
||
caster->EnergizeBySpell(player, spellId, kRageGain, POWER_RAGE);
|
||
caster->EnergizeBySpell(player, spellId, kRunicPowerGain, POWER_RUNIC_POWER);
|
||
}
|
||
|
||
void Register() override
|
||
{
|
||
AfterCast += SpellCastFn(spell_paragon_arcane_torrent::HandleAfterCast);
|
||
}
|
||
};
|
||
|
||
// Predatory Strikes (16972 / 16974 / 16975) for Paragon: re-implements the
|
||
// Cataclysm-era proc behavior of the talent so a Paragon's damaging
|
||
// finishers (Eviscerate / Envenom / Ferocious Bite / Rip / Rupture) can
|
||
// roll Predator's Swiftness (69369) -- the same buff that real druids
|
||
// get from the Cata redesign of this talent. Combined with the
|
||
// Spell::prepare interception in core (Spell.cpp), 69369 makes the
|
||
// Paragon's NEXT Nature-school spell with a base cast time below 10s
|
||
// instant cast: Chain Lightning, Lightning Bolt, Healing Touch, Wrath,
|
||
// Nourish, etc. -- not just the Druid-family Nature subset that the
|
||
// stock SPELLMOD_CASTING_TIME mask on 69369 covers.
|
||
//
|
||
// Filter logic:
|
||
// - Source spell must consume combo points (NeedsComboPoints() — gates
|
||
// out non-finisher combo-point builders).
|
||
// - "Damaging finisher": SPELL_ATTR1_FINISHING_MOVE_DAMAGE (Eviscerate,
|
||
// Envenom, Ferocious Bite, ...) OR a SPELL_ATTR1_FINISHING_MOVE_DURATION
|
||
// finisher that applies periodic damage (Rip, Rupture). Duration
|
||
// finishers that only heal (Recuperate) or only buff / CC / armor shred
|
||
// (Slice and Dice, Savage Roar, Kidney Shot, Maim, Expose Armor) are
|
||
// rejected.
|
||
//
|
||
// Chance per combo point matches the Cataclysm tuning that the user's
|
||
// client tooltip text reflects: rank 1 = 3% per CP, rank 2 = 5% per CP,
|
||
// rank 3 = 7% per CP. At 5 CP that is 15% / 25% / 35%, capped at 100%.
|
||
//
|
||
// Combo-point read happens during PROC_SPELL_PHASE_CAST, which fires in
|
||
// Spell::cast → Spell::ProcReflectProcs / Unit::ProcDamageAndSpellFor
|
||
// BEFORE Spell::_handle_finish_phase clears the player's combo points
|
||
// (see Spell.cpp:_handle_finish_phase clearing combo points). So
|
||
// player->GetComboPoints() inside HandleProc returns the pre-clear value.
|
||
class spell_paragon_predatory_strikes : public AuraScript
|
||
{
|
||
PrepareAuraScript(spell_paragon_predatory_strikes);
|
||
|
||
static constexpr uint32 SPELL_PARAGON_PREDATORS_SWIFTNESS = 69369;
|
||
|
||
bool Validate(SpellInfo const* /*spellInfo*/) override
|
||
{
|
||
return ValidateSpellInfo({ SPELL_PARAGON_PREDATORS_SWIFTNESS });
|
||
}
|
||
|
||
bool CheckProc(ProcEventInfo& eventInfo)
|
||
{
|
||
SpellInfo const* spellInfo = eventInfo.GetSpellInfo();
|
||
if (!spellInfo || !spellInfo->NeedsComboPoints())
|
||
return false;
|
||
|
||
if (spellInfo->HasAttribute(SPELL_ATTR1_FINISHING_MOVE_DAMAGE))
|
||
return true;
|
||
|
||
if (spellInfo->HasAttribute(SPELL_ATTR1_FINISHING_MOVE_DURATION))
|
||
{
|
||
bool periodicHeal = false;
|
||
bool periodicDamage = false;
|
||
for (SpellEffectInfo const& eff : spellInfo->Effects)
|
||
{
|
||
if (eff.Effect != SPELL_EFFECT_APPLY_AURA && eff.Effect != SPELL_EFFECT_APPLY_AREA_AURA_PARTY
|
||
&& eff.Effect != SPELL_EFFECT_PERSISTENT_AREA_AURA)
|
||
continue;
|
||
|
||
switch (eff.ApplyAuraName)
|
||
{
|
||
case SPELL_AURA_PERIODIC_HEAL:
|
||
case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
|
||
case SPELL_AURA_OBS_MOD_HEALTH:
|
||
periodicHeal = true;
|
||
break;
|
||
case SPELL_AURA_PERIODIC_DAMAGE:
|
||
case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
|
||
case SPELL_AURA_PERIODIC_LEECH:
|
||
periodicDamage = true;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (periodicHeal)
|
||
return false;
|
||
|
||
return periodicDamage;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
void HandleProc(ProcEventInfo& eventInfo)
|
||
{
|
||
PreventDefaultAction();
|
||
|
||
Unit* actor = eventInfo.GetActor();
|
||
Player* player = actor ? actor->ToPlayer() : nullptr;
|
||
if (!player || player->getClass() != CLASS_PARAGON)
|
||
return;
|
||
|
||
uint8 const cp = player->GetComboPoints();
|
||
if (cp == 0)
|
||
return;
|
||
|
||
SpellInfo const* talent = GetSpellInfo();
|
||
if (!talent)
|
||
return;
|
||
|
||
uint32 pctPerCP = 0;
|
||
switch (talent->Id)
|
||
{
|
||
case 16972: pctPerCP = 3; break;
|
||
case 16974: pctPerCP = 5; break;
|
||
case 16975: pctPerCP = 7; break;
|
||
default:
|
||
return;
|
||
}
|
||
|
||
uint32 const chance = std::min<uint32>(100u, pctPerCP * uint32(cp));
|
||
if (!roll_chance_i(int32(chance)))
|
||
return;
|
||
|
||
player->CastSpell(player, SPELL_PARAGON_PREDATORS_SWIFTNESS, true);
|
||
}
|
||
|
||
void Register() override
|
||
{
|
||
DoCheckProc += AuraCheckProcFn(spell_paragon_predatory_strikes::CheckProc);
|
||
OnProc += AuraProcFn(spell_paragon_predatory_strikes::HandleProc);
|
||
}
|
||
};
|
||
|
||
void AddSC_paragon()
|
||
{
|
||
new Paragon_PlayerScript();
|
||
RegisterSpellScript(spell_paragon_arcane_torrent);
|
||
RegisterSpellScript(spell_paragon_predatory_strikes);
|
||
}
|