Docker Build
da17074a63
Lets the Paragon class buy Runeforging from the Character Advancement
panel and apply rune enchants from anywhere in the world without needing
to be near a runeforge GameObject. Three carve-outs work together:
* Spell.cpp: bypass the SpellFocusObject GO proximity check when the
caster is a Paragon and the spell belongs to SKILL_RUNEFORGING (776).
Stock DK behaviour is unchanged -- the bypass is gated on
getClass() == CLASS_PARAGON, not on the IsClass() context hook.
* Player.cpp: skip the Paragon class-skill cascade block for skill 776
so the rune-enchant SLA cascade actually fires. Without this the
player gets the Runeforging skill but no rune options at the anvil.
* Paragon_Essence.cpp:
- Treat SKILL_RUNEFORGING children as a meta-skill cluster: cascade
them like passives even though they're active casts, so they stick
as panel_spell_children and get cleaned up via the standard refund
path.
- Whitelist the 8 basic rune-enchants in PruneSkillLineCascadeChildren
so they don't get evicted as "active in children = legacy garbage".
- Force-attach them in PanelLearnSpellChain (the SLA rows ship with
AcquireMethod=0, so the engine cascade alone won't grant them).
- Add an OnPlayerLogin fixup so existing Paragons who bought
Runeforging before this change get the 8 runes retro-granted.
- Stop filtering SPELL_ATTR0_DO_NOT_DISPLAY in PushSpellSnapshot --
Runeforging itself is hidden in the DBC but is a real panel
purchase that must show in the Overview tab.
The two advanced runes (Stoneskin Gargoyle, Nerubian Carapace) are
intentionally excluded from the auto-grant -- retail gates them behind
heroic dungeon / raid item drops and the SLA AcquireMethod=0 honours
that gating.
No SQL migration needed; works against existing DBC + SLA data.
Co-authored-by: Cursor <cursoragent@cursor.com>
4921 lines
196 KiB
C++
4921 lines
196 KiB
C++
/*
|
|
* mod-paragon — Ability Essence (AE) / Talent Essence (TE)
|
|
*
|
|
* Inspired by Project Ascension's classless currencies (see Fandom:
|
|
* Ability Essence / Talent Essence). Server-side only: values persist in
|
|
* character_paragon_currency; optional per-spell AE costs live in world
|
|
* table paragon_spell_ae_cost. Client UI for bars / advancement panels is
|
|
* separate (see README).
|
|
*/
|
|
|
|
#include "CharacterDatabase.h"
|
|
#include "Chat.h"
|
|
#include "CommandScript.h"
|
|
#include "Config.h"
|
|
#include "Pet.h"
|
|
#include "Player.h"
|
|
#include "Random.h"
|
|
#include "RBAC.h"
|
|
#include "ScriptMgr.h"
|
|
#include "SharedDefines.h"
|
|
#include "SpellAuras.h"
|
|
#include "SpellInfo.h"
|
|
#include "SpellMgr.h"
|
|
#include "WorldDatabase.h"
|
|
#include "WorldPacket.h"
|
|
#include "Log.h"
|
|
#include "DBCEnums.h"
|
|
#include "DBCStores.h"
|
|
|
|
#include <fmt/format.h>
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cctype>
|
|
#include <cstdlib>
|
|
#include <string_view>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
using namespace Acore::ChatCommands;
|
|
|
|
namespace
|
|
{
|
|
// Wire-format prefix shared with the ParagonAdvancement addon (Net.lua).
|
|
char const* const kAddonPrefix = "PARAA";
|
|
|
|
struct ParagonCurrencyData
|
|
{
|
|
uint32 abilityEssence = 0;
|
|
uint32 talentEssence = 0;
|
|
};
|
|
|
|
std::unordered_map<uint32, ParagonCurrencyData> gParagonCurrencyCache;
|
|
|
|
uint32 ComputeStartingAE(uint8 level)
|
|
{
|
|
uint32 base = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.Start", 9);
|
|
uint32 per = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.PerLevel", 1);
|
|
uint32 minLv = sConfigMgr->GetOption<uint32>("Paragon.Currency.GrantLevelMin", 10);
|
|
if (level >= minLv)
|
|
base += uint32(level - minLv + 1) * per;
|
|
return base;
|
|
}
|
|
|
|
uint32 ComputeStartingTE(uint8 level)
|
|
{
|
|
uint32 base = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.Start", 0);
|
|
uint32 per = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.PerLevel", 1);
|
|
uint32 minLv = sConfigMgr->GetOption<uint32>("Paragon.Currency.GrantLevelMin", 10);
|
|
if (level >= minLv)
|
|
base += uint32(level - minLv + 1) * per;
|
|
return base;
|
|
}
|
|
|
|
ParagonCurrencyData& GetOrCreateCacheEntry(uint32 lowGuid)
|
|
{
|
|
return gParagonCurrencyCache[lowGuid];
|
|
}
|
|
|
|
void DbUpsertCurrency(uint32 lowGuid, uint32 ae, uint32 te)
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"REPLACE INTO character_paragon_currency (guid, ability_essence, talent_essence) VALUES ({}, {}, {})",
|
|
lowGuid, ae, te);
|
|
}
|
|
|
|
void LoadCurrencyFromDb(Player* player)
|
|
{
|
|
if (!player || player->getClass() != CLASS_PARAGON)
|
|
return;
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
return;
|
|
|
|
uint32 const lowGuid = player->GetGUID().GetCounter();
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT ability_essence, talent_essence FROM character_paragon_currency WHERE guid = {}", lowGuid))
|
|
{
|
|
Field const* f = r->Fetch();
|
|
ParagonCurrencyData& d = GetOrCreateCacheEntry(lowGuid);
|
|
d.abilityEssence = f[0].Get<uint32>();
|
|
d.talentEssence = f[1].Get<uint32>();
|
|
return;
|
|
}
|
|
|
|
uint32 const ae = ComputeStartingAE(player->GetLevel());
|
|
uint32 const te = ComputeStartingTE(player->GetLevel());
|
|
DbUpsertCurrency(lowGuid, ae, te);
|
|
ParagonCurrencyData& d = GetOrCreateCacheEntry(lowGuid);
|
|
d.abilityEssence = ae;
|
|
d.talentEssence = te;
|
|
}
|
|
|
|
void SaveCurrencyToDb(Player* player)
|
|
{
|
|
if (!player || player->getClass() != CLASS_PARAGON)
|
|
return;
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
return;
|
|
|
|
uint32 const lowGuid = player->GetGUID().GetCounter();
|
|
auto itr = gParagonCurrencyCache.find(lowGuid);
|
|
if (itr == gParagonCurrencyCache.end())
|
|
return;
|
|
|
|
DbUpsertCurrency(lowGuid, itr->second.abilityEssence, itr->second.talentEssence);
|
|
}
|
|
|
|
void RemoveCacheEntry(uint32 lowGuid)
|
|
{
|
|
gParagonCurrencyCache.erase(lowGuid);
|
|
}
|
|
|
|
uint32 GetAE(Player* player)
|
|
{
|
|
if (!player)
|
|
return 0;
|
|
auto itr = gParagonCurrencyCache.find(player->GetGUID().GetCounter());
|
|
if (itr == gParagonCurrencyCache.end())
|
|
return 0;
|
|
return itr->second.abilityEssence;
|
|
}
|
|
|
|
uint32 GetTE(Player* player)
|
|
{
|
|
if (!player)
|
|
return 0;
|
|
auto itr = gParagonCurrencyCache.find(player->GetGUID().GetCounter());
|
|
if (itr == gParagonCurrencyCache.end())
|
|
return 0;
|
|
return itr->second.talentEssence;
|
|
}
|
|
|
|
// Pushes an addon-channel message to a single player. The 3.3.5 client
|
|
// recognises CHAT_MSG_WHISPER+LANG_ADDON as an addon broadcast and fires
|
|
// CHAT_MSG_ADDON locally, splitting payload on the first tab into
|
|
// (prefix, body). The ParagonAdvancement addon listens for prefix "PARAA".
|
|
void SendAddonMessage(Player* player, std::string const& body)
|
|
{
|
|
if (!player || !player->GetSession())
|
|
return;
|
|
|
|
std::string payload = std::string(kAddonPrefix) + "\t" + body;
|
|
WorldPacket data;
|
|
ChatHandler::BuildChatPacket(data, CHAT_MSG_WHISPER, LANG_ADDON, player, player, payload);
|
|
player->SendDirectMessage(&data);
|
|
}
|
|
|
|
// Helper: send "R CURRENCY <ae> <te>" so the client can update its
|
|
// authoritative balance. Safe to call any time the cached values change.
|
|
void PushCurrency(Player* player)
|
|
{
|
|
if (!player || player->getClass() != CLASS_PARAGON)
|
|
return;
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
return;
|
|
|
|
// Defensive: if for any reason the in-memory cache has lost this player
|
|
// (race during login, hot-reload, etc.) refuse to silently broadcast
|
|
// (0, 0). Hydrate from DB first so the panel always sees real balances.
|
|
if (gParagonCurrencyCache.find(player->GetGUID().GetCounter()) == gParagonCurrencyCache.end())
|
|
LoadCurrencyFromDb(player);
|
|
|
|
SendAddonMessage(player, fmt::format("R CURRENCY {} {}", GetAE(player), GetTE(player)));
|
|
}
|
|
|
|
bool TrySpendAE(Player* player, uint32 amount)
|
|
{
|
|
if (!amount)
|
|
return true;
|
|
auto itr = gParagonCurrencyCache.find(player->GetGUID().GetCounter());
|
|
if (itr == gParagonCurrencyCache.end())
|
|
return false;
|
|
if (itr->second.abilityEssence < amount)
|
|
return false;
|
|
itr->second.abilityEssence -= amount;
|
|
return true;
|
|
}
|
|
|
|
bool TrySpendTE(Player* player, uint32 amount)
|
|
{
|
|
if (!amount)
|
|
return true;
|
|
auto itr = gParagonCurrencyCache.find(player->GetGUID().GetCounter());
|
|
if (itr == gParagonCurrencyCache.end())
|
|
return false;
|
|
if (itr->second.talentEssence < amount)
|
|
return false;
|
|
itr->second.talentEssence -= amount;
|
|
return true;
|
|
}
|
|
|
|
void GrantLevelUpEssence(Player* player, uint8 oldLevel, uint8 newLevel)
|
|
{
|
|
if (!player || player->getClass() != CLASS_PARAGON)
|
|
return;
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
return;
|
|
|
|
uint32 const minLv = sConfigMgr->GetOption<uint32>("Paragon.Currency.GrantLevelMin", 10);
|
|
uint32 const aePer = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.PerLevel", 1);
|
|
uint32 const tePer = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.PerLevel", 1);
|
|
|
|
ParagonCurrencyData& d = GetOrCreateCacheEntry(player->GetGUID().GetCounter());
|
|
|
|
for (uint32 lvl = uint32(oldLevel) + 1; lvl <= uint32(newLevel); ++lvl)
|
|
{
|
|
if (lvl >= minLv)
|
|
{
|
|
d.abilityEssence += aePer;
|
|
d.talentEssence += tePer;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32 LookupSpellAECost(uint32 spellId)
|
|
{
|
|
uint32 const fallback = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.DefaultSpellCost", 2);
|
|
QueryResult r = WorldDatabase.Query("SELECT ae_cost FROM paragon_spell_ae_cost WHERE spell_id = {}", spellId);
|
|
if (!r)
|
|
return fallback;
|
|
return std::max<uint32>(r->Fetch()[0].Get<uint32>(), 1u);
|
|
}
|
|
|
|
// Matches client bake `lvl` (Spell.dbc SpellLevel; see _gen_paragon_advancement_spells_lua.py).
|
|
uint32 GetParagonPanelSpellRequiredLevel(SpellInfo const* info)
|
|
{
|
|
if (!info)
|
|
return 1u;
|
|
uint32 lv = info->SpellLevel;
|
|
if (!lv)
|
|
lv = info->BaseLevel;
|
|
return std::max(1u, lv);
|
|
}
|
|
|
|
// Reconciles the player's AE/TE cache against what they SHOULD have
|
|
// based on level (ComputeStartingAE/TE) minus what they've spent through
|
|
// Character Advancement (sum over character_paragon_panel_spells +
|
|
// character_paragon_panel_talents). Updates the cache + DB if either
|
|
// direction drifts:
|
|
// * actual < expected: top up (handles per-level grants automatically;
|
|
// also self-heals from admin commands / crashes that lost essence).
|
|
// * actual > expected: clamp down (prevents .modify-style cheese, ghost
|
|
// panel rows that were rolled back, or any path that left more
|
|
// essence than the level allowed).
|
|
// Logs at INFO when drift is corrected so we can spot abuse patterns.
|
|
//
|
|
// Cheap (two SELECTs of small per-character tables) and safe to call from
|
|
// OnPlayerLogin and OnPlayerLevelChanged. SAFE TO CALL ANY TIME the panel
|
|
// DB is in a steady state (i.e. NOT mid-HandleCommit).
|
|
void ReconcileEssenceForPlayer(Player* pl)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
return;
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
return;
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
uint8 const level = pl->GetLevel();
|
|
|
|
// Sum AE / TE spent through panel purchases. Mirrors the cost lookups
|
|
// used by HandleCommit so reconciliation matches the spend math byte-
|
|
// for-byte (no off-by-one if config keys are tweaked at runtime).
|
|
uint32 spentAE = 0;
|
|
uint32 spentTE = 0;
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT spell_id FROM character_paragon_panel_spells WHERE guid = {}", lowGuid))
|
|
{
|
|
do
|
|
{
|
|
spentAE += LookupSpellAECost(r->Fetch()[0].Get<uint32>());
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
uint32 const tePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
uint32 const aePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.TalentLearnCost", 1);
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT talent_id, `rank` FROM character_paragon_panel_talents WHERE guid = {}", lowGuid))
|
|
{
|
|
do
|
|
{
|
|
Field const* f = r->Fetch();
|
|
uint32 const tid = f[0].Get<uint32>();
|
|
uint32 const rank = f[1].Get<uint32>();
|
|
TalentEntry const* te = sTalentStore.LookupEntry(tid);
|
|
if (!te || !rank)
|
|
continue;
|
|
spentTE += rank * tePerRank;
|
|
if (te->addToSpellBook)
|
|
spentAE += rank * aePerRank;
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
uint32 const expectedTotalAE = ComputeStartingAE(level);
|
|
uint32 const expectedTotalTE = ComputeStartingTE(level);
|
|
uint32 const expectedBalAE = expectedTotalAE > spentAE ? expectedTotalAE - spentAE : 0;
|
|
uint32 const expectedBalTE = expectedTotalTE > spentTE ? expectedTotalTE - spentTE : 0;
|
|
|
|
ParagonCurrencyData& d = GetOrCreateCacheEntry(lowGuid);
|
|
if (d.abilityEssence == expectedBalAE && d.talentEssence == expectedBalTE)
|
|
return;
|
|
|
|
LOG_INFO("module",
|
|
"Paragon essence reconciled for {} (lvl {}): AE {}->{} TE {}->{} (spent AE={} TE={}, expected total AE={} TE={})",
|
|
pl->GetName(), uint32(level),
|
|
d.abilityEssence, expectedBalAE,
|
|
d.talentEssence, expectedBalTE,
|
|
spentAE, spentTE,
|
|
expectedTotalAE, expectedTotalTE);
|
|
|
|
d.abilityEssence = expectedBalAE;
|
|
d.talentEssence = expectedBalTE;
|
|
SaveCurrencyToDb(pl);
|
|
}
|
|
|
|
// Forward declaration: reset handlers below need PushSnapshot, which itself
|
|
// is defined later (after PushSpellSnapshot / PushTalentSnapshot).
|
|
void PushSnapshot(Player* pl);
|
|
|
|
// Forward declarations: reset handlers below clear the active build pointer
|
|
// and re-push the build catalog so the cell border drops client-side. Both
|
|
// helpers live with the rest of the build catalog code further down.
|
|
void SetActiveBuildId(uint32 lowGuid, uint32 buildId);
|
|
void PushBuildCatalog(Player* pl);
|
|
bool BuildBelongsToPlayer(uint32 lowGuid, uint32 buildId);
|
|
void SnapshotBuildFromCurrent(Player* pl, uint32 buildId);
|
|
|
|
// Forward declaration: the login-time scoped sweep (defined a few helpers
|
|
// down) calls into the chain-walker (defined further down).
|
|
void CollectSpellChainIds(uint32 baseSpellId, std::unordered_set<uint32>& out);
|
|
|
|
// ---- Panel-learn tracking (Overview + resets) ------------------------------
|
|
//
|
|
// Spells / talent ranks bought through Character Advancement are stored in
|
|
// character_paragon_panel_spells and character_paragon_panel_talents. The
|
|
// addon snapshot lists ONLY these rows (intersected with the live player),
|
|
// so racial spells, trainer defaults, etc. never appear in Overview.
|
|
|
|
void DbInsertPanelSpell(uint32 lowGuid, uint32 spellId)
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT IGNORE INTO character_paragon_panel_spells (guid, spell_id) VALUES ({}, {})",
|
|
lowGuid, spellId);
|
|
}
|
|
|
|
void DbInsertPanelSpellChild(uint32 lowGuid, uint32 parentSpellId, uint32 childSpellId)
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT IGNORE INTO character_paragon_panel_spell_children "
|
|
"(guid, parent_spell_id, child_spell_id) VALUES ({}, {}, {})",
|
|
lowGuid, parentSpellId, childSpellId);
|
|
}
|
|
|
|
// Persist an "active dependent we revoked" so we can re-revoke it after
|
|
// AC's skill cascade re-grants it on the next login. See
|
|
// `RevokeBlockedSpellsForPlayer` for the redo step.
|
|
void DbInsertPanelSpellRevoked(uint32 lowGuid, uint32 parentSpellId, uint32 revokedSpellId)
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT IGNORE INTO character_paragon_panel_spell_revoked "
|
|
"(guid, parent_spell_id, revoked_spell_id) VALUES ({}, {}, {})",
|
|
lowGuid, parentSpellId, revokedSpellId);
|
|
}
|
|
|
|
// Drop any panel_spell_revoked rows whose `revoked_spell_id` falls inside
|
|
// `chainIds`. Called from `PanelLearnSpellChain` right after the panel
|
|
// purchase row is committed so a freshly bought spell can't be unlearned
|
|
// on the next login by a stale (pre-purchase) revoke entry. Without this,
|
|
// the very first login after the purchase would walk the revoke table,
|
|
// hit the ghost row, `removeSpell` the freshly-paid-for ability, and
|
|
// then `PushSpellSnapshot` (which deletes panel_spells rows whose spell
|
|
// the player no longer has) would erase the purchase from the panel
|
|
// record entirely -- losing both the spell and the AE refund hook.
|
|
void DbDeletePanelSpellRevokedForChain(uint32 lowGuid,
|
|
std::unordered_set<uint32> const& chainIds)
|
|
{
|
|
if (chainIds.empty())
|
|
return;
|
|
|
|
std::string in;
|
|
in.reserve(chainIds.size() * 8);
|
|
bool first = true;
|
|
for (uint32 sid : chainIds)
|
|
{
|
|
if (!first)
|
|
in += ",";
|
|
in += std::to_string(sid);
|
|
first = false;
|
|
}
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_spell_revoked "
|
|
"WHERE guid = {} AND revoked_spell_id IN ({})",
|
|
lowGuid, in);
|
|
}
|
|
|
|
// Build the allowlist of spell IDs the player legitimately owns through
|
|
// Character Advancement: every chain rank of every spell in panel_spells,
|
|
// every rank-spell-id up to the purchased rank of every talent in
|
|
// panel_talents, and every recorded panel_spell_children id. Both
|
|
// `RevokeUnwantedCascadeSpellsForPlayer` and `RevokeBlockedSpellsForPlayer`
|
|
// need exactly this set; without the talent contribution, buying a spell
|
|
// after a talent (e.g., DK Death Coil after Scourge Strike) caused the
|
|
// post-commit sweep to revoke the talent-granted spell because it didn't
|
|
// appear in panel_spells. See ParagonAdvancement_TalentData.lua: many
|
|
// "abilities" the player perceives as spells (Scourge Strike id=2216,
|
|
// Bladestorm, Starfall, ...) are panel TALENTS that grant a spell rank
|
|
// via Player::LearnTalent.
|
|
void BuildPanelOwnedSpellsAllowlist(uint32 lowGuid, std::unordered_set<uint32>& allowed)
|
|
{
|
|
if (!lowGuid)
|
|
return;
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT spell_id FROM character_paragon_panel_spells WHERE guid = {}",
|
|
lowGuid))
|
|
{
|
|
do
|
|
{
|
|
CollectSpellChainIds(r->Fetch()[0].Get<uint32>(), allowed);
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT talent_id, `rank` FROM character_paragon_panel_talents WHERE guid = {}",
|
|
lowGuid))
|
|
{
|
|
do
|
|
{
|
|
Field const* f = r->Fetch();
|
|
uint32 const tid = f[0].Get<uint32>();
|
|
uint32 const rank = f[1].Get<uint32>();
|
|
TalentEntry const* te = sTalentStore.LookupEntry(tid);
|
|
if (!te || !rank)
|
|
continue;
|
|
// panel_talents.rank is 1-based ("1 means rank-1 owned"). Allow
|
|
// every rank id from 0..rank-1 so a partial-rank purchase still
|
|
// protects all lower ranks the player rolled through.
|
|
uint32 const cap = std::min<uint32>(rank, MAX_TALENT_RANK);
|
|
for (uint32 i = 0; i < cap; ++i)
|
|
{
|
|
uint32 const rankSpell = te->RankID[i];
|
|
if (!rankSpell)
|
|
continue;
|
|
allowed.insert(rankSpell);
|
|
|
|
// Some talents (Mangle, Feral Charge, Mutilate, ...) own a
|
|
// *passive* RankID spell whose effects then LEARN_SPELL the
|
|
// actual active abilities the player gets to use. RankID
|
|
// alone isn't enough -- the granted spells live on the
|
|
// class skill line, so the login cascade sweep would see
|
|
// them as "not allowlisted" and revoke them, and from the
|
|
// user's POV the ability vanishes on relog.
|
|
//
|
|
// Walk every effect of this rank's spell, expand each
|
|
// SPELL_EFFECT_LEARN_SPELL trigger through CollectSpellChainIds
|
|
// so the whole rank chain of the granted spell stays
|
|
// protected too (e.g. Mangle Bear rank 1 33878 ->
|
|
// 33986 -> ... -> 48566; we want all of them on the
|
|
// allowlist so a high-level Paragon druid keeps the rank
|
|
// appropriate to their level).
|
|
SpellInfo const* rankInfo = sSpellMgr->GetSpellInfo(rankSpell);
|
|
if (!rankInfo)
|
|
continue;
|
|
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;
|
|
CollectSpellChainIds(grantId, allowed);
|
|
}
|
|
}
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT child_spell_id FROM character_paragon_panel_spell_children WHERE guid = {}",
|
|
lowGuid))
|
|
{
|
|
do
|
|
{
|
|
allowed.insert(r->Fetch()[0].Get<uint32>());
|
|
} while (r->NextRow());
|
|
}
|
|
}
|
|
|
|
// Walk every (guid, *, revoked_spell_id) row and `removeSpell` it if the
|
|
// player still has it. Call sites:
|
|
// * `OnPlayerLogin` -- because `_LoadSkills` -> `learnSkillRewardedSpells`
|
|
// ran during LoadFromDB and may have re-granted Blood Presence /
|
|
// Death Coil / Death Grip / etc. before any of our hooks fired.
|
|
// * `HandleParagonResetAbilities` is NOT a caller; reset clears the
|
|
// table outright so the revoke list starts fresh on next purchase.
|
|
//
|
|
// Allowlist-aware: a revoked row whose `revoked_spell_id` is now part of
|
|
// a panel_spells chain (or recorded as a passive child) is *stale* -- it
|
|
// was inserted before the player legitimately purchased that spell, so
|
|
// re-running `removeSpell` on it would zap a paid-for ability. Such rows
|
|
// are skipped and dropped from the table so they can't fire again. This
|
|
// is the self-heal path for the pre-fix bug where buying a spell that
|
|
// had previously been caught by the login sweep left the (0, sid) ghost
|
|
// row in place; on every subsequent login that ghost would unlearn the
|
|
// freshly bought spell, and `PushSpellSnapshot`'s !HasSpell branch would
|
|
// then delete the panel_spells row, vanishing the purchase entirely.
|
|
void RevokeBlockedSpellsForPlayer(Player* pl)
|
|
{
|
|
if (!pl)
|
|
return;
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
|
|
// Allowlist: chain ranks of panel_spells + rank IDs of panel_talents
|
|
// + panel_spell_children. Talents matter here because many Wrath
|
|
// "abilities" (Scourge Strike, Bladestorm, ...) are talent-granted.
|
|
std::unordered_set<uint32> allowed;
|
|
BuildPanelOwnedSpellsAllowlist(lowGuid, allowed);
|
|
|
|
QueryResult r = CharacterDatabase.Query(
|
|
"SELECT parent_spell_id, revoked_spell_id FROM character_paragon_panel_spell_revoked WHERE guid = {}",
|
|
lowGuid);
|
|
if (!r)
|
|
return;
|
|
|
|
// Cache panel_spells for this guid so we can reattach migrating passive
|
|
// rows to a still-owned parent (per "passives stick" policy below).
|
|
std::unordered_set<uint32> ownedPanelSpells;
|
|
if (QueryResult ps = CharacterDatabase.Query(
|
|
"SELECT spell_id FROM character_paragon_panel_spells WHERE guid = {}", lowGuid))
|
|
{
|
|
do { ownedPanelSpells.insert(ps->Fetch()[0].Get<uint32>()); } while (ps->NextRow());
|
|
}
|
|
|
|
uint32 removed = 0;
|
|
uint32 migrated = 0;
|
|
std::vector<uint32> stale; // allowlisted -> drop the row
|
|
std::vector<uint32> passiveStaleAll; // passive revokes -> drop unconditionally
|
|
std::vector<std::pair<uint32, uint32>> passiveMigrate; // (parent, child) -> insert as child
|
|
do
|
|
{
|
|
Field const* f = r->Fetch();
|
|
uint32 const parent = f[0].Get<uint32>();
|
|
uint32 const sid = f[1].Get<uint32>();
|
|
|
|
// Legacy migration: previous builds revoked passive cascade
|
|
// rewards (Forceful Deflection, Runic Focus, ...). New policy is
|
|
// that all cascade-granted passives stick. Drop those rows
|
|
// and, where we have a still-owned parent, reattach the passive
|
|
// as a panel_spell_child so future reset/unlearn drops it
|
|
// alongside the parent.
|
|
SpellInfo const* info = sSpellMgr->GetSpellInfo(sid);
|
|
if (info && info->IsPassive())
|
|
{
|
|
if (parent && ownedPanelSpells.count(parent))
|
|
passiveMigrate.emplace_back(parent, sid);
|
|
passiveStaleAll.push_back(sid);
|
|
++migrated;
|
|
continue;
|
|
}
|
|
|
|
// Same migration for meta-skill cascade spells. Earlier builds
|
|
// (and this one until just now) revoked the rune-enchant spells
|
|
// (Razorice, Cinderglacier, Rune of the Fallen Crusader, ...)
|
|
// when a Paragon learned Runeforging via the panel, because
|
|
// they're active spells and the default classifier treats
|
|
// unknown active cascades as leaks. New policy: anything on
|
|
// SKILL_RUNEFORGING is part of the Runeforging meta-skill
|
|
// package and stays. Drop the revoked row and, if we have a
|
|
// still-owned parent (typically Runeforging itself, 53428),
|
|
// re-record as a child so refund/unlearn still cleans them up.
|
|
bool isMetaSkillRevoke = false;
|
|
{
|
|
auto bounds = sSpellMgr->GetSkillLineAbilityMapBounds(sid);
|
|
for (auto it = bounds.first; it != bounds.second; ++it)
|
|
{
|
|
if (it->second->SkillLine == SKILL_RUNEFORGING)
|
|
{
|
|
isMetaSkillRevoke = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (isMetaSkillRevoke)
|
|
{
|
|
if (parent && ownedPanelSpells.count(parent))
|
|
passiveMigrate.emplace_back(parent, sid);
|
|
passiveStaleAll.push_back(sid);
|
|
++migrated;
|
|
continue;
|
|
}
|
|
|
|
if (allowed.count(sid))
|
|
{
|
|
stale.push_back(sid);
|
|
continue;
|
|
}
|
|
if (pl->HasSpell(sid))
|
|
{
|
|
pl->removeSpell(sid, SPEC_MASK_ALL, false);
|
|
++removed;
|
|
}
|
|
} while (r->NextRow());
|
|
|
|
for (auto const& kv : passiveMigrate)
|
|
DbInsertPanelSpellChild(lowGuid, kv.first, kv.second);
|
|
|
|
if (!passiveStaleAll.empty())
|
|
{
|
|
std::sort(passiveStaleAll.begin(), passiveStaleAll.end());
|
|
passiveStaleAll.erase(std::unique(passiveStaleAll.begin(), passiveStaleAll.end()), passiveStaleAll.end());
|
|
|
|
std::string in;
|
|
in.reserve(passiveStaleAll.size() * 8);
|
|
bool first = true;
|
|
for (uint32 sid : passiveStaleAll)
|
|
{
|
|
if (!first) in += ",";
|
|
in += std::to_string(sid);
|
|
first = false;
|
|
}
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_spell_revoked "
|
|
"WHERE guid = {} AND revoked_spell_id IN ({})",
|
|
lowGuid, in);
|
|
}
|
|
|
|
if (!stale.empty())
|
|
{
|
|
// Build IN-list. `stale` is bounded by the player's revoked rows.
|
|
std::sort(stale.begin(), stale.end());
|
|
stale.erase(std::unique(stale.begin(), stale.end()), stale.end());
|
|
|
|
std::string in;
|
|
in.reserve(stale.size() * 8);
|
|
bool first = true;
|
|
for (uint32 sid : stale)
|
|
{
|
|
if (!first)
|
|
in += ",";
|
|
in += std::to_string(sid);
|
|
first = false;
|
|
}
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_spell_revoked "
|
|
"WHERE guid = {} AND revoked_spell_id IN ({})",
|
|
lowGuid, in);
|
|
|
|
LOG_INFO("module",
|
|
"Paragon panel: dropped {} stale revoke rows for {} "
|
|
"(spell now owned via panel purchase)",
|
|
stale.size(), pl->GetName());
|
|
}
|
|
|
|
if (removed)
|
|
LOG_INFO("module",
|
|
"Paragon panel: re-revoked {} skill-cascade dependents for {} on login",
|
|
removed, pl->GetName());
|
|
|
|
if (migrated)
|
|
LOG_INFO("module",
|
|
"Paragon panel: migrated {} passive revokes to children for {} (legacy)",
|
|
migrated, pl->GetName());
|
|
}
|
|
|
|
[[nodiscard]] static bool SkillLineAbilityIsSkillCascadeSigned(SkillLineAbilityEntry const* sla)
|
|
{
|
|
return sla && (sla->AcquireMethod == SKILL_LINE_ABILITY_LEARNED_ON_SKILL_LEARN
|
|
|| sla->AcquireMethod == SKILL_LINE_ABILITY_LEARNED_ON_SKILL_VALUE);
|
|
}
|
|
|
|
// SkillLine ids from every SkillLineAbility row that lists `spellId`
|
|
// (any AcquireMethod). Used as the *anchor* side of cascade detection.
|
|
//
|
|
// Important: the old helper only kept rows with AcquireMethod
|
|
// LEARNED_ON_SKILL_* . Spells like Blood Strike are usually tied to
|
|
// their skill line via a trainer/default row (AcquireMethod 0). That
|
|
// meant the anchor set was empty, so `IsSpellSkillLineCascadeDependent`
|
|
// never matched Forceful Deflection / Blood Presence — those were stored
|
|
// as innocent "children" and never revoked.
|
|
//
|
|
// Dependent detection still requires the *dependent* spell to have a
|
|
// LEARNED_ON_SKILL_* row on one of these lines (same as
|
|
// `learnSkillRewardedSpells`).
|
|
[[nodiscard]] static std::unordered_set<uint32> SkillLinesLinkedToSpell(uint32 spellId)
|
|
{
|
|
std::unordered_set<uint32> out;
|
|
SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(spellId);
|
|
for (auto it = bounds.first; it != bounds.second; ++it)
|
|
{
|
|
SkillLineAbilityEntry const* sla = it->second;
|
|
if (!sla)
|
|
continue;
|
|
out.insert(sla->SkillLine);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Forward: defined after `CollectSpellChainIds` (needs the chain walker).
|
|
[[nodiscard]] static bool IsDepGrantedByLearnSpellOnAnyChainRank(uint32 anchorChainHead, uint32 depSpellId);
|
|
|
|
// Plague Strike / Icy Touch teach their disease passives through the same
|
|
// DK weapon skill-line machinery as true cascade rewards (Forceful
|
|
// Deflection, …) — there is often no SPELL_EFFECT_LEARN_SPELL row on the
|
|
// strike itself (the debuff spell is reached via TRIGGER_SPELL at cast
|
|
// time). Without an explicit carve-out, `IsSpellSkillLineCascadeDependent`
|
|
// returns true and we revoke Blood Plague / Frost Fever right after the
|
|
// learnSpell diff inserts them.
|
|
[[nodiscard]] static bool IsParagonStrikeTiedDiseasePassive(uint32 anchorChainHead, uint32 depSpellId)
|
|
{
|
|
uint32 const dHead = sSpellMgr->GetFirstSpellInChain(depSpellId);
|
|
uint32 const depH = dHead ? dHead : depSpellId;
|
|
// On-target debuff spellbook rows (wrong for our panel attach, but still
|
|
// strike-tied) plus the correct passive spellbook entries (59879 / 59921).
|
|
// Without the latter, `PruneSkillLineCascadeChildrenFromDb` classifies
|
|
// (45462,59879) as a skill-line cascade child and strips the forced attach
|
|
// immediately after `PanelLearnSpellChain` returns.
|
|
if (anchorChainHead == 45462 && (depH == 55078 || depH == 59879)) // Plague Strike -> Blood Plague
|
|
return true;
|
|
if (anchorChainHead == 45477 && (depH == 55095 || depH == 59921)) // Icy Touch -> Frost Fever
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// True when `depSpellId` is granted as a skill-line reward on one of the
|
|
// same SkillLines as `anchorSpellId` (e.g. Blood Strike -> Forceful
|
|
// Deflection / Blood Presence). Passives learned only via spell effects
|
|
// (disease auras, etc.) typically return false here.
|
|
//
|
|
// IMPORTANT: some passives (Blood Plague from Plague Strike) sit on the
|
|
// same SkillLine as the anchor AND carry LEARNED_ON_SKILL_* rows, so the
|
|
// naive skill-line intersection would classify them as "cascade" and
|
|
// revoke them. Those spells are still legitimate spell-effect grants when
|
|
// Plague Strike's SPELL_EFFECT_LEARN_SPELL points at them — we exclude
|
|
// that case first via `IsDepGrantedByLearnSpellOnAnyChainRank`.
|
|
[[nodiscard]] static bool IsSpellSkillLineCascadeDependent(uint32 anchorSpellId, uint32 depSpellId)
|
|
{
|
|
uint32 const anchorHead = sSpellMgr->GetFirstSpellInChain(anchorSpellId);
|
|
uint32 const head = anchorHead ? anchorHead : anchorSpellId;
|
|
if (IsDepGrantedByLearnSpellOnAnyChainRank(head, depSpellId))
|
|
return false;
|
|
if (IsParagonStrikeTiedDiseasePassive(head, depSpellId))
|
|
return false;
|
|
|
|
std::unordered_set<uint32> const anchorLines = SkillLinesLinkedToSpell(anchorSpellId);
|
|
if (anchorLines.empty())
|
|
return false;
|
|
|
|
SkillLineAbilityMapBounds db = sSpellMgr->GetSkillLineAbilityMapBounds(depSpellId);
|
|
for (auto it = db.first; it != db.second; ++it)
|
|
{
|
|
SkillLineAbilityEntry const* sla = it->second;
|
|
if (!SkillLineAbilityIsSkillCascadeSigned(sla))
|
|
continue;
|
|
if (anchorLines.count(sla->SkillLine))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Allowlist for ACTIVE spells we explicitly want kept as
|
|
// panel_spell_children, even though the general policy is "actives in
|
|
// children = legacy garbage, drop them" (see
|
|
// PruneSkillLineCascadeChildrenFromDb).
|
|
//
|
|
// The original kAttached set was 100% passives (Frost Fever, Blood
|
|
// Plague, Forceful Deflection, Runic Focus). For those, "passive ==
|
|
// keep" was a perfect proxy. Runeforging changed that: the 8 basic
|
|
// rune-enchant spells (53344, 53343, 53341, 53331, 53342, 53323,
|
|
// 54447, 54446) are ACTIVE casts that we DO want to attach to the
|
|
// Runeforging panel purchase so:
|
|
// * The Lua-substitute Runeforge UI can cast them (HasActiveSpell).
|
|
// * Refunding Runeforging cleans them up via the standard
|
|
// panel_spell_children unlearn path.
|
|
//
|
|
// Without this allowlist, PruneSkillLineCascadeChildrenFromDb runs
|
|
// immediately after PanelLearnSpellChain attaches them, sees them as
|
|
// non-passive, drops them, and inserts panel_spell_revoked rows --
|
|
// stranding the player with no usable runeforging menu.
|
|
//
|
|
// Every entry here MUST also appear in PanelLearnSpellChain::kAttached
|
|
// AND in OnPlayerLogin's kFixup list (or a shared source if those ever
|
|
// get factored out). The pair ordering is (parentHead, attachedSpell),
|
|
// matching kAttached / kFixup.
|
|
struct IntentionalActiveAttached { uint32 parent; uint32 child; };
|
|
static IntentionalActiveAttached const kIntentionalActiveAttached[] = {
|
|
{ 53428, 53344 }, // Runeforging -> Rune of the Fallen Crusader
|
|
{ 53428, 53343 }, // Runeforging -> Rune of Razorice
|
|
{ 53428, 53341 }, // Runeforging -> Rune of Cinderglacier
|
|
{ 53428, 53331 }, // Runeforging -> Rune of Lichbane
|
|
{ 53428, 53342 }, // Runeforging -> Rune of Spellshattering
|
|
{ 53428, 53323 }, // Runeforging -> Rune of Swordshattering
|
|
{ 53428, 54447 }, // Runeforging -> Rune of Spellbreaking
|
|
{ 53428, 54446 }, // Runeforging -> Rune of Swordbreaking
|
|
};
|
|
|
|
[[nodiscard]] static bool IsIntentionalActiveAttachedChild(uint32 parent, uint32 child)
|
|
{
|
|
for (auto const& e : kIntentionalActiveAttached)
|
|
if (e.parent == parent && e.child == child)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// Current policy: cascade-granted passives stick as panel_spell_children;
|
|
// only actives get revoked. This pass exists to scrub *legacy* rows that
|
|
// older logic inserted incorrectly — specifically, any active spell that
|
|
// ended up in panel_spell_children from a build that classified things
|
|
// differently. Passive children are always retained, as are entries
|
|
// whitelisted via kIntentionalActiveAttached (Runeforging rune-enchants
|
|
// are active casts that we deliberately attach as children).
|
|
static void PruneSkillLineCascadeChildrenFromDb(Player* pl, uint32 lowGuid)
|
|
{
|
|
if (!pl)
|
|
return;
|
|
|
|
QueryResult r = CharacterDatabase.Query(
|
|
"SELECT parent_spell_id, child_spell_id FROM character_paragon_panel_spell_children WHERE guid = {}",
|
|
lowGuid);
|
|
if (!r)
|
|
return;
|
|
|
|
do
|
|
{
|
|
uint32 const parent = r->Fetch()[0].Get<uint32>();
|
|
uint32 const child = r->Fetch()[1].Get<uint32>();
|
|
SpellInfo const* info = sSpellMgr->GetSpellInfo(child);
|
|
if (info && info->IsPassive())
|
|
continue; // passives always stay
|
|
if (IsIntentionalActiveAttachedChild(parent, child))
|
|
continue; // intentional active attachment
|
|
// Active in children -> legacy garbage. Drop the row, revoke the
|
|
// spell, and persist into panel_spell_revoked so the login sweep
|
|
// catches future cascade re-fires.
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_spell_children WHERE guid = {} AND parent_spell_id = {} AND child_spell_id = {}",
|
|
lowGuid, parent, child);
|
|
|
|
if (pl->HasSpell(child))
|
|
{
|
|
pl->removeSpell(child, SPEC_MASK_ALL, false);
|
|
DbInsertPanelSpellRevoked(lowGuid, parent, child);
|
|
}
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
// Login-time scoped sweep for cascade-granted dependents that the
|
|
// commit-time diff missed.
|
|
//
|
|
// Background: AC's `_addSpell` calls `LearnDefaultSkill(skill, 0)` once
|
|
// for any SkillLineAbility-linked spell when the player doesn't yet have
|
|
// the skill. `LearnDefaultSkill` -> `SetSkill` -> `learnSkillRewardedSpells`
|
|
// then grants every reward of that skill as PLAYERSPELL_TEMPORARY (which
|
|
// lives in m_spells but is NOT written to character_spell). On every
|
|
// subsequent login `_LoadSkills` re-fires the cascade for any skill row
|
|
// that exists in `character_skills`, silently re-granting Blood Presence
|
|
// / Forceful Deflection / Death Coil / etc. -- including for characters
|
|
// like Test whose first commit predates the per-purchase revoke list.
|
|
//
|
|
// Strategy: from the player's panel-purchased spells, derive the set of
|
|
// SkillLines we've activated (via SkillLineAbility's SkillLine field).
|
|
// Walk those SkillLines' rewards and revoke any spell (active or passive)
|
|
// currently in m_spells that isn't in our allowlist (panel chain ranks +
|
|
// non-cascade passive children). Persist each revoke into
|
|
// `character_paragon_panel_spell_revoked` so the cheaper
|
|
// `RevokeBlockedSpellsForPlayer` path handles it on every subsequent
|
|
// login.
|
|
//
|
|
// Why this is safe (unlike the earlier blanket-temporary sweep):
|
|
// * Only walks SkillLines that we caused to be activated. Racial
|
|
// skills, weapon skills, Defense, etc. live in different SkillLines
|
|
// and are never reached.
|
|
// * Passives that are pure spell-effect side effects stay in
|
|
// `character_paragon_panel_spell_children` and remain allowlisted.
|
|
// * Skill-line cascade passives (Forceful Deflection, ...) are not
|
|
// allowlisted children anymore; see `PruneSkillLineCascadeChildrenFromDb`
|
|
// + `PanelLearnSpellChain`.
|
|
void RevokeUnwantedCascadeSpellsForPlayer(Player* pl)
|
|
{
|
|
if (!pl)
|
|
return;
|
|
|
|
bool const diag = sConfigMgr->GetOption<bool>("Paragon.Diag.PanelLearn", false);
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
|
|
PruneSkillLineCascadeChildrenFromDb(pl, lowGuid);
|
|
|
|
// Allowlist: chain ranks of panel_spells + rank IDs of panel_talents
|
|
// + panel_spell_children. Talents matter here because many Wrath
|
|
// "abilities" (Scourge Strike, Bladestorm, ...) are talent-granted:
|
|
// a Death Coil purchase otherwise activates the DK skill line and
|
|
// sweeps Scourge Strike (55090) out from under the talent.
|
|
std::unordered_set<uint32> allowed;
|
|
BuildPanelOwnedSpellsAllowlist(lowGuid, allowed);
|
|
|
|
if (allowed.empty())
|
|
return;
|
|
|
|
// From the allowlist, derive which SkillLines we've activated. Use
|
|
// every SkillLineAbility row for each spell (not only LEARNED_ON_SKILL_*),
|
|
// matching `SkillLinesLinkedToSpell` / `_addSpell`'s LearnDefaultSkill path.
|
|
std::unordered_set<uint32> ourSkillLines;
|
|
for (uint32 spellId : allowed)
|
|
{
|
|
SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(spellId);
|
|
for (auto it = bounds.first; it != bounds.second; ++it)
|
|
{
|
|
SkillLineAbilityEntry const* sla = it->second;
|
|
if (!sla)
|
|
continue;
|
|
ourSkillLines.insert(sla->SkillLine);
|
|
}
|
|
}
|
|
|
|
if (ourSkillLines.empty())
|
|
return;
|
|
|
|
// For each activated SkillLine, walk its rewards and queue revokes for
|
|
// active spells that aren't allowlisted but are currently in m_spells.
|
|
// Passive cascade rewards (Forceful Deflection, Runic Focus, ...) are
|
|
// intentionally retained — the panel-purchase commit recorded them as
|
|
// panel_spell_children so reset/queue-unlearn will drop them with the
|
|
// parent, but the login sweep MUST NOT strip them from the spellbook.
|
|
std::vector<uint32> toRevoke;
|
|
for (uint32 skillLine : ourSkillLines)
|
|
{
|
|
for (SkillLineAbilityEntry const* ab : GetSkillLineAbilitiesBySkillLine(skillLine))
|
|
{
|
|
if (!ab)
|
|
continue;
|
|
|
|
uint32 const sid = ab->Spell;
|
|
if (!sid)
|
|
continue;
|
|
if (allowed.count(sid))
|
|
continue;
|
|
if (!pl->HasSpell(sid))
|
|
continue; // not in m_spells right now
|
|
|
|
SpellInfo const* info = sSpellMgr->GetSpellInfo(sid);
|
|
if (!info)
|
|
continue;
|
|
if (info->IsPassive())
|
|
continue; // policy: passives always stay
|
|
|
|
toRevoke.push_back(sid);
|
|
}
|
|
}
|
|
|
|
if (toRevoke.empty())
|
|
{
|
|
if (diag)
|
|
LOG_INFO("module",
|
|
"[paragon-diag] login sweep: no orphan cascade spells for {} "
|
|
"(skillLines scanned={}, allowlist={})",
|
|
pl->GetName(), ourSkillLines.size(), allowed.size());
|
|
return;
|
|
}
|
|
|
|
// Dedup (a spell can show up under multiple SkillLines).
|
|
std::sort(toRevoke.begin(), toRevoke.end());
|
|
toRevoke.erase(std::unique(toRevoke.begin(), toRevoke.end()), toRevoke.end());
|
|
|
|
for (uint32 sid : toRevoke)
|
|
{
|
|
pl->removeSpell(sid, SPEC_MASK_ALL, false);
|
|
// parent_spell_id = 0 -> "caught at login by scoped sweep, no
|
|
// specific parent". Distinct PK from the (guid, parent, sid)
|
|
// rows the commit-time diff inserts.
|
|
DbInsertPanelSpellRevoked(lowGuid, 0u, sid);
|
|
}
|
|
|
|
LOG_INFO("module",
|
|
"Paragon panel: scoped sweep revoked {} cascade spells for {} "
|
|
"(skillLines scanned={}, allowlist={})",
|
|
toRevoke.size(), pl->GetName(), ourSkillLines.size(), allowed.size());
|
|
}
|
|
|
|
// Blood Elf racial "Arcane Torrent" is three different spell IDs in WotLK
|
|
// (28730 mana, 25046 rogue energy, 50613 DK runic power), all on skill line
|
|
// 756. The blanket SkillLineAbility overlay opened all three to class 12;
|
|
// Paragon should keep only the mana version (matches primary power display).
|
|
void RevokeDuplicateBloodElfArcaneTorrent(Player* pl)
|
|
{
|
|
if (!pl || pl->getRace() != RACE_BLOODELF)
|
|
return;
|
|
|
|
constexpr uint32 SPELL_ARCANE_TORRENT_ROGUE = 25046;
|
|
constexpr uint32 SPELL_ARCANE_TORRENT_DK = 50613;
|
|
|
|
for (uint32 sid : { SPELL_ARCANE_TORRENT_ROGUE, SPELL_ARCANE_TORRENT_DK })
|
|
if (pl->HasSpell(sid))
|
|
pl->removeSpell(sid, SPEC_MASK_ALL, false);
|
|
}
|
|
|
|
// Snapshot of currently-known spell IDs (excluding entries marked removed).
|
|
// Used by PanelLearnSpellChain to detect spells that AzerothCore's
|
|
// addSpell machinery auto-learns alongside the spell we asked for.
|
|
std::unordered_set<uint32> SnapshotKnownSpells(Player* pl)
|
|
{
|
|
std::unordered_set<uint32> out;
|
|
if (!pl)
|
|
return out;
|
|
PlayerSpellMap const& spells = pl->GetSpellMap();
|
|
out.reserve(spells.size());
|
|
for (auto const& kv : spells)
|
|
{
|
|
PlayerSpell const* ps = kv.second;
|
|
if (ps && ps->State != PLAYERSPELL_REMOVED)
|
|
out.insert(kv.first);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// (suppression-via-placeholder helpers were removed: AzerothCore's auto-
|
|
// learn for class spells comes via `learnSkillRewardedSpells` -> `_addSpell`,
|
|
// not via `SPELL_EFFECT_LEARN_SPELL` effects on the parent. Pre-blocking
|
|
// by spell id list didn't intercept the right path. The chat-toast
|
|
// suppression now lives client-side in ParagonAdvancement_Net.lua;
|
|
// the server just tells the client which ids to silence.)
|
|
|
|
// Build the full chain id set for `baseSpellId` (every rank). Used both
|
|
// by PanelLearnSpellChain and by the silence-window opener so the client
|
|
// knows which "you have learned X" toasts to keep visible.
|
|
void CollectSpellChainIds(uint32 baseSpellId, std::unordered_set<uint32>& out)
|
|
{
|
|
if (!baseSpellId)
|
|
return;
|
|
uint32 const firstId = sSpellMgr->GetFirstSpellInChain(baseSpellId);
|
|
uint32 cur = firstId ? firstId : baseSpellId;
|
|
while (cur)
|
|
{
|
|
if (!out.insert(cur).second)
|
|
break;
|
|
uint32 const n = sSpellMgr->GetNextSpellInChain(cur);
|
|
if (!n || n == cur)
|
|
break;
|
|
cur = n;
|
|
}
|
|
}
|
|
|
|
// 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).
|
|
// Distinguishes Blood Plague (taught directly by Plague Strike ranks)
|
|
// from Forceful Deflection (skill-line reward only, no LEARN_SPELL on
|
|
// the Blood Strike ranks).
|
|
[[nodiscard]] static bool IsDepGrantedByLearnSpellOnAnyChainRank(uint32 anchorChainHead, uint32 depSpellId)
|
|
{
|
|
if (!anchorChainHead || !depSpellId)
|
|
return false;
|
|
|
|
std::unordered_set<uint32> anchorRanks;
|
|
CollectSpellChainIds(anchorChainHead, anchorRanks);
|
|
if (anchorRanks.empty())
|
|
anchorRanks.insert(anchorChainHead);
|
|
|
|
std::unordered_set<uint32> learnGrantIds;
|
|
for (uint32 rnk : anchorRanks)
|
|
{
|
|
SpellInfo const* si = sSpellMgr->GetSpellInfo(rnk);
|
|
if (!si)
|
|
continue;
|
|
for (uint8 e = 0; e < MAX_SPELL_EFFECTS; ++e)
|
|
{
|
|
if (si->Effects[e].Effect != SPELL_EFFECT_LEARN_SPELL)
|
|
continue;
|
|
uint32 const grant = si->Effects[e].TriggerSpell;
|
|
if (!grant)
|
|
continue;
|
|
CollectSpellChainIds(grant, learnGrantIds);
|
|
}
|
|
}
|
|
|
|
if (learnGrantIds.empty())
|
|
return false;
|
|
|
|
std::unordered_set<uint32> depRanks;
|
|
CollectSpellChainIds(depSpellId, depRanks);
|
|
if (depRanks.empty())
|
|
depRanks.insert(depSpellId);
|
|
|
|
for (uint32 d : depRanks)
|
|
if (learnGrantIds.count(d))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// Learn every rank of the spell chain that contains `baseSpellId` for which
|
|
// the player meets the SpellLevel requirement, then record ONLY the
|
|
// first-rank id in character_paragon_panel_spells.
|
|
//
|
|
// Recording only the chain head (one row per panel purchase) keeps reset
|
|
// accounting clean: refundAE is computed once per chain via
|
|
// LookupSpellAECost(firstRankId), and Player::removeSpell already cascades
|
|
// across higher ranks. If we recorded every learned rank we'd refund N x
|
|
// the cost for an N-rank chain and need to dedupe in reset.
|
|
//
|
|
// Side effect: AC's spell-learn machinery cascades through both the
|
|
// `SPELL_EFFECT_LEARN_SPELL` effects and the SkillLineAbility map (when
|
|
// the player gains a new skill via `LearnDefaultSkill` -> `SetSkill` ->
|
|
// `learnSkillRewardedSpells`), so learning a single class spell can
|
|
// auto-grant several side spells (e.g., Plague Strike pulls Death Coil,
|
|
// Death Grip, Blood Plague, Blood Presence, Forceful Deflection, Runic
|
|
// Focus). We diff the player's spell list before/after `learnSpell` to
|
|
// classify those side effects:
|
|
// * Passives that are pure spell-effect side effects (disease auras,
|
|
// etc.) are kept; we record them in character_paragon_panel_spell_children
|
|
// so reset unlearns them alongside the parent. SPELL_EFFECT_LEARN_SPELL
|
|
// grants are detected automatically; DK Plague Strike / Icy Touch disease
|
|
// passives (Blood Plague / Frost Fever) share the weapon skill line with
|
|
// their strikes and need an explicit carve-out — see
|
|
// `IsParagonStrikeTiedDiseasePassive` inside `IsSpellSkillLineCascadeDependent`.
|
|
// * Passives that are skill-line cascade rewards on the same SkillLine
|
|
// as the rank being learned (Forceful Deflection with Blood Strike)
|
|
// are revoked like actives — they are not panel children.
|
|
// * Active dependents (Death Coil, Death Grip, Blood Presence, ...) are
|
|
// revoked immediately via `removeSpell` so the player only ends up
|
|
// with what they actually purchased.
|
|
// The "you have learned X" / "you have unlearned X" chat toasts that
|
|
// fire during this dance are silenced client-side via a SILENCE
|
|
// addon-channel window opened around the whole commit (see
|
|
// HandleCommit + ParagonAdvancement_Net.lua).
|
|
void PanelLearnSpellChain(Player* pl, uint32 baseSpellId)
|
|
{
|
|
if (!pl || !baseSpellId)
|
|
return;
|
|
|
|
uint32 const playerLevel = pl->GetLevel();
|
|
uint32 const firstId = sSpellMgr->GetFirstSpellInChain(baseSpellId);
|
|
uint32 const trackId = firstId ? firstId : baseSpellId;
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
|
|
std::unordered_set<uint32> chainIds;
|
|
CollectSpellChainIds(trackId, chainIds);
|
|
|
|
bool const diag = sConfigMgr->GetOption<bool>("Paragon.Diag.PanelLearn", false);
|
|
if (diag)
|
|
{
|
|
LOG_INFO("module",
|
|
"[paragon-diag] PanelLearnSpellChain start: player={} lvl={} class={} baseSpellId={} trackId={} chainSize={}",
|
|
pl->GetName(), playerLevel, uint32(pl->getClass()), baseSpellId, trackId, chainIds.size());
|
|
}
|
|
|
|
uint32 cur = trackId;
|
|
while (cur)
|
|
{
|
|
SpellInfo const* info = sSpellMgr->GetSpellInfo(cur);
|
|
if (!info)
|
|
break;
|
|
|
|
// Spell.dbc ranks are ordered by required level ascending, so the
|
|
// first rank that exceeds the player's level terminates the walk.
|
|
uint32 const reqLv = GetParagonPanelSpellRequiredLevel(info);
|
|
if (playerLevel < reqLv)
|
|
break;
|
|
|
|
if (!pl->HasSpell(cur) && IsParagonSpellAllowedByRidingSkill(pl, cur))
|
|
{
|
|
std::unordered_set<uint32> before = SnapshotKnownSpells(pl);
|
|
if (diag)
|
|
LOG_INFO("module",
|
|
"[paragon-diag] pre-learn rank={} spellMapSize={}",
|
|
cur, before.size());
|
|
|
|
pl->learnSpell(cur, false);
|
|
std::unordered_set<uint32> after = SnapshotKnownSpells(pl);
|
|
|
|
if (diag)
|
|
LOG_INFO("module",
|
|
"[paragon-diag] post-learn rank={} spellMapSize={} delta={}",
|
|
cur, after.size(),
|
|
int32(after.size()) - int32(before.size()));
|
|
|
|
// Diff: classify each new spell that wasn't in the chain we
|
|
// asked for.
|
|
// * Passives (Forceful Deflection, Runic Focus, Blood Plague
|
|
// 59879, ...) ALWAYS stick. Recorded as panel_spell_children
|
|
// so reset/queue-unlearn drop them with the parent.
|
|
// * Actives (Blood Presence stance, Death Coil, Death Grip,
|
|
// ...) are revoked + persisted. AC's `_LoadSkills` re-fires
|
|
// `learnSkillRewardedSpells` on every login and would
|
|
// silently re-grant them otherwise.
|
|
for (uint32 spellId : after)
|
|
{
|
|
if (before.count(spellId))
|
|
continue; // already known
|
|
if (chainIds.count(spellId))
|
|
{
|
|
if (diag)
|
|
LOG_INFO("module",
|
|
"[paragon-diag] +{} (chain rank, kept)", spellId);
|
|
continue;
|
|
}
|
|
|
|
SpellInfo const* dep = sSpellMgr->GetSpellInfo(spellId);
|
|
if (!dep)
|
|
continue;
|
|
|
|
// Meta-skill cascade carve-out. Runeforging (776) is a
|
|
// CLASS-category skill that, once granted, is supposed to
|
|
// cascade ALL its rune-enchant spells (Rune of the Fallen
|
|
// Crusader, Razorice, Cinderglacier, Lichbane, Spell-/
|
|
// Sword-shattering, Spell-/Sword-breaking, Stoneskin
|
|
// Gargoyle, Nerubian Carapace) for the player to choose
|
|
// from at a runeforge anvil. Those rune-enchants are
|
|
// ACTIVE spells, so the default policy below would
|
|
// revoke them and the player would learn Runeforging
|
|
// for nothing. Treat the whole cluster the same way we
|
|
// treat passive deps: persist as children of the panel
|
|
// purchase so refund/unlearn drops them too, but do NOT
|
|
// revoke them.
|
|
//
|
|
// Detection: walk the dep's own SkillLineAbility entries
|
|
// and check for SKILL_RUNEFORGING. This auto-handles all
|
|
// 10 rune-enchant spells without an ID-by-ID allowlist.
|
|
bool isMetaSkillCascade = false;
|
|
{
|
|
auto bounds = sSpellMgr->GetSkillLineAbilityMapBounds(spellId);
|
|
for (auto it = bounds.first; it != bounds.second; ++it)
|
|
{
|
|
if (it->second->SkillLine == SKILL_RUNEFORGING)
|
|
{
|
|
isMetaSkillCascade = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dep->IsPassive() || isMetaSkillCascade)
|
|
{
|
|
DbInsertPanelSpellChild(lowGuid, trackId, spellId);
|
|
if (diag)
|
|
LOG_INFO("module",
|
|
"[paragon-diag] +{} ({} dep, kept as child of {})",
|
|
spellId,
|
|
isMetaSkillCascade ? "meta-skill" : "passive",
|
|
trackId);
|
|
}
|
|
else
|
|
{
|
|
pl->removeSpell(spellId, SPEC_MASK_ALL, false);
|
|
DbInsertPanelSpellRevoked(lowGuid, trackId, spellId);
|
|
if (diag)
|
|
LOG_INFO("module",
|
|
"[paragon-diag] +{} (active dep, REVOKED, parent={})",
|
|
spellId, trackId);
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32 const next = sSpellMgr->GetNextSpellInChain(cur);
|
|
if (!next || next == cur)
|
|
break;
|
|
cur = next;
|
|
}
|
|
|
|
DbInsertPanelSpell(lowGuid, trackId);
|
|
|
|
// ------------------------------------------------------------------
|
|
// Forced passive attachments. Some Wrath spells *should* come with a
|
|
// passive entry in the spellbook (so the player can read what the
|
|
// disease/aura does), but the engine only adds those passives via
|
|
// `learnSkillRewardedSpells`, which fires exactly ONCE per skill —
|
|
// the first time the player learns a spell on that skill line. If
|
|
// the player bought Blood Strike before Plague Strike, the cascade
|
|
// ran for Blood Strike, revoked the disease passives, and a later
|
|
// Plague Strike purchase finds the skill already known and never
|
|
// re-grants them.
|
|
//
|
|
// For each (chain head -> attached spell) pair below: if the player
|
|
// does not already have the attached spell, learnSpell it (silently
|
|
// -- the silence window is still open) and record it as a panel
|
|
// child of `trackId` so reset/queue-unlearn drop it alongside the
|
|
// parent. If the attached spell currently has a stale revoke row
|
|
// pointing at it (left over from the cascade run for a different
|
|
// parent), that row is dropped so the next login doesn't unlearn it.
|
|
// ------------------------------------------------------------------
|
|
{
|
|
// Static, intentionally tiny: every entry is a hand-curated
|
|
// spell-effect attachment that the spellbook UX expects to
|
|
// travel with the parent. Add new entries sparingly.
|
|
// IMPORTANT: 55078 / 55095 are the on-target *debuff* spell IDs for
|
|
// Blood Plague / Frost Fever (cast on enemies by Plague Strike /
|
|
// Icy Touch via SPELL_EFFECT_TRIGGER_SPELL). They are NOT marked
|
|
// passive in Spell.dbc, so the client renders them as castable
|
|
// spellbook icons. The correct *passive* spellbook entries the
|
|
// player is supposed to see are 59879 / 59921 (the descriptive
|
|
// "Passive disease" rows; SPELL_ATTR0_PASSIVE bit set).
|
|
// After the Paragon class-skill cascade guard landed in
|
|
// Player::learnSkillRewardedSpells, NONE of the DK skill-line
|
|
// cascade rewards are auto-granted any more — so passives that
|
|
// used to ride along on a class skill cascade (Forceful
|
|
// Deflection on Blood Strike, Runic Focus on Icy Touch) must be
|
|
// explicitly attached here, the same way Blood Plague / Frost
|
|
// Fever are. Add new entries when a panel-purchased active is
|
|
// expected to come with a passive spellbook entry that no
|
|
// SPELL_EFFECT_LEARN_SPELL on the parent provides.
|
|
struct AttachedPassive { uint32 parentHead; uint32 attachedSpell; };
|
|
static AttachedPassive const kAttached[] = {
|
|
{ 45462, 59879 }, // Plague Strike -> Blood Plague (passive entry)
|
|
{ 45477, 59921 }, // Icy Touch -> Frost Fever (passive entry)
|
|
{ 45477, 61455 }, // Icy Touch -> Runic Focus (parry from spell power)
|
|
{ 45902, 49410 }, // Blood Strike -> Forceful Deflection (parry from strength)
|
|
|
|
// Runeforging -> 8 basic rune-enchants. The
|
|
// SkillLineAbility rows for these (skill 776) all ship
|
|
// with AcquireMethod = 0 in the DBC (i.e. NOT auto-learn-
|
|
// on-skill-grant). For stock DKs the engine's hardcoded
|
|
// runeforging UI hand-rolls the cast for whichever rune
|
|
// the player picks, but for our Lua-substitute UI the
|
|
// server's HandleCastSpellOpcode / HasActiveSpell gate
|
|
// rejects the cast unless the spell is in the spellbook.
|
|
// Force-attach them as panel children so:
|
|
// 1. The player actually owns the spells (cast works).
|
|
// 2. Refunding Runeforging cleans them up via the
|
|
// standard panel_spell_children unlearn path.
|
|
// The two ADVANCED runes (Stoneskin Gargoyle 62158 and
|
|
// Nerubian Carapace 70164) are intentionally NOT listed:
|
|
// retail gates them behind item drops from heroic
|
|
// dungeons / Naxx / ICC, and our SkillLineAbility rows
|
|
// for them already use AcquireMethod=0 so the player
|
|
// gets them when they pick up the appropriate item, not
|
|
// for free with Runeforging itself.
|
|
{ 53428, 53344 }, // Runeforging -> Rune of the Fallen Crusader
|
|
{ 53428, 53343 }, // Runeforging -> Rune of Razorice
|
|
{ 53428, 53341 }, // Runeforging -> Rune of Cinderglacier
|
|
{ 53428, 53331 }, // Runeforging -> Rune of Lichbane
|
|
{ 53428, 53342 }, // Runeforging -> Rune of Spellshattering
|
|
{ 53428, 53323 }, // Runeforging -> Rune of Swordshattering
|
|
{ 53428, 54447 }, // Runeforging -> Rune of Spellbreaking
|
|
{ 53428, 54446 }, // Runeforging -> Rune of Swordbreaking
|
|
};
|
|
|
|
// Self-heal: a previous build of mod-paragon (briefly shipped)
|
|
// attached the on-target debuff IDs (55078 / 55095) instead of
|
|
// the passive spellbook IDs (59879 / 59921). Drop any such row
|
|
// and unlearn the spell so the player isn't left with a phantom
|
|
// "castable" Blood Plague / Frost Fever icon in their spellbook.
|
|
struct LegacyAttached { uint32 parentHead; uint32 wrongSpell; };
|
|
static LegacyAttached const kLegacyWrong[] = {
|
|
{ 45462, 55078 },
|
|
{ 45477, 55095 },
|
|
};
|
|
for (auto const& lw : kLegacyWrong)
|
|
{
|
|
if (lw.parentHead != trackId)
|
|
continue;
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_spell_children "
|
|
"WHERE guid = {} AND parent_spell_id = {} AND child_spell_id = {}",
|
|
lowGuid, trackId, lw.wrongSpell);
|
|
if (pl->HasSpell(lw.wrongSpell))
|
|
pl->removeSpell(lw.wrongSpell, SPEC_MASK_ALL, false);
|
|
}
|
|
|
|
for (auto const& ap : kAttached)
|
|
{
|
|
if (ap.parentHead != trackId)
|
|
continue;
|
|
if (pl->HasSpell(ap.attachedSpell))
|
|
{
|
|
DbInsertPanelSpellChild(lowGuid, trackId, ap.attachedSpell);
|
|
continue;
|
|
}
|
|
pl->learnSpell(ap.attachedSpell, false);
|
|
DbInsertPanelSpellChild(lowGuid, trackId, ap.attachedSpell);
|
|
|
|
// Drop any stale revoke row pointing at the just-attached
|
|
// spell. Otherwise the login sweep would unlearn it and
|
|
// PushSpellSnapshot's !HasSpell branch would then orphan
|
|
// the panel_spell_children row.
|
|
std::unordered_set<uint32> attachedChain;
|
|
CollectSpellChainIds(ap.attachedSpell, attachedChain);
|
|
if (attachedChain.empty())
|
|
attachedChain.insert(ap.attachedSpell);
|
|
DbDeletePanelSpellRevokedForChain(lowGuid, attachedChain);
|
|
|
|
if (diag)
|
|
LOG_INFO("module",
|
|
"[paragon-diag] forced-attach +{} as child of {} (skill cascade missed it)",
|
|
ap.attachedSpell, trackId);
|
|
}
|
|
}
|
|
|
|
// Clear any stale revoke rows that targeted a rank in this chain. A
|
|
// prior login sweep (before the purchase) or an earlier commit-time
|
|
// diff (e.g., this chain was revoked as a cascade dependent of a
|
|
// *different* purchase the user has since reset/refunded) may have
|
|
// left rows that would otherwise re-fire `removeSpell` next login.
|
|
DbDeletePanelSpellRevokedForChain(lowGuid, chainIds);
|
|
|
|
if (diag)
|
|
LOG_INFO("module",
|
|
"[paragon-diag] PanelLearnSpellChain end: trackId={}", trackId);
|
|
}
|
|
|
|
void DbUpsertPanelTalent(uint32 lowGuid, uint32 talentId, uint32 rank)
|
|
{
|
|
if (!rank)
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_talents WHERE guid = {} AND talent_id = {}",
|
|
lowGuid, talentId);
|
|
return;
|
|
}
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"REPLACE INTO character_paragon_panel_talents (guid, talent_id, `rank`) VALUES ({}, {}, {})",
|
|
lowGuid, talentId, rank);
|
|
}
|
|
|
|
// Player::HasTalent(spell, spec) ignores `spec` and only tests the active
|
|
// spec — useless for dual-spec. Walk the talent map + specMask instead.
|
|
[[nodiscard]] static bool PlayerTalentRankSpellKnownInAnySpec(Player* pl, uint32 rankSpellId)
|
|
{
|
|
if (!pl || !rankSpellId)
|
|
return false;
|
|
PlayerTalentMap const& tm = pl->GetTalentMap();
|
|
auto itr = tm.find(rankSpellId);
|
|
if (itr == tm.end() || !itr->second)
|
|
return false;
|
|
PlayerTalent const* const pt = itr->second;
|
|
if (pt->State == PLAYERSPELL_REMOVED)
|
|
return false;
|
|
uint8 const mask = pt->specMask;
|
|
for (uint8 s = 0; s < pl->GetSpecsCount(); ++s)
|
|
if (mask & (1u << s))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
uint32 ComputeTalentRankAnySpec(Player* pl, uint32 talentId)
|
|
{
|
|
if (!pl)
|
|
return 0;
|
|
|
|
TalentEntry const* te = sTalentStore.LookupEntry(talentId);
|
|
if (!te)
|
|
return 0;
|
|
|
|
uint32 best = 0;
|
|
for (uint8 r = 0; r < MAX_TALENT_RANK; ++r)
|
|
if (te->RankID[r] && PlayerTalentRankSpellKnownInAnySpec(pl, te->RankID[r]))
|
|
best = std::max(best, uint32(r + 1));
|
|
|
|
return best;
|
|
}
|
|
|
|
// ---- Commit handler --------------------------------------------------------
|
|
//
|
|
// Wire format from Net.lua Net:Commit:
|
|
// "C COMMIT s:<id1>,<id2>,...<empty allowed> t:<talentId>:<delta>,... u:<id>,..."
|
|
// The " u:" spell-unlearn section is optional (omitted by older clients).
|
|
// Both s: and t: leading tags are required. Examples:
|
|
// "C COMMIT s:5176,8921 t:"
|
|
// "C COMMIT s: t:1234:1,5678:2"
|
|
// "C COMMIT s: t: u:45477"
|
|
// We parse leniently and abort on any structural error.
|
|
//
|
|
// On success we push:
|
|
// "R OK <ae> <te>" followed by R SPELLS / R TALENTS snapshots.
|
|
// On failure (insufficient AE/TE, unknown spell, etc.):
|
|
// "R ERR <reason>" -- the panel restores its pending state.
|
|
|
|
constexpr size_t kCommitMaxItems = 64;
|
|
|
|
std::vector<uint32> ParseCsvUInt(std::string_view csv)
|
|
{
|
|
std::vector<uint32> out;
|
|
out.reserve(8);
|
|
size_t i = 0;
|
|
while (i < csv.size())
|
|
{
|
|
size_t end = csv.find(',', i);
|
|
if (end == std::string_view::npos)
|
|
end = csv.size();
|
|
if (end > i)
|
|
{
|
|
std::string tok(csv.substr(i, end - i));
|
|
try { out.push_back(uint32(std::stoul(tok))); }
|
|
catch (...) { out.push_back(0); }
|
|
}
|
|
i = end + 1;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Returns true on success; on failure, *err is filled and no state is mutated.
|
|
// Send a SILENCE OPEN window to the client listing every spell id whose
|
|
// learn/unlearn chat toast SHOULD remain visible. The client then suppresses
|
|
// every "you have learned X" / "you have unlearned X" system message during
|
|
// the window whose subject isn't on the allow-list. Window auto-closes
|
|
// after a short timeout client-side; we also send an explicit CLOSE at the
|
|
// end of the commit to release earlier.
|
|
//
|
|
// Allow-list contents:
|
|
// * full chain ids for every spell the player explicitly purchased (so
|
|
// the player still sees "Plague Strike (Rank 1..N) learned" toasts);
|
|
// * every talent rank id the player explicitly purchased (so addToSpellBook
|
|
// talents like Bladestorm/Starfall still toast normally);
|
|
// * chain ids + tracked passive children for spells intentionally unlearned
|
|
// in this commit (so "You have unlearned …" for those stays visible).
|
|
// Anything else learned/unlearned during the window -- the SkillLineAbility
|
|
// cascade and our diff-revoke cleanup -- is silenced.
|
|
void SendSilenceOpenForCommit(Player* pl,
|
|
std::vector<std::pair<uint32, uint32>> const& spellsAndCosts,
|
|
std::vector<std::pair<uint32, uint32>> const& talentDeltas,
|
|
std::vector<uint32> const& unlearnTrackIds = {},
|
|
std::vector<uint32> const& talentUnlearnIds = {})
|
|
{
|
|
if (!pl)
|
|
return;
|
|
|
|
std::unordered_set<uint32> allow;
|
|
for (auto const& kv : spellsAndCosts)
|
|
CollectSpellChainIds(kv.first, allow);
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
for (uint32 trackId : unlearnTrackIds)
|
|
{
|
|
if (!trackId)
|
|
continue;
|
|
CollectSpellChainIds(trackId, allow);
|
|
if (QueryResult cr = CharacterDatabase.Query(
|
|
"SELECT child_spell_id FROM character_paragon_panel_spell_children "
|
|
"WHERE guid = {} AND parent_spell_id = {}",
|
|
lowGuid, trackId))
|
|
{
|
|
do
|
|
{
|
|
uint32 const cid = cr->Fetch()[0].Get<uint32>();
|
|
if (cid)
|
|
allow.insert(cid);
|
|
} while (cr->NextRow());
|
|
}
|
|
}
|
|
|
|
for (auto const& [tid, delta] : talentDeltas)
|
|
{
|
|
(void)delta;
|
|
TalentEntry const* te = sTalentStore.LookupEntry(tid);
|
|
if (!te)
|
|
continue;
|
|
for (uint8 r = 0; r < MAX_TALENT_RANK; ++r)
|
|
if (te->RankID[r])
|
|
allow.insert(te->RankID[r]);
|
|
}
|
|
|
|
// Talent unlearns: each rank id is about to fire SMSG_REMOVED_SPELL.
|
|
// Whitelist them so the "You have unlearned <rank-1 name>" toast
|
|
// shown to the user is not suppressed.
|
|
for (uint32 tid : talentUnlearnIds)
|
|
{
|
|
TalentEntry const* te = sTalentStore.LookupEntry(tid);
|
|
if (!te)
|
|
continue;
|
|
for (uint8 r = 0; r < MAX_TALENT_RANK; ++r)
|
|
if (te->RankID[r])
|
|
allow.insert(te->RankID[r]);
|
|
}
|
|
|
|
// Open the window even when the allow list is empty (still useful for
|
|
// talent-only commits that cascade unrelated passives, etc.).
|
|
std::string body = "R SILENCE OPEN";
|
|
if (!allow.empty())
|
|
{
|
|
body += ' ';
|
|
bool first = true;
|
|
for (uint32 id : allow)
|
|
{
|
|
if (!first)
|
|
body += ',';
|
|
body += std::to_string(id);
|
|
first = false;
|
|
|
|
// Stay under the addon-channel chat budget (~250 chars). When
|
|
// close to full, flush this batch and start a new OPEN message.
|
|
// Client treats multiple OPEN as additive.
|
|
if (body.size() > 220)
|
|
{
|
|
SendAddonMessage(pl, body);
|
|
body = "R SILENCE OPEN ";
|
|
first = true;
|
|
}
|
|
}
|
|
}
|
|
SendAddonMessage(pl, body);
|
|
}
|
|
|
|
void SendSilenceClose(Player* pl)
|
|
{
|
|
if (pl)
|
|
SendAddonMessage(pl, "R SILENCE CLOSE");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Buff-cheese cleanup. When a panel-purchased spell is unlearned (queue
|
|
// unlearn, build swap, full reset) any aura the player cast on themselves
|
|
// with that spell goes away with the spell. Without this, a Paragon could
|
|
// cast Power Word: Fortitude on themselves, queue PW:F for unlearn on
|
|
// Learn All to recoup the AE, and keep the buff for free until next zone
|
|
// change.
|
|
//
|
|
// Filters: only the player's *own* self-cast auras are touched. Buffs on
|
|
// the same player from another caster (a real priest in the group, paladin
|
|
// blessings, etc.) are left alone, and any auras the player cast on others
|
|
// are not affected by this sweep -- crowd-cleansing on every panel mutation
|
|
// would be more annoying than the cheese it closes.
|
|
//
|
|
// The chain walk is so any rank's aura goes regardless of which rank was
|
|
// active when it was cast (cast PW:F R8, then unlearn the chain whose head
|
|
// is R1 -> we still have to look at R8 to find the active aura).
|
|
// ---------------------------------------------------------------------------
|
|
void RemoveSelfCastAurasForChain(Player* pl, uint32 chainAnyRankId)
|
|
{
|
|
if (!pl || !chainAnyRankId)
|
|
return;
|
|
std::unordered_set<uint32> chainIds;
|
|
CollectSpellChainIds(chainAnyRankId, chainIds);
|
|
if (chainIds.empty())
|
|
chainIds.insert(chainAnyRankId);
|
|
ObjectGuid const myGuid = pl->GetGUID();
|
|
for (uint32 rankId : chainIds)
|
|
pl->RemoveOwnedAura(rankId, myGuid);
|
|
}
|
|
|
|
// Blanket sweep of self-cast non-passive auras. Used at the tail of
|
|
// HandleBuildLoad (build swap) so any stale self-buffs cast prior to the
|
|
// swap are cleared, even if the spell that produced them is also in the
|
|
// new build's recipe. There is no useful semantic of "preserve buffs across
|
|
// loadout swap" -- the swap is meant to be a clean state transition, and
|
|
// keeping arbitrary buffs across it is exactly the cheese vector for
|
|
// any spell that is in the OUTGOING recipe but not the INCOMING one.
|
|
//
|
|
// Skipped:
|
|
// - auras whose caster is not the player (party buffs, NPC debuffs)
|
|
// - passives -- spellbook-driven; removing them just makes the engine's
|
|
// CastPassiveAuras / spellbook_apply_passives re-grant them on the
|
|
// next tick. Pointless churn.
|
|
void SweepSelfCastSpellAuras(Player* pl)
|
|
{
|
|
if (!pl)
|
|
return;
|
|
ObjectGuid const myGuid = pl->GetGUID();
|
|
std::vector<uint32> toRemove;
|
|
toRemove.reserve(8);
|
|
for (auto const& kv : pl->GetOwnedAuras())
|
|
{
|
|
Aura const* aura = kv.second;
|
|
if (!aura)
|
|
continue;
|
|
if (aura->GetCasterGUID() != myGuid)
|
|
continue;
|
|
SpellInfo const* si = aura->GetSpellInfo();
|
|
if (!si || si->IsPassive())
|
|
continue;
|
|
toRemove.push_back(kv.first);
|
|
}
|
|
for (uint32 spellId : toRemove)
|
|
pl->RemoveOwnedAura(spellId, myGuid);
|
|
}
|
|
|
|
// Removes one Character Advancement spell purchase (chain head in
|
|
// character_paragon_panel_spells). Refunds that row's AE cost, unlearns
|
|
// tracked passive children then the parent chain, and clears matching
|
|
// panel_* DB rows (mirrors the per-spell portion of HandleParagonResetAbilities).
|
|
// `spellId` may be any rank id from the bake; normalized to GetFirstSpellInChain.
|
|
bool PanelUnlearnSpellPurchase(Player* pl, uint32 spellId, std::string* err)
|
|
{
|
|
if (!pl || !spellId)
|
|
{
|
|
if (err)
|
|
*err = "bad player or spell";
|
|
return false;
|
|
}
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
uint32 const head = sSpellMgr->GetFirstSpellInChain(spellId);
|
|
uint32 const sid = head ? head : spellId;
|
|
|
|
if (!CharacterDatabase.Query(
|
|
"SELECT 1 FROM character_paragon_panel_spells WHERE guid = {} AND spell_id = {} LIMIT 1",
|
|
lowGuid, sid))
|
|
{
|
|
if (err)
|
|
*err = fmt::format("spell {} is not a panel purchase", sid);
|
|
return false;
|
|
}
|
|
|
|
uint32 const refund = LookupSpellAECost(sid);
|
|
|
|
if (QueryResult cr = CharacterDatabase.Query(
|
|
"SELECT child_spell_id FROM character_paragon_panel_spell_children "
|
|
"WHERE guid = {} AND parent_spell_id = {}",
|
|
lowGuid, sid))
|
|
{
|
|
do
|
|
{
|
|
uint32 const cid = cr->Fetch()[0].Get<uint32>();
|
|
if (pl->HasSpell(cid))
|
|
pl->removeSpell(cid, SPEC_MASK_ALL, false);
|
|
} while (cr->NextRow());
|
|
}
|
|
|
|
if (pl->HasSpell(sid))
|
|
pl->removeSpell(sid, SPEC_MASK_ALL, false);
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_spell_children WHERE guid = {} AND parent_spell_id = {}",
|
|
lowGuid, sid);
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_spell_revoked WHERE guid = {} AND parent_spell_id = {}",
|
|
lowGuid, sid);
|
|
|
|
std::unordered_set<uint32> chainIds;
|
|
CollectSpellChainIds(sid, chainIds);
|
|
DbDeletePanelSpellRevokedForChain(lowGuid, chainIds);
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_spells WHERE guid = {} AND spell_id = {}",
|
|
lowGuid, sid);
|
|
|
|
// Buff-cheese close: drop any self-cast aura whose source is this chain.
|
|
// (See RemoveSelfCastAurasForChain comment.)
|
|
RemoveSelfCastAurasForChain(pl, sid);
|
|
|
|
ParagonCurrencyData& d = GetOrCreateCacheEntry(lowGuid);
|
|
d.abilityEssence += refund;
|
|
return true;
|
|
}
|
|
|
|
// Removes one Character Advancement talent purchase entirely. Refunds all
|
|
// ranks worth of TE (and AE for addToSpellBook talents), drops every rank
|
|
// spell from m_spells / m_talents across all specs, deletes the panel_talents
|
|
// row. Symmetric counterpart of PanelUnlearnSpellPurchase.
|
|
bool PanelUnlearnTalentPurchase(Player* pl, uint32 talentId, uint32* outRefundAE,
|
|
uint32* outRefundTE, std::string* err)
|
|
{
|
|
if (outRefundAE) *outRefundAE = 0;
|
|
if (outRefundTE) *outRefundTE = 0;
|
|
|
|
if (!pl || !talentId)
|
|
{
|
|
if (err) *err = "bad player or talent";
|
|
return false;
|
|
}
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
|
|
QueryResult q = CharacterDatabase.Query(
|
|
"SELECT `rank` FROM character_paragon_panel_talents WHERE guid = {} AND talent_id = {}",
|
|
lowGuid, talentId);
|
|
if (!q)
|
|
{
|
|
if (err) *err = fmt::format("talent {} is not a panel purchase", talentId);
|
|
return false;
|
|
}
|
|
uint32 const dbRank = q->Fetch()[0].Get<uint32>();
|
|
|
|
TalentEntry const* te = sTalentStore.LookupEntry(talentId);
|
|
if (!te)
|
|
{
|
|
if (err) *err = fmt::format("unknown talent {}", talentId);
|
|
return false;
|
|
}
|
|
|
|
// Use the player's *actual* rank across specs, capped at the DB record.
|
|
// Refund matches what was actually spent: a partial-rank purchase that
|
|
// got reset out of one spec but not another should refund what was
|
|
// recorded in panel_talents, not the engine state.
|
|
uint32 const actual = ComputeTalentRankAnySpec(pl, talentId);
|
|
uint32 const refundRanks = std::min(dbRank, actual ? actual : dbRank);
|
|
if (!refundRanks)
|
|
{
|
|
// Player has no rank but row exists -> stale. Drop it and skip
|
|
// refund so we don't double-credit a previous reset.
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_talents WHERE guid = {} AND talent_id = {}",
|
|
lowGuid, talentId);
|
|
return true;
|
|
}
|
|
|
|
uint32 const tePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
uint32 const aePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.TalentLearnCost", 1);
|
|
uint32 const refundTE = refundRanks * tePerRank;
|
|
uint32 const refundAE = te->addToSpellBook ? (refundRanks * aePerRank) : 0;
|
|
|
|
// Wipe every rank across all specs. Important caveats:
|
|
// * Player::removeSpell only touches m_spells. The m_talents entry
|
|
// (PlayerTalent + specMask) is NOT cleared, so HasTalent /
|
|
// `HasBeastMasteryInAnySpec` keep returning true after.
|
|
// Player::resetTalents pairs `_removeTalentAurasAndSpells` +
|
|
// `_removeTalent` for that reason — mirror it here.
|
|
// * `addToSpellBook` talents (Bladestorm/Starfall/...) also live in
|
|
// the spellbook and need a removeSpell so the icon goes away.
|
|
// * Some talents trigger `IsAdditionalTalentSpell` extras via
|
|
// SPELL_EFFECT_LEARN_SPELL — strip those too (matches resetTalents).
|
|
for (uint8 ri = 0; ri < MAX_TALENT_RANK; ++ri)
|
|
{
|
|
uint32 const rankSpell = te->RankID[ri];
|
|
if (!rankSpell)
|
|
continue;
|
|
|
|
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(rankSpell);
|
|
|
|
pl->_removeTalentAurasAndSpells(rankSpell);
|
|
|
|
if (te->addToSpellBook && spellInfo
|
|
&& !spellInfo->HasAttribute(SPELL_ATTR0_PASSIVE)
|
|
&& !spellInfo->HasEffect(SPELL_EFFECT_LEARN_SPELL))
|
|
{
|
|
if (pl->HasSpell(rankSpell))
|
|
pl->removeSpell(rankSpell, SPEC_MASK_ALL, false);
|
|
}
|
|
|
|
if (spellInfo)
|
|
{
|
|
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
|
|
{
|
|
uint32 const trig = spellInfo->Effects[i].TriggerSpell;
|
|
if (spellInfo->Effects[i].Effect == SPELL_EFFECT_LEARN_SPELL && trig
|
|
&& sSpellMgr->IsAdditionalTalentSpell(trig)
|
|
&& pl->HasSpell(trig))
|
|
{
|
|
pl->removeSpell(trig, SPEC_MASK_ALL, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Drop the m_talents row so HasTalent / HasBeastMasteryInAnySpec /
|
|
// OnPlayerLearnTalents bookkeeping stop seeing the talent.
|
|
pl->_removeTalent(rankSpell, SPEC_MASK_ALL);
|
|
}
|
|
|
|
// Push the engine-side talent state to the client so the talent UI
|
|
// (and the +talent-points pool) reflects the unlearn immediately.
|
|
pl->SendTalentsInfoData(false);
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_talents WHERE guid = {} AND talent_id = {}",
|
|
lowGuid, talentId);
|
|
|
|
ParagonCurrencyData& d = GetOrCreateCacheEntry(lowGuid);
|
|
d.abilityEssence += refundAE;
|
|
d.talentEssence += refundTE;
|
|
|
|
if (outRefundAE) *outRefundAE = refundAE;
|
|
if (outRefundTE) *outRefundTE = refundTE;
|
|
return true;
|
|
}
|
|
|
|
// Forward declarations for helpers defined later in this TU. HandleCommit
|
|
// is far enough above them in the file that we'd need to either rearrange
|
|
// or declare upfront; declarations are smaller surface area.
|
|
bool HasBeastMasteryInAnySpec(Player* pl);
|
|
void MaybeForcePetTalentResetForBeastMasteryLoss(Player* pl, bool hadBeastMasteryBefore);
|
|
|
|
bool HandleCommit(Player* pl, std::string const& body, std::string* err)
|
|
{
|
|
// Strip leading "C COMMIT " (already stripped by caller, but be defensive)
|
|
constexpr std::string_view kPrefix = "C COMMIT ";
|
|
std::string_view rest = body;
|
|
if (rest.substr(0, kPrefix.size()) == kPrefix)
|
|
rest.remove_prefix(kPrefix.size());
|
|
|
|
// Find " t:" delimiter to split spells / talents sections.
|
|
auto sPos = rest.find("s:");
|
|
auto tPos = rest.find(" t:");
|
|
if (sPos != 0 || tPos == std::string_view::npos)
|
|
{
|
|
*err = "malformed commit";
|
|
return false;
|
|
}
|
|
|
|
std::string_view spellsCsv = rest.substr(2, tPos - 2);
|
|
std::string_view talentsCsv;
|
|
std::string_view unlearnCsv;
|
|
std::string_view talentUnlearnCsv;
|
|
|
|
// Layout after " t:" is one of:
|
|
// <talents> (no unlearns at all)
|
|
// <talents> u:<spell-unlearn-ids> (legacy)
|
|
// <talents> u:<...> tu:<talent-unlearn-ids> (current)
|
|
// <talents> tu:<talent-unlearn-ids> (no spell unlearns)
|
|
// The " u:" / " tu:" tokens are kept distinct (note the leading space)
|
|
// so a substring match for " u:" never collides with " tu:".
|
|
size_t const uPos = rest.find(" u:", tPos);
|
|
size_t const tuPos = rest.find(" tu:", tPos);
|
|
|
|
auto inRange = [](size_t v) { return v != std::string_view::npos; };
|
|
|
|
if (inRange(uPos) && inRange(tuPos))
|
|
{
|
|
talentsCsv = rest.substr(tPos + 3, uPos - (tPos + 3));
|
|
unlearnCsv = rest.substr(uPos + 3, tuPos - (uPos + 3));
|
|
talentUnlearnCsv = rest.substr(tuPos + 4);
|
|
}
|
|
else if (inRange(uPos))
|
|
{
|
|
talentsCsv = rest.substr(tPos + 3, uPos - (tPos + 3));
|
|
unlearnCsv = rest.substr(uPos + 3);
|
|
}
|
|
else if (inRange(tuPos))
|
|
{
|
|
talentsCsv = rest.substr(tPos + 3, tuPos - (tPos + 3));
|
|
talentUnlearnCsv = rest.substr(tuPos + 4);
|
|
}
|
|
else
|
|
talentsCsv = rest.substr(tPos + 3);
|
|
|
|
std::vector<uint32> spellIds = ParseCsvUInt(spellsCsv);
|
|
std::vector<uint32> unlearnRaw = ParseCsvUInt(unlearnCsv);
|
|
std::vector<uint32> talentUnlearnRaw = ParseCsvUInt(talentUnlearnCsv);
|
|
|
|
// Talents are "id:delta,id:delta,...". Parse into vector of pairs.
|
|
std::vector<std::pair<uint32, uint32>> talentDeltas;
|
|
{
|
|
size_t i = 0;
|
|
while (i < talentsCsv.size())
|
|
{
|
|
size_t end = talentsCsv.find(',', i);
|
|
if (end == std::string_view::npos)
|
|
end = talentsCsv.size();
|
|
if (end > i)
|
|
{
|
|
std::string_view tok = talentsCsv.substr(i, end - i);
|
|
size_t colon = tok.find(':');
|
|
if (colon == std::string_view::npos)
|
|
{
|
|
*err = "talent token missing colon";
|
|
return false;
|
|
}
|
|
uint32 tid = 0, delta = 0;
|
|
try
|
|
{
|
|
tid = uint32(std::stoul(std::string(tok.substr(0, colon))));
|
|
delta = uint32(std::stoul(std::string(tok.substr(colon + 1))));
|
|
}
|
|
catch (...)
|
|
{
|
|
*err = "talent token parse failed";
|
|
return false;
|
|
}
|
|
if (tid && delta)
|
|
talentDeltas.emplace_back(tid, delta);
|
|
}
|
|
i = end + 1;
|
|
}
|
|
}
|
|
|
|
std::unordered_set<uint32> unlearnTrackSet;
|
|
std::vector<uint32> unlearnTracks;
|
|
for (uint32 raw : unlearnRaw)
|
|
{
|
|
if (!raw)
|
|
continue;
|
|
uint32 const head = sSpellMgr->GetFirstSpellInChain(raw);
|
|
uint32 const tid = head ? head : raw;
|
|
if (unlearnTrackSet.insert(tid).second)
|
|
unlearnTracks.push_back(tid);
|
|
}
|
|
|
|
// Dedupe talent unlearns (same talent twice in one commit is a no-op).
|
|
std::unordered_set<uint32> talentUnlearnSet;
|
|
std::vector<uint32> talentUnlearns;
|
|
talentUnlearns.reserve(talentUnlearnRaw.size());
|
|
for (uint32 tid : talentUnlearnRaw)
|
|
{
|
|
if (!tid)
|
|
continue;
|
|
if (talentUnlearnSet.insert(tid).second)
|
|
talentUnlearns.push_back(tid);
|
|
}
|
|
|
|
if (spellIds.size() + talentDeltas.size() + unlearnTracks.size() + talentUnlearns.size() > kCommitMaxItems)
|
|
{
|
|
*err = "commit exceeds size cap";
|
|
return false;
|
|
}
|
|
|
|
uint32 unlearnRefundAE = 0;
|
|
for (uint32 tid : unlearnTracks)
|
|
{
|
|
if (!CharacterDatabase.Query(
|
|
"SELECT 1 FROM character_paragon_panel_spells WHERE guid = {} AND spell_id = {} LIMIT 1",
|
|
pl->GetGUID().GetCounter(), tid))
|
|
{
|
|
*err = fmt::format("cannot unlearn {} (not a panel purchase)", tid);
|
|
return false;
|
|
}
|
|
unlearnRefundAE += LookupSpellAECost(tid);
|
|
}
|
|
|
|
// Pre-validate talent unlearns. Each must be a panel purchase, must
|
|
// not also appear in talentDeltas (can't learn + unlearn in one
|
|
// commit), and contributes its full ranks * costPerRank to the
|
|
// commit's refund pool. addToSpellBook talents add AE to the pool;
|
|
// all talents add TE.
|
|
uint32 talentUnlearnRefundAE = 0;
|
|
uint32 talentUnlearnRefundTE = 0;
|
|
{
|
|
uint32 const tePerRank_pre = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
uint32 const aePerRank_pre = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.TalentLearnCost", 1);
|
|
for (uint32 tid : talentUnlearns)
|
|
{
|
|
for (auto const& [td, _delta] : talentDeltas)
|
|
{
|
|
if (td == tid)
|
|
{
|
|
*err = "cannot learn and unlearn the same talent in one commit";
|
|
return false;
|
|
}
|
|
}
|
|
QueryResult r = CharacterDatabase.Query(
|
|
"SELECT `rank` FROM character_paragon_panel_talents WHERE guid = {} AND talent_id = {}",
|
|
pl->GetGUID().GetCounter(), tid);
|
|
if (!r)
|
|
{
|
|
*err = fmt::format("cannot unlearn talent {} (not a panel purchase)", tid);
|
|
return false;
|
|
}
|
|
uint32 const rank = r->Fetch()[0].Get<uint32>();
|
|
TalentEntry const* te = sTalentStore.LookupEntry(tid);
|
|
if (!te)
|
|
{
|
|
*err = fmt::format("unknown talent {}", tid);
|
|
return false;
|
|
}
|
|
talentUnlearnRefundTE += rank * tePerRank_pre;
|
|
if (te->addToSpellBook)
|
|
talentUnlearnRefundAE += rank * aePerRank_pre;
|
|
}
|
|
}
|
|
|
|
// Pre-validate spells: must be valid SpellInfo, not already learned,
|
|
// and afford their combined AE cost.
|
|
uint32 totalAE = 0;
|
|
std::vector<std::pair<uint32, uint32>> spellsAndCosts;
|
|
spellsAndCosts.reserve(spellIds.size());
|
|
for (uint32 id : spellIds)
|
|
{
|
|
if (!id)
|
|
continue;
|
|
SpellInfo const* info = sSpellMgr->GetSpellInfo(id);
|
|
if (!info)
|
|
{
|
|
*err = fmt::format("unknown spell {}", id);
|
|
return false;
|
|
}
|
|
if (pl->HasSpell(id))
|
|
continue; // silently skip; not an error from the user's POV
|
|
uint32 const reqLv = GetParagonPanelSpellRequiredLevel(info);
|
|
if (pl->GetLevel() < reqLv)
|
|
{
|
|
*err = fmt::format("requires level {} for spell {}", reqLv, id);
|
|
return false;
|
|
}
|
|
uint32 const learnHead = sSpellMgr->GetFirstSpellInChain(id);
|
|
uint32 const learnTrack = learnHead ? learnHead : id;
|
|
if (unlearnTrackSet.count(learnTrack))
|
|
{
|
|
*err = "cannot learn and unlearn the same spell in one commit";
|
|
return false;
|
|
}
|
|
uint32 cost = LookupSpellAECost(id);
|
|
spellsAndCosts.emplace_back(id, cost);
|
|
totalAE += cost;
|
|
}
|
|
// (combined AE budget — spells + spell-granting talent ranks — is checked
|
|
// once below after we know the talent AE total)
|
|
|
|
// Pre-validate talents. addToSpellBook talents (Starfall, Bladestorm, …)
|
|
// cost both AE and TE per rank; other talents cost TE only.
|
|
uint32 const tePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
uint32 const aePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.TalentLearnCost", 1);
|
|
uint32 talentsTE = 0;
|
|
uint32 talentsAE = 0;
|
|
for (auto const& [tid, delta] : talentDeltas)
|
|
{
|
|
TalentEntry const* te = sTalentStore.LookupEntry(tid);
|
|
if (!te)
|
|
{
|
|
*err = fmt::format("unknown talent {}", tid);
|
|
return false;
|
|
}
|
|
// Same tier gate as default Wrath UI: row 0 @ 10, +5 per row down.
|
|
uint32 const minLevelForTier = 10u + te->Row * 5u;
|
|
if (pl->GetLevel() < minLevelForTier)
|
|
{
|
|
*err = fmt::format("requires level {} for that talent tier", minLevelForTier);
|
|
return false;
|
|
}
|
|
if (te->addToSpellBook)
|
|
{
|
|
talentsAE += delta * aePerRank;
|
|
talentsTE += delta * tePerRank;
|
|
}
|
|
else
|
|
talentsTE += delta * tePerRank;
|
|
}
|
|
if (GetTE(pl) + talentUnlearnRefundTE < talentsTE)
|
|
{
|
|
*err = fmt::format("not enough TE (need {} have {} plus {} from talent unlearns in this commit)",
|
|
talentsTE, GetTE(pl), talentUnlearnRefundTE);
|
|
return false;
|
|
}
|
|
if (GetAE(pl) + unlearnRefundAE + talentUnlearnRefundAE < (totalAE + talentsAE))
|
|
{
|
|
*err = fmt::format("not enough AE (need {} total; you have {} plus {} from spell unlearns and {} from talent unlearns in this commit)",
|
|
totalAE + talentsAE, GetAE(pl), unlearnRefundAE, talentUnlearnRefundAE);
|
|
return false;
|
|
}
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
|
|
// Open client-side silence window so the cascade dependents AC's
|
|
// learnSpell drags along (Death Coil/Death Grip/Blood Plague/Blood
|
|
// Presence/Forceful Deflection/Runic Focus/...) don't spam learn/
|
|
// unlearn toasts. Allow list = chain ranks of explicitly purchased
|
|
// spells + talent rank ids + chains/children for intentional unlearns
|
|
// (spells + talents).
|
|
SendSilenceOpenForCommit(pl, spellsAndCosts, talentDeltas, unlearnTracks, talentUnlearns);
|
|
|
|
// Capture BM pre-state for the pet-talent-respec check below. Beast
|
|
// Mastery is a talent, so only the talent unlearn path can flip the
|
|
// value within this commit.
|
|
bool const hadBeastMasteryPre = !talentUnlearns.empty() && HasBeastMasteryInAnySpec(pl);
|
|
|
|
// Apply unlearns first so refunded AE/TE is available for spends.
|
|
for (uint32 tid : unlearnTracks)
|
|
{
|
|
if (!PanelUnlearnSpellPurchase(pl, tid, err))
|
|
{
|
|
SendSilenceClose(pl);
|
|
return false;
|
|
}
|
|
}
|
|
for (uint32 tid : talentUnlearns)
|
|
{
|
|
if (!PanelUnlearnTalentPurchase(pl, tid, /*outRefundAE*/nullptr,
|
|
/*outRefundTE*/nullptr, err))
|
|
{
|
|
SendSilenceClose(pl);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// If a talent that puts an active aura on the player (e.g. an
|
|
// addToSpellBook talent like Improved Devotion Aura) just got
|
|
// refunded, the aura should go with it. Mirrors the build-swap
|
|
// sweep. Cheap when no talents were unlearned.
|
|
if (!talentUnlearns.empty())
|
|
{
|
|
SweepSelfCastSpellAuras(pl);
|
|
MaybeForcePetTalentResetForBeastMasteryLoss(pl, hadBeastMasteryPre);
|
|
}
|
|
|
|
// Apply spells: each consumes its individual AE cost. PanelLearnSpellChain
|
|
// also grants every higher rank up to the player's current level so the
|
|
// panel matches "trainer-style" learning (e.g., buying Wrath at L60 yields
|
|
// ranks 1-9 in one purchase). Only the chain head is recorded so reset
|
|
// refunds the AE cost exactly once per purchase.
|
|
for (auto const& [id, cost] : spellsAndCosts)
|
|
{
|
|
if (!TrySpendAE(pl, cost))
|
|
{
|
|
*err = "AE spend failed mid-commit (race?)";
|
|
SendSilenceClose(pl);
|
|
return false;
|
|
}
|
|
PanelLearnSpellChain(pl, id);
|
|
}
|
|
|
|
// Apply talents one rank at a time so each call goes through the
|
|
// existing OnPlayerLearnTalents hook (which spends TE per rank, and
|
|
// both AE+TE for addToSpellBook talents).
|
|
// command=true bypasses talent-point and tier-spend requirements;
|
|
// class-mask is bypassed in core for Paragon (Player::LearnTalent).
|
|
for (auto const& [tid, delta] : talentDeltas)
|
|
{
|
|
TalentEntry const* te = sTalentStore.LookupEntry(tid);
|
|
if (!te)
|
|
continue;
|
|
|
|
// Find the player's current rank in this talent (0-indexed; 0 means
|
|
// none, 1 means rank-1, etc.). Compare against MAX_TALENT_RANK.
|
|
uint32 currentRank = 0;
|
|
for (uint8 r = 0; r < MAX_TALENT_RANK; ++r)
|
|
{
|
|
if (te->RankID[r] && pl->HasTalent(te->RankID[r], pl->GetActiveSpec()))
|
|
{
|
|
currentRank = r + 1;
|
|
// keep scanning to find HIGHEST rank
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
(void)delta;
|
|
uint32 const r = ComputeTalentRankAnySpec(pl, tid);
|
|
DbUpsertPanelTalent(lowGuid, tid, r);
|
|
}
|
|
|
|
// One scoped sweep after all panel DB rows for this commit exist. Catches
|
|
// cascade dependents the per-rank diff missed when anchor SkillLine rows
|
|
// used a non-LEARN_* AcquireMethod (fixed in SkillLinesLinkedToSpell, but
|
|
// this is cheap insurance for mixed commits / talent side effects).
|
|
RevokeUnwantedCascadeSpellsForPlayer(pl);
|
|
|
|
SaveCurrencyToDb(pl);
|
|
SendSilenceClose(pl);
|
|
return true;
|
|
}
|
|
|
|
// ---- Snapshot push (R SPELLS / R TALENTS) ---------------------------------
|
|
//
|
|
// Sends spell IDs and talent (id, rank) pairs that were purchased through
|
|
// Character Advancement only (see character_paragon_panel_* tables).
|
|
//
|
|
// Addon-channel messages have a generous chat-packet size budget but smaller
|
|
// is friendlier, so we chunk into ~180-char payload bodies. Format:
|
|
// "R SPELLS <id>,<id>,..." (multiple messages OK; client appends)
|
|
// "R SPELLS_END" (sentinel: rebuild list now)
|
|
// "R TALENTS <tid>:<rank>,..." (chunked similarly)
|
|
// "R TALENTS_END"
|
|
// The client clears its buffer when it sees the first "R SPELLS" / "R TALENTS"
|
|
// after a "_END", so resending is idempotent.
|
|
|
|
constexpr size_t kSnapshotChunkBudget = 180;
|
|
|
|
void PushSpellSnapshot(Player* pl)
|
|
{
|
|
if (!pl)
|
|
return;
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
std::string buf;
|
|
buf.reserve(kSnapshotChunkBudget + 16);
|
|
buf = "R SPELLS ";
|
|
bool first = true;
|
|
|
|
auto flush = [&](bool finalChunk)
|
|
{
|
|
if (buf.size() > 9)
|
|
SendAddonMessage(pl, buf);
|
|
buf = "R SPELLS ";
|
|
first = true;
|
|
if (finalChunk)
|
|
SendAddonMessage(pl, "R SPELLS_END");
|
|
};
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT spell_id FROM character_paragon_panel_spells WHERE guid = {} ORDER BY spell_id", lowGuid))
|
|
{
|
|
do
|
|
{
|
|
uint32 const sid = r->Fetch()[0].Get<uint32>();
|
|
if (!pl->HasSpell(sid))
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_spells WHERE guid = {} AND spell_id = {}",
|
|
lowGuid, sid);
|
|
continue;
|
|
}
|
|
|
|
// Note: we deliberately do NOT filter SPELL_ATTR0_DO_NOT_DISPLAY
|
|
// here. Earlier builds did, on the theory that hidden spells
|
|
// shouldn't appear in the spellbook-style Overview tab. That
|
|
// turned out to be wrong: cascade-granted hidden passives
|
|
// (Forceful Deflection, Frost Fever, ...) live in
|
|
// panel_spell_children, not in panel_spells -- so the only
|
|
// entries that ever land in this query are the chain heads
|
|
// the player explicitly purchased. Those MUST appear in the
|
|
// Overview even if their DBC entry is hidden, because they
|
|
// are the player's actual purchases (e.g. Runeforging 53428
|
|
// is hidden in the DBC but is the entire Runeforging panel
|
|
// purchase). Filtering them out left chars whose only buy
|
|
// was Runeforging with an empty Overview tab -- looked like
|
|
// a regression but was actually the existing snapshot logic
|
|
// mismatching the panel's user-facing semantics.
|
|
|
|
std::string token = (first ? "" : ",") + std::to_string(sid);
|
|
if (buf.size() + token.size() > kSnapshotChunkBudget)
|
|
flush(/*finalChunk=*/false);
|
|
buf.append(first ? std::to_string(sid) : token);
|
|
first = false;
|
|
} while (r->NextRow());
|
|
}
|
|
flush(/*finalChunk=*/true);
|
|
}
|
|
|
|
void PushTalentSnapshot(Player* pl)
|
|
{
|
|
if (!pl)
|
|
return;
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
std::string buf = "R TALENTS ";
|
|
bool first = true;
|
|
|
|
auto flush = [&](bool finalChunk)
|
|
{
|
|
if (buf.size() > 10)
|
|
SendAddonMessage(pl, buf);
|
|
buf = "R TALENTS ";
|
|
first = true;
|
|
if (finalChunk)
|
|
SendAddonMessage(pl, "R TALENTS_END");
|
|
};
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT talent_id, `rank` FROM character_paragon_panel_talents WHERE guid = {}", lowGuid))
|
|
{
|
|
do
|
|
{
|
|
Field const* f = r->Fetch();
|
|
uint32 const tid = f[0].Get<uint32>();
|
|
uint32 const dbRank = f[1].Get<uint32>();
|
|
uint32 const actual = ComputeTalentRankAnySpec(pl, tid);
|
|
if (!actual || !dbRank)
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_talents WHERE guid = {} AND talent_id = {}",
|
|
lowGuid, tid);
|
|
continue;
|
|
}
|
|
|
|
uint32 const shown = std::min(actual, dbRank);
|
|
|
|
std::string token =
|
|
(first ? "" : ",") + std::to_string(tid) + ":" + std::to_string(shown);
|
|
if (buf.size() + token.size() > kSnapshotChunkBudget)
|
|
flush(/*finalChunk=*/false);
|
|
buf.append(first ? (std::to_string(tid) + ":" + std::to_string(shown)) : token);
|
|
first = false;
|
|
} while (r->NextRow());
|
|
}
|
|
flush(/*finalChunk=*/true);
|
|
}
|
|
|
|
bool HandleParagonResetAbilities(Player* pl, std::string* err)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
*err = "not a Paragon";
|
|
return false;
|
|
}
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
{
|
|
*err = "Paragon currency disabled";
|
|
return false;
|
|
}
|
|
|
|
LoadCurrencyFromDb(pl);
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
uint32 refundAE = 0;
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT spell_id FROM character_paragon_panel_spells WHERE guid = {} ORDER BY spell_id", lowGuid))
|
|
{
|
|
do
|
|
{
|
|
uint32 const sid = r->Fetch()[0].Get<uint32>();
|
|
refundAE += LookupSpellAECost(sid);
|
|
|
|
// Unlearn any passive dependents we tracked when this parent
|
|
// was learned (Frost Fever, Blood Presence, Forceful
|
|
// Deflection, ...). Done before removing the parent so the
|
|
// server doesn't re-grant them via SPELL_EFFECT_LEARN_SPELL
|
|
// re-application during the parent's removeSpell cascade.
|
|
if (QueryResult cr = CharacterDatabase.Query(
|
|
"SELECT child_spell_id FROM character_paragon_panel_spell_children "
|
|
"WHERE guid = {} AND parent_spell_id = {}", lowGuid, sid))
|
|
{
|
|
do
|
|
{
|
|
uint32 const cid = cr->Fetch()[0].Get<uint32>();
|
|
if (pl->HasSpell(cid))
|
|
pl->removeSpell(cid, SPEC_MASK_ALL, false);
|
|
} while (cr->NextRow());
|
|
}
|
|
|
|
if (pl->HasSpell(sid))
|
|
pl->removeSpell(sid, SPEC_MASK_ALL, false);
|
|
|
|
// Buff-cheese close: drop any self-cast aura sourced from this
|
|
// chain. Same rationale as PanelUnlearnSpellPurchase, applied
|
|
// here so a full Reset Abilities (or the reset phase of a build
|
|
// swap) doesn't leave Power Word: Fortitude / Inner Fire / etc.
|
|
// ticking after the spell is gone from the spellbook.
|
|
RemoveSelfCastAurasForChain(pl, sid);
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
// Best-effort revoke pass for active dependents the cascade may have
|
|
// re-installed since last commit (Blood Presence, Death Coil, ...).
|
|
// Without this, a player who upgraded to this build with orphan
|
|
// dependents already in their spellbook would still see them after
|
|
// Reset Abilities; with this they're swept the moment they reset.
|
|
if (QueryResult rev = CharacterDatabase.Query(
|
|
"SELECT revoked_spell_id FROM character_paragon_panel_spell_revoked WHERE guid = {}", lowGuid))
|
|
{
|
|
do
|
|
{
|
|
uint32 const sid = rev->Fetch()[0].Get<uint32>();
|
|
if (pl->HasSpell(sid))
|
|
pl->removeSpell(sid, SPEC_MASK_ALL, false);
|
|
} while (rev->NextRow());
|
|
}
|
|
|
|
CharacterDatabase.DirectExecute("DELETE FROM character_paragon_panel_spells WHERE guid = {}", lowGuid);
|
|
CharacterDatabase.DirectExecute("DELETE FROM character_paragon_panel_spell_children WHERE guid = {}", lowGuid);
|
|
CharacterDatabase.DirectExecute("DELETE FROM character_paragon_panel_spell_revoked WHERE guid = {}", lowGuid);
|
|
|
|
if (refundAE)
|
|
{
|
|
ParagonCurrencyData& d = GetOrCreateCacheEntry(lowGuid);
|
|
d.abilityEssence += refundAE;
|
|
}
|
|
|
|
// Reset detaches the player from any active build. The build's
|
|
// saved recipe is preserved in DB so the player can re-load it,
|
|
// but until they do, the next swap MUST NOT auto-snapshot the
|
|
// (now empty/partial) panel state into that build -- which is
|
|
// exactly what would happen if we left the pointer set. We push
|
|
// the catalog so the cell that previously had the "active"
|
|
// border drops it client-side; if this reset is being invoked
|
|
// mid-swap (HandleBuildLoad), the swap's final PushBuildCatalog
|
|
// restores the correct activeId at the tail.
|
|
SetActiveBuildId(lowGuid, 0);
|
|
|
|
SaveCurrencyToDb(pl);
|
|
PushCurrency(pl);
|
|
PushSnapshot(pl);
|
|
PushBuildCatalog(pl);
|
|
LOG_INFO("module", "Paragon panel: {} reset abilities (+{} AE refund)", pl->GetName(), refundAE);
|
|
return true;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Beast Mastery (Hunter 51-pt talent, spell 53270): grants +4 pet talent
|
|
// points while learned. If the player loses the talent (Reset Talents,
|
|
// build swap to a non-BM recipe, ...) we must wipe the pet's current talent
|
|
// allocation -- otherwise the 4 extra slots they spent while specced into
|
|
// BM keep their effects after the talent is gone, which is straight cheese.
|
|
//
|
|
// Detection is "had it before, doesn't have it after". Beast Mastery is a
|
|
// single-rank talent (spell 53270 on talent id 2139 in our client bake); the
|
|
// rank spell must be looked up via the talent map's specMask — Player::HasTalent
|
|
// ignores its spec argument and only checks the active spec, which misses BM
|
|
// learned on the inactive dual-spec page.
|
|
// ---------------------------------------------------------------------------
|
|
constexpr uint32 kSpellBeastMastery = 53270;
|
|
|
|
bool HasBeastMasteryInAnySpec(Player* pl)
|
|
{
|
|
return PlayerTalentRankSpellKnownInAnySpec(pl, kSpellBeastMastery);
|
|
}
|
|
|
|
void MaybeForcePetTalentResetForBeastMasteryLoss(Player* pl, bool hadBeastMasteryBefore)
|
|
{
|
|
if (!pl || !hadBeastMasteryBefore)
|
|
return;
|
|
if (HasBeastMasteryInAnySpec(pl))
|
|
return; // still learned somewhere -> no cheese to close
|
|
Pet* pet = pl->GetPet();
|
|
if (!pet || pet->getPetType() != HUNTER_PET)
|
|
return; // only hunter pets have a talent tree in 3.3.5
|
|
// Free, instant: refunds spent pet talents and re-pushes the talent UI.
|
|
// Same call the addon's "C RESET PET TALENTS" verb uses.
|
|
pl->ResetPetTalents();
|
|
LOG_INFO("module",
|
|
"Paragon panel: {} lost Beast Mastery -> pet talents force-reset",
|
|
pl->GetName());
|
|
}
|
|
|
|
bool HandleParagonResetTalents(Player* pl, std::string* err, bool autoResetPetIfBmLost = true)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
*err = "not a Paragon";
|
|
return false;
|
|
}
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
{
|
|
*err = "Paragon currency disabled";
|
|
return false;
|
|
}
|
|
|
|
// Capture pre-reset BM state so we can detect a "had it, lost it"
|
|
// transition once the engine's resetTalents pass below has wiped
|
|
// every spec. Skipped when the caller wants to handle the check
|
|
// themselves (HandleBuildLoad does it post-recipe-apply so it can
|
|
// also clear BM lost across a swap into a non-BM build).
|
|
bool const hadBeastMasteryPre = autoResetPetIfBmLost && HasBeastMasteryInAnySpec(pl);
|
|
|
|
LoadCurrencyFromDb(pl);
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
uint32 refundAE = 0;
|
|
uint32 refundTE = 0;
|
|
uint32 const tePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
uint32 const aePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.TalentLearnCost", 1);
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT talent_id, `rank` FROM character_paragon_panel_talents WHERE guid = {}", lowGuid))
|
|
{
|
|
do
|
|
{
|
|
Field const* f = r->Fetch();
|
|
uint32 const tid = f[0].Get<uint32>();
|
|
uint32 const dbRank = f[1].Get<uint32>();
|
|
TalentEntry const* te = sTalentStore.LookupEntry(tid);
|
|
if (!te || !dbRank)
|
|
continue;
|
|
uint32 const actual = ComputeTalentRankAnySpec(pl, tid);
|
|
uint32 const ranks = std::min(dbRank, actual);
|
|
if (!ranks)
|
|
continue;
|
|
if (te->addToSpellBook)
|
|
{
|
|
refundAE += ranks * aePerRank;
|
|
refundTE += ranks * tePerRank;
|
|
}
|
|
else
|
|
refundTE += ranks * tePerRank;
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
uint8 const origSpec = pl->GetActiveSpec();
|
|
for (uint8 s = 0; s < pl->GetSpecsCount(); ++s)
|
|
{
|
|
pl->ActivateSpec(s);
|
|
pl->resetTalents(true);
|
|
}
|
|
pl->ActivateSpec(origSpec);
|
|
|
|
CharacterDatabase.DirectExecute("DELETE FROM character_paragon_panel_talents WHERE guid = {}", lowGuid);
|
|
|
|
ParagonCurrencyData& d = GetOrCreateCacheEntry(lowGuid);
|
|
d.abilityEssence += refundAE;
|
|
d.talentEssence += refundTE;
|
|
|
|
// See HandleParagonResetAbilities: detach from the active build
|
|
// so the next swap doesn't overwrite its saved recipe with the
|
|
// (post-reset) state.
|
|
SetActiveBuildId(lowGuid, 0);
|
|
|
|
SaveCurrencyToDb(pl);
|
|
PushCurrency(pl);
|
|
PushSnapshot(pl);
|
|
PushBuildCatalog(pl);
|
|
|
|
// Pet-talent cheese close: if BM was learned before this reset and
|
|
// resetTalents has now wiped it out of every spec, force a free pet
|
|
// talent respec. Skipped when the caller opted out (HandleBuildLoad
|
|
// defers this to its own post-recipe-apply check).
|
|
if (autoResetPetIfBmLost)
|
|
MaybeForcePetTalentResetForBeastMasteryLoss(pl, hadBeastMasteryPre);
|
|
|
|
LOG_INFO("module", "Paragon panel: {} reset talents (+{} AE +{} TE refund)", pl->GetName(), refundAE, refundTE);
|
|
return true;
|
|
}
|
|
|
|
bool HandleParagonResetAll(Player* pl, std::string* err)
|
|
{
|
|
std::string sub;
|
|
if (!HandleParagonResetTalents(pl, err))
|
|
return false;
|
|
if (!HandleParagonResetAbilities(pl, &sub))
|
|
{
|
|
*err = sub;
|
|
return false;
|
|
}
|
|
LOG_INFO("module", "Paragon panel: {} reset everything", pl->GetName());
|
|
return true;
|
|
}
|
|
|
|
void PushSnapshot(Player* pl)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
return;
|
|
PushSpellSnapshot(pl);
|
|
PushTalentSnapshot(pl);
|
|
}
|
|
|
|
// ============================================================================
|
|
// Build catalog (saved Character Advancement loadouts).
|
|
// ----------------------------------------------------------------------------
|
|
// See data/sql/db-characters/updates/2026_05_10_03.sql for the schema and
|
|
// the architectural overview. The "active build" pointer is a per-character
|
|
// row in `character_paragon_active_build`; if no row exists the player has
|
|
// no active build (free-floating loadout, default state).
|
|
//
|
|
// Wire format (PARAA addon channel):
|
|
//
|
|
// Q BUILDS -- request catalog
|
|
// C BUILD NEW <name>\t<icon> -- create empty build
|
|
// C BUILD SAVE_CURRENT <name>\t<icon> -- create build from current
|
|
// panel state and set active
|
|
// C BUILD EDIT <id>\t<name>\t<icon> -- rename / re-icon
|
|
// C BUILD DELETE <id> -- delete + drop parked pet;
|
|
// if <id> is the active build,
|
|
// also full panel reset (unlearn
|
|
// + AE/TE refund) like RESET ALL
|
|
// C BUILD LOAD <id> -- swap to this build
|
|
// C BUILD UNLOAD -- clear active pointer
|
|
// C BUILD IMPORT <sharecode> -- copy a shared build
|
|
// into our own catalog
|
|
//
|
|
// Server replies push `R BUILDS` after every mutation. Format:
|
|
//
|
|
// R BUILDS active=<id|->\t<id>:<haspet>:<sharecode>:<remainAE>:<remainTE>:<name>:<icon>; ...
|
|
//
|
|
// `sharecode` is a 6-character random alphanumeric token unique across
|
|
// the realm, generated at build creation. It's how players exchange
|
|
// builds: paste the code into the BuildsPane share box on a friend's
|
|
// client and the IMPORT command copies the recipe (name + icon + spell
|
|
// rows + talent rows) into the friend's catalog as a new build with a
|
|
// fresh sharecode (so the imported copy can be re-shared independently).
|
|
//
|
|
// `remainAE` / `remainTE` are SIGNED int32s representing the AE / TE
|
|
// the player would have unspent IF they loaded this build right now
|
|
// (load = refund all currently-learned panel spells/talents, then
|
|
// re-spend on the target recipe). Negative means the recipe costs
|
|
// more than the player has earned -- the client renders that case in
|
|
// red so the player knows they can't afford the load.
|
|
//
|
|
// Names and icon paths are sanitized server-side: name = ASCII printable
|
|
// up to 32 chars (no '\t', '\r', '\n', ';', ':' since those are wire
|
|
// separators); icon = filename suffix only (no slashes), capped at 64
|
|
// chars. The client renders the icon as
|
|
// "Interface\\Icons\\<icon>".
|
|
// ----------------------------------------------------------------------------
|
|
|
|
constexpr char const* kDefaultBuildIcon = "INV_Misc_QuestionMark";
|
|
constexpr std::size_t kBuildNameMaxLen = 32;
|
|
constexpr std::size_t kBuildIconMaxLen = 64;
|
|
|
|
// Share code charset: upper-case alphanumeric minus visually-ambiguous
|
|
// glyphs (I, O, 0, 1) so codes spoken aloud or copied by hand are
|
|
// unambiguous. 31 chars ^ 6 positions = ~887M unique codes; collision
|
|
// retry on insert keeps practical collision probability vanishingly
|
|
// small for any realistic per-realm catalog.
|
|
constexpr std::size_t kBuildShareCodeLen = 6;
|
|
constexpr char const kBuildShareCharset[] = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
|
|
constexpr std::size_t kBuildShareCharsetN = sizeof(kBuildShareCharset) - 1;
|
|
|
|
std::string GenerateBuildShareCode()
|
|
{
|
|
std::string code;
|
|
code.reserve(kBuildShareCodeLen);
|
|
for (std::size_t i = 0; i < kBuildShareCodeLen; ++i)
|
|
code += kBuildShareCharset[urand(0, static_cast<uint32>(kBuildShareCharsetN) - 1)];
|
|
return code;
|
|
}
|
|
|
|
// Strict whitelist on incoming `C BUILD IMPORT <code>` payloads. The
|
|
// SQL we'd feed into the lookup query interpolates the value via
|
|
// fmt::format (matching the rest of this file's style), so we vet
|
|
// length and charset up front and reject anything that isn't 6
|
|
// characters drawn from the same alphabet GenerateBuildShareCode emits.
|
|
bool IsValidShareCode(std::string const& s)
|
|
{
|
|
if (s.size() != kBuildShareCodeLen)
|
|
return false;
|
|
for (char c : s)
|
|
{
|
|
bool ok = false;
|
|
for (std::size_t i = 0; i < kBuildShareCharsetN; ++i)
|
|
{
|
|
if (c == kBuildShareCharset[i])
|
|
{
|
|
ok = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!ok)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Generate a fresh share code, retrying on collision against the
|
|
// existing rows. With a 31^6 alphabet and even 1M rows the probability
|
|
// of a single random pick colliding is < 0.001%, so 8 retries is far
|
|
// more than enough headroom; the loop is purely defensive.
|
|
std::string GenerateUniqueShareCode()
|
|
{
|
|
for (int attempt = 0; attempt < 8; ++attempt)
|
|
{
|
|
std::string code = GenerateBuildShareCode();
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT 1 FROM character_paragon_builds WHERE share_code = '{}'", code))
|
|
continue;
|
|
if (QueryResult r2 = CharacterDatabase.Query(
|
|
"SELECT 1 FROM character_paragon_build_share_archive WHERE share_code = '{}'", code))
|
|
continue;
|
|
return code;
|
|
}
|
|
// Worst-case fallback: append a numeric uniquifier from build_id
|
|
// sequence. We can't produce a guaranteed-unique 6-char code if
|
|
// ~887M codes are taken (impossible at any realistic scale), so
|
|
// collapse to the last attempt and let the unique index reject
|
|
// duplicates if the universe is broken.
|
|
return GenerateBuildShareCode();
|
|
}
|
|
|
|
// After a successful Learn All while a build is active: freeze the
|
|
// previous share_code + recipe into character_paragon_build_share_archive*
|
|
// (so Discord-posted codes keep importing that exact loadout), then
|
|
// snapshot the panel into the live build rows and assign a fresh code
|
|
// for the owner's current recipe.
|
|
void PersistActiveBuildSnapshotAfterLearnAllCommit(Player* pl, uint32 buildId)
|
|
{
|
|
if (!pl || !buildId)
|
|
return;
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
if (!BuildBelongsToPlayer(lowGuid, buildId))
|
|
return;
|
|
|
|
std::string oldCode;
|
|
if (QueryResult row = CharacterDatabase.Query(
|
|
"SELECT COALESCE(NULLIF(share_code, ''), '') AS sc "
|
|
"FROM character_paragon_builds WHERE build_id = {} AND guid = {}",
|
|
buildId, lowGuid))
|
|
oldCode = row->Fetch()[0].Get<std::string>();
|
|
|
|
if (!oldCode.empty())
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_build_share_archive_spells WHERE share_code = '{}'", oldCode);
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_build_share_archive_talents WHERE share_code = '{}'", oldCode);
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_build_share_archive WHERE share_code = '{}'", oldCode);
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT INTO character_paragon_build_share_archive (share_code, name, icon) "
|
|
"SELECT share_code, name, icon FROM character_paragon_builds "
|
|
"WHERE build_id = {} AND guid = {}", buildId, lowGuid);
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT INTO character_paragon_build_share_archive_spells (share_code, spell_id) "
|
|
"SELECT '{}', spell_id FROM character_paragon_build_spells WHERE build_id = {}",
|
|
oldCode, buildId);
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT INTO character_paragon_build_share_archive_talents (share_code, spec, talent_id, `rank`) "
|
|
"SELECT '{}', spec, talent_id, `rank` FROM character_paragon_build_talents WHERE build_id = {}",
|
|
oldCode, buildId);
|
|
}
|
|
|
|
SnapshotBuildFromCurrent(pl, buildId);
|
|
|
|
std::string const newCode = GenerateUniqueShareCode();
|
|
CharacterDatabase.DirectExecute(
|
|
"UPDATE character_paragon_builds SET share_code = '{}' WHERE build_id = {} AND guid = {}",
|
|
newCode, buildId, lowGuid);
|
|
|
|
LOG_INFO("module",
|
|
"Paragon build: {} persisted active build {} after commit (share now {})",
|
|
pl->GetName(), buildId, newCode);
|
|
}
|
|
|
|
std::string SanitizeBuildName(std::string s)
|
|
{
|
|
std::string out;
|
|
out.reserve(s.size());
|
|
for (char c : s)
|
|
{
|
|
// Reject wire separators and control characters. Keep printable
|
|
// ASCII + space; everything else dropped silently. WoW's font
|
|
// engine handles UTF-8 input but our wire format is ; : \t so
|
|
// we conservatively limit to ASCII to keep the serializer
|
|
// simple and the parser unambiguous.
|
|
if (c == '\t' || c == '\r' || c == '\n' || c == ';' || c == ':')
|
|
continue;
|
|
if (c < 0x20 || c == 0x7F)
|
|
continue;
|
|
out += c;
|
|
}
|
|
if (out.size() > kBuildNameMaxLen)
|
|
out.resize(kBuildNameMaxLen);
|
|
// Trim leading/trailing whitespace.
|
|
auto notSpace = [](unsigned char c) { return !std::isspace(c); };
|
|
auto first = std::find_if(out.begin(), out.end(), notSpace);
|
|
auto last = std::find_if(out.rbegin(), out.rend(), notSpace).base();
|
|
if (first >= last)
|
|
return std::string();
|
|
return std::string(first, last);
|
|
}
|
|
|
|
std::string SanitizeBuildIcon(std::string s)
|
|
{
|
|
std::string out;
|
|
out.reserve(s.size());
|
|
for (char c : s)
|
|
{
|
|
// Icon file paths are alnum + underscore + hyphen + dot only.
|
|
// No slashes (we always prepend "Interface\\Icons\\" client-side).
|
|
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
|
|
(c >= '0' && c <= '9') || c == '_' || c == '-' || c == '.')
|
|
out += c;
|
|
}
|
|
if (out.size() > kBuildIconMaxLen)
|
|
out.resize(kBuildIconMaxLen);
|
|
if (out.empty())
|
|
out = kDefaultBuildIcon;
|
|
return out;
|
|
}
|
|
|
|
uint32 GetActiveBuildId(uint32 lowGuid)
|
|
{
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT build_id FROM character_paragon_active_build WHERE guid = {}", lowGuid))
|
|
return r->Fetch()[0].Get<uint32>();
|
|
return 0;
|
|
}
|
|
|
|
void SetActiveBuildId(uint32 lowGuid, uint32 buildId)
|
|
{
|
|
if (buildId)
|
|
CharacterDatabase.DirectExecute(
|
|
"REPLACE INTO character_paragon_active_build (guid, build_id) VALUES ({}, {})",
|
|
lowGuid, buildId);
|
|
else
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_active_build WHERE guid = {}", lowGuid);
|
|
}
|
|
|
|
bool BuildBelongsToPlayer(uint32 lowGuid, uint32 buildId)
|
|
{
|
|
if (!buildId)
|
|
return false;
|
|
QueryResult r = CharacterDatabase.Query(
|
|
"SELECT 1 FROM character_paragon_builds WHERE build_id = {} AND guid = {}",
|
|
buildId, lowGuid);
|
|
return r != nullptr;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Cost / remaining-AE-TE helpers (used by PushBuildCatalog tooltip data).
|
|
// ----------------------------------------------------------------------------
|
|
// "Remaining if loaded" = (total earned by this player so far)
|
|
// - (cost of recipe stored in this build).
|
|
//
|
|
// The wire push computes both halves and ships the *remaining* numbers
|
|
// per build; the client just renders them. Computing total_earned from
|
|
// (current pool + currently-spent on panel) keeps us from having to
|
|
// add a dedicated "earned" counter to character_paragon_currency.
|
|
//
|
|
// Note on per-spec accuracy: character_paragon_panel_talents is keyed
|
|
// (guid, talent_id) -- it stores the highest rank in any spec, not a
|
|
// per-spec breakdown. If a Paragon char has DIFFERENT talent allocations
|
|
// in spec 0 vs spec 1 they may have paid TE multiple times for the same
|
|
// talent_id, but the "spent" walk only sees one row. This undercounts
|
|
// total_earned in that edge case, which makes "remaining if loaded"
|
|
// show conservatively LOW for builds that include cross-spec talents.
|
|
// The character_paragon_build_talents table IS keyed (build_id, spec,
|
|
// talent_id) so the BUILD cost side is always accurate. Net effect:
|
|
// the tooltip might say a build needs 2 more AE than it really does
|
|
// for a small fraction of players. That's preferable to over-promising
|
|
// and having the load fail with "not enough TE" mid-flight.
|
|
|
|
struct BuildCost
|
|
{
|
|
uint32 ae = 0;
|
|
uint32 te = 0;
|
|
};
|
|
|
|
BuildCost ComputeBuildRecipeCost(uint32 buildId)
|
|
{
|
|
BuildCost out{};
|
|
if (!buildId)
|
|
return out;
|
|
|
|
uint32 const tePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
uint32 const aePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.TalentLearnCost", 1);
|
|
|
|
// Spell side: each panel spell costs LookupSpellAECost. The recipe
|
|
// table doesn't carry rank info because PanelLearnSpellChain grants
|
|
// every higher rank of a chain in one charge, so one row = one
|
|
// chain-head buy = one cost lookup.
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT spell_id FROM character_paragon_build_spells WHERE build_id = {}",
|
|
buildId))
|
|
{
|
|
do
|
|
{
|
|
uint32 sid = r->Fetch()[0].Get<uint32>();
|
|
if (!sid)
|
|
continue;
|
|
out.ae += LookupSpellAECost(sid);
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
// Talent side: charge tePerRank * rank for every (spec, talent_id)
|
|
// row. addToSpellBook talents (the few that grant an active spell
|
|
// like Starfall / Bladestorm / Mirror Image) charge AE on top.
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT talent_id, `rank` FROM character_paragon_build_talents "
|
|
"WHERE build_id = {}", buildId))
|
|
{
|
|
do
|
|
{
|
|
Field const* f = r->Fetch();
|
|
uint32 tid = f[0].Get<uint32>();
|
|
uint32 rank = f[1].Get<uint8>();
|
|
if (!tid || !rank)
|
|
continue;
|
|
TalentEntry const* te = sTalentStore.LookupEntry(tid);
|
|
if (!te)
|
|
continue;
|
|
out.te += rank * tePerRank;
|
|
if (te->addToSpellBook)
|
|
out.ae += rank * aePerRank;
|
|
} while (r->NextRow());
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Sum the AE/TE the player has currently SPENT on panel-bought spells
|
|
// and talents. Refunding everything via Reset would return exactly this
|
|
// total to the unspent pool, so total_earned == current + spent.
|
|
BuildCost ComputeCurrentlySpentOnPanel(uint32 lowGuid)
|
|
{
|
|
BuildCost out{};
|
|
|
|
uint32 const tePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
uint32 const aePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.TalentLearnCost", 1);
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT spell_id FROM character_paragon_panel_spells WHERE guid = {}",
|
|
lowGuid))
|
|
{
|
|
do
|
|
{
|
|
uint32 sid = r->Fetch()[0].Get<uint32>();
|
|
if (!sid)
|
|
continue;
|
|
out.ae += LookupSpellAECost(sid);
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT talent_id, `rank` FROM character_paragon_panel_talents WHERE guid = {}",
|
|
lowGuid))
|
|
{
|
|
do
|
|
{
|
|
Field const* f = r->Fetch();
|
|
uint32 tid = f[0].Get<uint32>();
|
|
uint32 rank = f[1].Get<uint8>();
|
|
if (!tid || !rank)
|
|
continue;
|
|
TalentEntry const* te = sTalentStore.LookupEntry(tid);
|
|
if (!te)
|
|
continue;
|
|
out.te += rank * tePerRank;
|
|
if (te->addToSpellBook)
|
|
out.ae += rank * aePerRank;
|
|
} while (r->NextRow());
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Lazily assign share codes to any of this player's builds that still
|
|
// have a NULL share_code (rows created under the pre-2026_05_10_04
|
|
// schema). Runs at the top of every PushBuildCatalog so by the time
|
|
// the wire response is built every row has a non-NULL code. Cheap in
|
|
// steady-state -- the SELECT returns zero rows once backfilled.
|
|
void BackfillBuildShareCodes(uint32 lowGuid)
|
|
{
|
|
QueryResult r = CharacterDatabase.Query(
|
|
"SELECT build_id FROM character_paragon_builds "
|
|
"WHERE guid = {} AND (share_code IS NULL OR share_code = '')", lowGuid);
|
|
if (!r)
|
|
return;
|
|
do
|
|
{
|
|
uint32 buildId = r->Fetch()[0].Get<uint32>();
|
|
std::string code = GenerateUniqueShareCode();
|
|
CharacterDatabase.DirectExecute(
|
|
"UPDATE character_paragon_builds SET share_code = '{}' "
|
|
"WHERE build_id = {}", code, buildId);
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
void PushBuildCatalog(Player* pl)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
return;
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
BackfillBuildShareCodes(lowGuid);
|
|
|
|
uint32 const active = GetActiveBuildId(lowGuid);
|
|
|
|
// total_earned (approx) = current unspent pool + amount currently
|
|
// spent on panel learns. Refunding everything via Reset would
|
|
// return exactly the spent portion, so we model "remaining if
|
|
// loaded" as `total_earned - build_cost`. See the long comment
|
|
// on ComputeCurrentlySpentOnPanel for the per-spec edge case.
|
|
BuildCost const spent = ComputeCurrentlySpentOnPanel(lowGuid);
|
|
int64 const earnedAE = int64(GetAE(pl)) + int64(spent.ae);
|
|
int64 const earnedTE = int64(GetTE(pl)) + int64(spent.te);
|
|
|
|
std::string activeStr = active ? std::to_string(active) : std::string("-");
|
|
std::string body = fmt::format("R BUILDS active={}\t", activeStr);
|
|
|
|
if (QueryResult r = CharacterDatabase.Query(
|
|
"SELECT build_id, pet_number, share_code, name, icon "
|
|
"FROM character_paragon_builds WHERE guid = {} "
|
|
"ORDER BY build_id ASC", lowGuid))
|
|
{
|
|
bool first = true;
|
|
do
|
|
{
|
|
Field const* f = r->Fetch();
|
|
uint32 id = f[0].Get<uint32>();
|
|
bool haspet = !f[1].IsNull() && f[1].Get<uint32>() != 0;
|
|
std::string code = f[2].IsNull() ? std::string() : f[2].Get<std::string>();
|
|
std::string name = f[3].Get<std::string>();
|
|
std::string icon = f[4].Get<std::string>();
|
|
|
|
BuildCost const cost = ComputeBuildRecipeCost(id);
|
|
// Signed: negative means the recipe costs more than the
|
|
// player has earned to date (insufficient). Clamp at int32
|
|
// bounds out of paranoia though realistic catalogs stay
|
|
// far inside.
|
|
int32 const remainAE = static_cast<int32>(earnedAE - int64(cost.ae));
|
|
int32 const remainTE = static_cast<int32>(earnedTE - int64(cost.te));
|
|
|
|
if (!first)
|
|
body += ';';
|
|
first = false;
|
|
// Wire format:
|
|
// <id>:<haspet>:<sharecode>:<remainAE>:<remainTE>:<name>:<icon>
|
|
// Sharecode is always 6 chars after backfill; remainAE/TE
|
|
// are signed (formatted with %+d-equivalent via fmt's "{}",
|
|
// which renders a leading '-' for negatives and bare digits
|
|
// for non-negatives, matching the client's "%-?%d+" parse).
|
|
body += fmt::format("{}:{}:{}:{}:{}:{}:{}", id,
|
|
haspet ? 1 : 0,
|
|
code,
|
|
remainAE, remainTE,
|
|
name, icon);
|
|
} while (r->NextRow());
|
|
}
|
|
|
|
SendAddonMessage(pl, body);
|
|
}
|
|
|
|
bool HandleBuildNew(Player* pl, std::string const& payload, std::string* err)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
*err = "not a Paragon";
|
|
return false;
|
|
}
|
|
auto tab = payload.find('\t');
|
|
if (tab == std::string::npos)
|
|
{
|
|
*err = "BUILD NEW malformed";
|
|
return false;
|
|
}
|
|
std::string name = SanitizeBuildName(payload.substr(0, tab));
|
|
std::string icon = SanitizeBuildIcon(payload.substr(tab + 1));
|
|
if (name.empty())
|
|
{
|
|
*err = "build name is empty";
|
|
return false;
|
|
}
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
|
|
// Soft cap: prevent a runaway script from creating thousands of
|
|
// empty builds. 64 is far above what fits in the UI grid; the
|
|
// client also enforces its own limit based on visible cells.
|
|
if (QueryResult cnt = CharacterDatabase.Query(
|
|
"SELECT COUNT(*) FROM character_paragon_builds WHERE guid = {}", lowGuid))
|
|
{
|
|
if (cnt->Fetch()[0].Get<uint32>() >= 64)
|
|
{
|
|
*err = "build limit reached (64)";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
std::string code = GenerateUniqueShareCode();
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT INTO character_paragon_builds (guid, name, icon, share_code) "
|
|
"VALUES ({}, '{}', '{}', '{}')",
|
|
lowGuid, name, icon, code);
|
|
|
|
PushBuildCatalog(pl);
|
|
LOG_INFO("module", "Paragon build: {} created build '{}' (share code {})",
|
|
pl->GetName(), name, code);
|
|
return true;
|
|
}
|
|
|
|
// "Save current loadout as a new build". Driven by the Overview pane's
|
|
// "Save as Build" button. Equivalent to HandleBuildNew + an immediate
|
|
// SnapshotBuildFromCurrent into the new row, plus a SetActiveBuildId
|
|
// flip. Does NOT touch panel rows / currency / learned spells -- the
|
|
// player's state is already what they want, we just file it under a
|
|
// named slot. The previously-active build (if any) keeps its last
|
|
// committed recipe; loading it later restores that snapshot exactly
|
|
// as the normal swap flow does.
|
|
bool HandleBuildSaveCurrent(Player* pl, std::string const& payload, std::string* err)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
*err = "not a Paragon";
|
|
return false;
|
|
}
|
|
if (pl->IsInCombat())
|
|
{
|
|
*err = "cannot save builds while in combat";
|
|
return false;
|
|
}
|
|
auto tab = payload.find('\t');
|
|
if (tab == std::string::npos)
|
|
{
|
|
*err = "BUILD SAVE_CURRENT malformed";
|
|
return false;
|
|
}
|
|
std::string name = SanitizeBuildName(payload.substr(0, tab));
|
|
std::string icon = SanitizeBuildIcon(payload.substr(tab + 1));
|
|
if (name.empty())
|
|
{
|
|
*err = "build name is empty";
|
|
return false;
|
|
}
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
if (QueryResult cnt = CharacterDatabase.Query(
|
|
"SELECT COUNT(*) FROM character_paragon_builds WHERE guid = {}", lowGuid))
|
|
{
|
|
if (cnt->Fetch()[0].Get<uint32>() >= 64)
|
|
{
|
|
*err = "build limit reached (64)";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
std::string insertName = name;
|
|
std::string insertIcon = icon;
|
|
CharacterDatabase.EscapeString(insertName);
|
|
CharacterDatabase.EscapeString(insertIcon);
|
|
std::string const code = GenerateUniqueShareCode();
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT INTO character_paragon_builds (guid, name, icon, share_code) "
|
|
"VALUES ({}, '{}', '{}', '{}')",
|
|
lowGuid, insertName, insertIcon, code);
|
|
|
|
QueryResult idRow = CharacterDatabase.Query(
|
|
"SELECT build_id FROM character_paragon_builds "
|
|
"WHERE share_code = '{}'", code);
|
|
if (!idRow)
|
|
{
|
|
*err = "save failed (could not allocate build_id)";
|
|
return false;
|
|
}
|
|
uint32 const newBuildId = idRow->Fetch()[0].Get<uint32>();
|
|
|
|
SnapshotBuildFromCurrent(pl, newBuildId);
|
|
SetActiveBuildId(lowGuid, newBuildId);
|
|
|
|
PushBuildCatalog(pl);
|
|
LOG_INFO("module",
|
|
"Paragon build: {} saved current loadout as build {} '{}' (share {})",
|
|
pl->GetName(), newBuildId, name, code);
|
|
return true;
|
|
}
|
|
|
|
bool HandleBuildEdit(Player* pl, std::string const& payload, std::string* err)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
*err = "not a Paragon";
|
|
return false;
|
|
}
|
|
// payload is "<id>\t<name>\t<icon>"
|
|
auto t1 = payload.find('\t');
|
|
if (t1 == std::string::npos)
|
|
{
|
|
*err = "BUILD EDIT malformed";
|
|
return false;
|
|
}
|
|
auto t2 = payload.find('\t', t1 + 1);
|
|
if (t2 == std::string::npos)
|
|
{
|
|
*err = "BUILD EDIT malformed";
|
|
return false;
|
|
}
|
|
uint32 buildId = static_cast<uint32>(std::strtoul(payload.substr(0, t1).c_str(), nullptr, 10));
|
|
std::string name = SanitizeBuildName(payload.substr(t1 + 1, t2 - t1 - 1));
|
|
std::string icon = SanitizeBuildIcon(payload.substr(t2 + 1));
|
|
if (!buildId)
|
|
{
|
|
*err = "BUILD EDIT bad id";
|
|
return false;
|
|
}
|
|
if (name.empty())
|
|
{
|
|
*err = "build name is empty";
|
|
return false;
|
|
}
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
if (!BuildBelongsToPlayer(lowGuid, buildId))
|
|
{
|
|
*err = "build does not belong to player";
|
|
return false;
|
|
}
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"UPDATE character_paragon_builds SET name = '{}', icon = '{}' WHERE build_id = {}",
|
|
name, icon, buildId);
|
|
|
|
PushBuildCatalog(pl);
|
|
return true;
|
|
}
|
|
|
|
// Permanently delete a parked pet (as if the player abandoned it at the
|
|
// stable master). This is intentionally destructive -- the client warns
|
|
// the user before reaching this code path. Mirrors the engine's
|
|
// PET_SAVE_AS_DELETED behavior in DeleteFromDB but scoped to the rows
|
|
// we know about (the pet itself is unsummoned and not present in
|
|
// PetStable.CurrentPet, so this is purely a DB cleanup).
|
|
void DeleteParkedPet(uint32 lowGuid, uint32 petNumber)
|
|
{
|
|
if (!petNumber)
|
|
return;
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_pet WHERE owner = {} AND id = {}", lowGuid, petNumber);
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM pet_aura WHERE guid = {}", petNumber);
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM pet_spell WHERE guid = {}", petNumber);
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM pet_spell_cooldown WHERE guid = {}", petNumber);
|
|
}
|
|
|
|
bool HandleBuildDelete(Player* pl, std::string const& payload, std::string* err)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
*err = "not a Paragon";
|
|
return false;
|
|
}
|
|
uint32 const buildId = static_cast<uint32>(std::strtoul(payload.c_str(), nullptr, 10));
|
|
if (!buildId)
|
|
{
|
|
*err = "BUILD DELETE bad id";
|
|
return false;
|
|
}
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
|
|
// Look up parked pet (and verify ownership) in a single query.
|
|
QueryResult r = CharacterDatabase.Query(
|
|
"SELECT pet_number FROM character_paragon_builds WHERE build_id = {} AND guid = {}",
|
|
buildId, lowGuid);
|
|
if (!r)
|
|
{
|
|
*err = "build not found";
|
|
return false;
|
|
}
|
|
|
|
Field const* f = r->Fetch();
|
|
uint32 petNumber = f[0].IsNull() ? 0 : f[0].Get<uint32>();
|
|
|
|
// Deleting the *active* build is a hard reset: unlearn everything the
|
|
// Character Advancement panel bought, refund all AE/TE into the
|
|
// unspent pool, and clear the active pointer (same net effect as
|
|
// C RESET ALL). Deleting a non-active slot only removes the saved
|
|
// recipe row + any parked pet bound to that slot.
|
|
uint32 const active = GetActiveBuildId(lowGuid);
|
|
if (active == buildId)
|
|
{
|
|
std::string resetErr;
|
|
if (!HandleParagonResetAll(pl, &resetErr))
|
|
{
|
|
*err = resetErr;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_build_spells WHERE build_id = {}", buildId);
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_build_talents WHERE build_id = {}", buildId);
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_builds WHERE build_id = {} AND guid = {}",
|
|
buildId, lowGuid);
|
|
|
|
if (petNumber)
|
|
DeleteParkedPet(lowGuid, petNumber);
|
|
|
|
PushBuildCatalog(pl);
|
|
LOG_INFO("module", "Paragon build: {} deleted build {} (parked pet {})",
|
|
pl->GetName(), buildId, petNumber);
|
|
return true;
|
|
}
|
|
|
|
// Import a build from another player's catalog by share code. Copies
|
|
// the recipe (name + icon + per-spec talent rows + spell rows) into a
|
|
// new owned build for the requester with a freshly-generated share
|
|
// code. Crucially does NOT auto-load the imported build -- the player
|
|
// finds it in their catalog and clicks it like any other saved build,
|
|
// matching the "import_only" UX choice. The original build owner's
|
|
// row is untouched.
|
|
//
|
|
// Errors (sent back as "R ERR ..." for the addon channel):
|
|
// - malformed code (length / charset)
|
|
// - code not found (neither live nor archived)
|
|
// - the code points to one of the requester's own live-catalog builds
|
|
// - the requester is at the 64-build cap
|
|
bool HandleBuildImport(Player* pl, std::string const& payload, std::string* err)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
*err = "not a Paragon";
|
|
return false;
|
|
}
|
|
|
|
// Trim whitespace and uppercase the input so users don't have to
|
|
// type the code in exact case. The wire-charset is upper-only so
|
|
// forcing upper preserves the lookup hit rate even if the player
|
|
// typed a lower-case 'a'.
|
|
std::string code = payload;
|
|
auto notSpace = [](unsigned char c) { return !std::isspace(c); };
|
|
auto first = std::find_if(code.begin(), code.end(), notSpace);
|
|
auto last = std::find_if(code.rbegin(), code.rend(), notSpace).base();
|
|
code = (first < last) ? std::string(first, last) : std::string();
|
|
for (char& c : code)
|
|
c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
|
|
|
|
if (!IsValidShareCode(code))
|
|
{
|
|
*err = "share code must be 6 characters (A-Z minus I/O, 2-9)";
|
|
return false;
|
|
}
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
|
|
// Live catalog first, then retired codes frozen in
|
|
// character_paragon_build_share_archive* (same code keeps importing
|
|
// the recipe that was current when the owner last committed).
|
|
QueryResult srcRow = CharacterDatabase.Query(
|
|
"SELECT build_id, guid, name, icon "
|
|
"FROM character_paragon_builds WHERE share_code = '{}'", code);
|
|
|
|
bool fromArchive = false;
|
|
uint32 srcBuildId = 0;
|
|
uint32 srcOwner = 0;
|
|
std::string srcName;
|
|
std::string srcIcon;
|
|
|
|
if (srcRow)
|
|
{
|
|
Field const* sf = srcRow->Fetch();
|
|
srcBuildId = sf[0].Get<uint32>();
|
|
srcOwner = sf[1].Get<uint32>();
|
|
srcName = sf[2].Get<std::string>();
|
|
srcIcon = sf[3].Get<std::string>();
|
|
}
|
|
else if (QueryResult arch = CharacterDatabase.Query(
|
|
"SELECT name, icon FROM character_paragon_build_share_archive WHERE share_code = '{}'", code))
|
|
{
|
|
fromArchive = true;
|
|
Field const* af = arch->Fetch();
|
|
srcName = af[0].Get<std::string>();
|
|
srcIcon = af[1].Get<std::string>();
|
|
}
|
|
else
|
|
{
|
|
*err = "no build with that code";
|
|
return false;
|
|
}
|
|
|
|
if (!fromArchive && srcOwner == lowGuid)
|
|
{
|
|
*err = "this build is already in your catalog";
|
|
return false;
|
|
}
|
|
|
|
if (QueryResult cnt = CharacterDatabase.Query(
|
|
"SELECT COUNT(*) FROM character_paragon_builds WHERE guid = {}", lowGuid))
|
|
{
|
|
if (cnt->Fetch()[0].Get<uint32>() >= 64)
|
|
{
|
|
*err = "build limit reached (64)";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Insert the new owned build first so we have its build_id to
|
|
// attach the copied recipe rows to. Server-generated share code
|
|
// is fresh -- the imported copy can be re-shared independently.
|
|
//
|
|
// Pet handling: we deliberately do NOT copy `pet_number`. A parked
|
|
// hunter pet belongs to the source player's character and lives
|
|
// in `character_pet` under their owner guid; cloning the row
|
|
// would either steal the pet (corrupting the source player's
|
|
// stable / stable-master state) or summon a pet the importer
|
|
// can't legally own. The new row leaves `pet_number = NULL`
|
|
// (column default), so when the importer first loads this build
|
|
// and HandleBuildLoad reaches Phase 4, RestoreParkedPetForBuild
|
|
// sees NULL and no-ops -- the player must tame their own pet
|
|
// (Tame Beast comes via the recipe if the source build had it),
|
|
// and on next swap-away ParkActivePetForBuild will bind THEIR
|
|
// pet to the row exactly like a locally-created build.
|
|
std::string newCode = GenerateUniqueShareCode();
|
|
std::string insertName = srcName;
|
|
std::string insertIcon = srcIcon;
|
|
CharacterDatabase.EscapeString(insertName);
|
|
CharacterDatabase.EscapeString(insertIcon);
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT INTO character_paragon_builds (guid, name, icon, share_code) "
|
|
"VALUES ({}, '{}', '{}', '{}')",
|
|
lowGuid, insertName, insertIcon, newCode);
|
|
|
|
QueryResult idRow = CharacterDatabase.Query(
|
|
"SELECT build_id FROM character_paragon_builds "
|
|
"WHERE share_code = '{}'", newCode);
|
|
if (!idRow)
|
|
{
|
|
*err = "import failed (could not allocate build_id)";
|
|
return false;
|
|
}
|
|
uint32 newBuildId = idRow->Fetch()[0].Get<uint32>();
|
|
|
|
// Copy recipe rows row-by-row via INSERT...SELECT so we don't
|
|
// need to materialize them in C++. Using a literal `newBuildId`
|
|
// for the copy so the foreign reference is correct on the new
|
|
// owner's row.
|
|
if (!fromArchive)
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT INTO character_paragon_build_spells (build_id, spell_id) "
|
|
"SELECT {}, spell_id FROM character_paragon_build_spells WHERE build_id = {}",
|
|
newBuildId, srcBuildId);
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT INTO character_paragon_build_talents (build_id, spec, talent_id, `rank`) "
|
|
"SELECT {}, spec, talent_id, `rank` FROM character_paragon_build_talents "
|
|
"WHERE build_id = {}",
|
|
newBuildId, srcBuildId);
|
|
}
|
|
else
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT INTO character_paragon_build_spells (build_id, spell_id) "
|
|
"SELECT {}, spell_id FROM character_paragon_build_share_archive_spells "
|
|
"WHERE share_code = '{}'",
|
|
newBuildId, code);
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT INTO character_paragon_build_talents (build_id, spec, talent_id, `rank`) "
|
|
"SELECT {}, spec, talent_id, `rank` FROM character_paragon_build_share_archive_talents "
|
|
"WHERE share_code = '{}'",
|
|
newBuildId, code);
|
|
}
|
|
|
|
PushBuildCatalog(pl);
|
|
|
|
// Hunter-pet hint: imports never carry a parked pet (see comment
|
|
// before the INSERT above). If the recipe contains Tame Beast
|
|
// (spell 1515) we surface a one-line system message so the player
|
|
// knows they need to tame their own pet before that build feels
|
|
// "complete". Other classes' pet-summon spells (Summon Imp, Raise
|
|
// Dead, ...) re-summon a fresh entity each cast so they don't
|
|
// need any heads-up.
|
|
QueryResult petCheck = CharacterDatabase.Query(
|
|
"SELECT 1 FROM character_paragon_build_spells "
|
|
"WHERE build_id = {} AND spell_id = 1515 LIMIT 1", newBuildId);
|
|
if (petCheck && pl->GetSession())
|
|
{
|
|
std::string const msg = fmt::format(
|
|
"|cffffd200[Paragon]|r Imported \"{}\" includes Tame Beast. "
|
|
"Tame your own pet after loading this build -- the source "
|
|
"player's pet was not transferred.", srcName);
|
|
ChatHandler(pl->GetSession()).SendSysMessage(msg.c_str());
|
|
}
|
|
|
|
if (fromArchive)
|
|
LOG_INFO("module",
|
|
"Paragon build: {} imported archived code '{}' as new build {} (share {})",
|
|
pl->GetName(), code, newBuildId, newCode);
|
|
else
|
|
LOG_INFO("module",
|
|
"Paragon build: {} imported '{}' (src build {} owner {}) "
|
|
"as new build {} with code {}",
|
|
pl->GetName(), srcName, srcBuildId, srcOwner, newBuildId, newCode);
|
|
return true;
|
|
}
|
|
|
|
// Snapshot the player's current panel-purchased state into a build's
|
|
// recipe rows. Wipes the build's existing recipe rows first so this is
|
|
// idempotent. Reads `character_paragon_panel_spells` (already authoritative
|
|
// for purchased spells) and walks `Player::m_talents` per spec for
|
|
// purchased talents that ALSO appear in `character_paragon_panel_talents`
|
|
// (so we don't accidentally capture talents the player learned via some
|
|
// non-panel mechanism -- e.g. trainer dual-spec gift).
|
|
void SnapshotBuildFromCurrent(Player* pl, uint32 buildId)
|
|
{
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_build_spells WHERE build_id = {}", buildId);
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_build_talents WHERE build_id = {}", buildId);
|
|
|
|
if (QueryResult sp = CharacterDatabase.Query(
|
|
"SELECT spell_id FROM character_paragon_panel_spells WHERE guid = {}", lowGuid))
|
|
{
|
|
do
|
|
{
|
|
uint32 sid = sp->Fetch()[0].Get<uint32>();
|
|
CharacterDatabase.DirectExecute(
|
|
"INSERT IGNORE INTO character_paragon_build_spells (build_id, spell_id) VALUES ({}, {})",
|
|
buildId, sid);
|
|
} while (sp->NextRow());
|
|
}
|
|
|
|
// Per-spec talents: query the engine's per-spec talent state via
|
|
// ActivateSpec round-trips, intersected with the panel-bought set
|
|
// so we only record talents the player actually paid for.
|
|
std::unordered_set<uint32> panelTalents;
|
|
if (QueryResult pt = CharacterDatabase.Query(
|
|
"SELECT talent_id FROM character_paragon_panel_talents WHERE guid = {}", lowGuid))
|
|
{
|
|
do { panelTalents.insert(pt->Fetch()[0].Get<uint32>()); } while (pt->NextRow());
|
|
}
|
|
|
|
if (panelTalents.empty())
|
|
return;
|
|
|
|
uint8 const origSpec = pl->GetActiveSpec();
|
|
for (uint8 s = 0; s < pl->GetSpecsCount(); ++s)
|
|
{
|
|
if (s != origSpec)
|
|
pl->ActivateSpec(s);
|
|
// Walk PlayerTalentMap and record the rank of each panel-known
|
|
// talent. The engine stores individual rank ids in the talent
|
|
// map; we resolve back to the (talentId, rank) pair by walking
|
|
// sTalentStore.
|
|
for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
|
|
{
|
|
TalentEntry const* te = sTalentStore.LookupEntry(i);
|
|
if (!te)
|
|
continue;
|
|
if (!panelTalents.count(te->TalentID))
|
|
continue;
|
|
uint8 rank = 0;
|
|
for (int8 r = MAX_TALENT_RANK - 1; r >= 0; --r)
|
|
{
|
|
if (te->RankID[r] && pl->HasTalent(te->RankID[r], s))
|
|
{
|
|
rank = static_cast<uint8>(r + 1);
|
|
break;
|
|
}
|
|
}
|
|
if (!rank)
|
|
continue;
|
|
CharacterDatabase.DirectExecute(
|
|
"REPLACE INTO character_paragon_build_talents "
|
|
"(build_id, spec, talent_id, `rank`) VALUES ({}, {}, {}, {})",
|
|
buildId, s, te->TalentID, rank);
|
|
}
|
|
}
|
|
if (pl->GetActiveSpec() != origSpec)
|
|
pl->ActivateSpec(origSpec);
|
|
}
|
|
|
|
// Park the currently-summoned hunter pet (if any) into PET_SAVE_NOT_IN_SLOT
|
|
// and bind the resulting pet_number to `buildId` so that on swap-back the
|
|
// same pet (with its name, talents, exp) can be re-summoned. Non-hunter
|
|
// pets (warlock demon, DK ghoul, mage water elemental) are NOT parked
|
|
// because the engine re-summons those from a fresh template each cast,
|
|
// so there's nothing to preserve.
|
|
void ParkActivePetForBuild(Player* pl, uint32 buildId)
|
|
{
|
|
if (!pl || !buildId)
|
|
return;
|
|
Pet* pet = pl->GetPet();
|
|
if (!pet || pet->getPetType() != HUNTER_PET)
|
|
return;
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
uint32 const petNumber = pet->GetCharmInfo() ? pet->GetCharmInfo()->GetPetNumber() : 0;
|
|
|
|
pl->RemovePet(pet, PET_SAVE_NOT_IN_SLOT);
|
|
|
|
if (!petNumber)
|
|
return;
|
|
|
|
CharacterDatabase.DirectExecute(
|
|
"UPDATE character_paragon_builds SET pet_number = {} WHERE build_id = {}",
|
|
petNumber, buildId);
|
|
|
|
LOG_INFO("module", "Paragon build: parked pet #{} for build {} (player {})",
|
|
petNumber, buildId, lowGuid);
|
|
}
|
|
|
|
// Reverse of ParkActivePetForBuild: if `buildId` has a parked pet,
|
|
// move that pet from PET_SAVE_NOT_IN_SLOT back to PET_SAVE_AS_CURRENT
|
|
// and re-summon it next to the player. Mirrors the engine's
|
|
// HandleStableSwapPet flow (NPCHandler.cpp:576).
|
|
void RestoreParkedPetForBuild(Player* pl, uint32 buildId)
|
|
{
|
|
if (!pl || !buildId)
|
|
return;
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
|
|
QueryResult r = CharacterDatabase.Query(
|
|
"SELECT pet_number FROM character_paragon_builds WHERE build_id = {} AND guid = {}",
|
|
buildId, lowGuid);
|
|
if (!r)
|
|
return;
|
|
uint32 petNumber = r->Fetch()[0].IsNull() ? 0 : r->Fetch()[0].Get<uint32>();
|
|
if (!petNumber)
|
|
return;
|
|
|
|
// Refuse mid-combat / mid-instance restores -- these would race with
|
|
// the worldserver's spawn replication and can leave a "ghost pet"
|
|
// whose guid the client never receives. The build-load path is
|
|
// already gated on combat upstream; this is a defense-in-depth
|
|
// check.
|
|
if (pl->IsInCombat() || pl->GetMap()->IsBattlegroundOrArena())
|
|
{
|
|
LOG_INFO("module", "Paragon build: skipping pet restore for build {} (combat/arena)",
|
|
buildId);
|
|
return;
|
|
}
|
|
|
|
// If a pet is already current (shouldn't happen because the swap
|
|
// path parks first, but defensively handle), park it to NOT_IN_SLOT
|
|
// so we don't create two CurrentPet rows.
|
|
if (Pet* existing = pl->GetPet())
|
|
pl->RemovePet(existing, PET_SAVE_NOT_IN_SLOT);
|
|
|
|
// DB: flip the parked pet's slot to AS_CURRENT.
|
|
CharacterDatabase.DirectExecute(
|
|
"UPDATE character_pet SET slot = {} WHERE owner = {} AND id = {}",
|
|
static_cast<int>(PET_SAVE_AS_CURRENT), lowGuid, petNumber);
|
|
|
|
// In-memory PetStable: move the matching UnslottedPets entry into
|
|
// CurrentPet so subsequent SummonPet() calls resolve correctly.
|
|
PetStable* ps = pl->GetPetStable();
|
|
if (ps)
|
|
{
|
|
// First, if there's a stale CurrentPet from the existing-park
|
|
// step above, push it back to UnslottedPets in memory.
|
|
if (ps->CurrentPet)
|
|
{
|
|
ps->UnslottedPets.push_back(std::move(*ps->CurrentPet));
|
|
ps->CurrentPet.reset();
|
|
}
|
|
for (auto it = ps->UnslottedPets.begin(); it != ps->UnslottedPets.end(); ++it)
|
|
{
|
|
if (it->PetNumber == petNumber)
|
|
{
|
|
ps->CurrentPet = std::move(*it);
|
|
ps->UnslottedPets.erase(it);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Match HandleStableSwapPet (NPCHandler.cpp:576): when a petnumber is
|
|
// specified, the `current` flag is ignored by GetLoadPetInfo, so use
|
|
// false to mirror the engine convention.
|
|
Pet* newPet = new Pet(pl, HUNTER_PET);
|
|
if (!newPet->LoadPetFromDB(pl, 0, petNumber, false))
|
|
{
|
|
delete newPet;
|
|
// Revert DB on failure so we don't strand the pet in CURRENT.
|
|
CharacterDatabase.DirectExecute(
|
|
"UPDATE character_pet SET slot = {} WHERE owner = {} AND id = {}",
|
|
static_cast<int>(PET_SAVE_NOT_IN_SLOT), lowGuid, petNumber);
|
|
LOG_INFO("module", "Paragon build: pet restore failed for build {} pet #{}",
|
|
buildId, petNumber);
|
|
return;
|
|
}
|
|
|
|
// pet_number column on the build row is now stale (the pet is
|
|
// current, not parked). Clear it so a subsequent park can rewrite.
|
|
CharacterDatabase.DirectExecute(
|
|
"UPDATE character_paragon_builds SET pet_number = NULL WHERE build_id = {}",
|
|
buildId);
|
|
}
|
|
|
|
bool HandleBuildLoad(Player* pl, std::string const& payload, std::string* err)
|
|
{
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
*err = "not a Paragon";
|
|
return false;
|
|
}
|
|
uint32 const targetId = static_cast<uint32>(std::strtoul(payload.c_str(), nullptr, 10));
|
|
if (!targetId)
|
|
{
|
|
*err = "BUILD LOAD bad id";
|
|
return false;
|
|
}
|
|
|
|
uint32 const lowGuid = pl->GetGUID().GetCounter();
|
|
if (!BuildBelongsToPlayer(lowGuid, targetId))
|
|
{
|
|
*err = "build does not belong to player";
|
|
return false;
|
|
}
|
|
|
|
if (pl->IsInCombat())
|
|
{
|
|
*err = "cannot swap builds while in combat";
|
|
return false;
|
|
}
|
|
|
|
uint32 const activeId = GetActiveBuildId(lowGuid);
|
|
bool const sameBuild = (activeId == targetId);
|
|
|
|
// Capture pre-swap Beast Mastery state. Phase 2's reset-then-reapply
|
|
// wipes every talent before the new recipe runs, so we can't use
|
|
// HandleParagonResetTalents' built-in BM check here -- it would fire
|
|
// mid-swap before the new build's BM (if any) is re-learned. Defer
|
|
// the pet-talent reset to the very end of the swap, when the final
|
|
// talent layout is committed (see Phase 5 below).
|
|
bool const hadBeastMasteryPreSwap = HasBeastMasteryInAnySpec(pl);
|
|
|
|
// -------------------------------------------------------------
|
|
// Phase 1: snapshot + park the current build's state.
|
|
//
|
|
// Cross-build swap: capture the outgoing build's panel state into
|
|
// its recipe rows so swapping back later restores it; park any
|
|
// active hunter pet so we can re-summon the same instance.
|
|
//
|
|
// Same-build "revert": skip the snapshot (we WANT the saved
|
|
// recipe to remain authoritative -- this command's whole purpose
|
|
// is to discard pending edits), but still park the pet so the
|
|
// reset+re-spend cycle below doesn't destroy it.
|
|
// -------------------------------------------------------------
|
|
if (activeId)
|
|
{
|
|
if (!sameBuild)
|
|
SnapshotBuildFromCurrent(pl, activeId);
|
|
ParkActivePetForBuild(pl, activeId);
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// Phase 2: reset all panel-bought spells/talents (refunds AE/TE
|
|
// through the existing reset path). autoResetPetIfBmLost=false
|
|
// because we're going to re-learn BM in Phase 3 if the new recipe
|
|
// includes it -- the BM-loss check is deferred to Phase 5.
|
|
// -------------------------------------------------------------
|
|
std::string sub;
|
|
if (!HandleParagonResetTalents(pl, &sub, /*autoResetPetIfBmLost=*/false))
|
|
{
|
|
*err = sub;
|
|
return false;
|
|
}
|
|
if (!HandleParagonResetAbilities(pl, &sub))
|
|
{
|
|
*err = sub;
|
|
return false;
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// Phase 3: re-spend AE/TE on the target build's recipe.
|
|
// ParagonResetAbilities/Talents above already set the active
|
|
// build pointer to "wiped" by removing all panel rows, but it
|
|
// hasn't touched character_paragon_active_build. We update it
|
|
// last (after success) so a partial failure leaves the player
|
|
// in "no active build" state with refunded currency.
|
|
// -------------------------------------------------------------
|
|
|
|
// Recipe spells: reuse PanelLearnSpellChain to drive the same
|
|
// commit path as the panel UI -- it inserts character_paragon_panel_spells
|
|
// / panel_spell_children / panel_spell_revoked rows internally. We
|
|
// explicitly TrySpendAE before each chain since PanelLearnSpellChain
|
|
// does NOT debit currency on its own (matches HandleCommit's pattern).
|
|
std::vector<uint32> recipeSpells;
|
|
if (QueryResult sp = CharacterDatabase.Query(
|
|
"SELECT spell_id FROM character_paragon_build_spells WHERE build_id = {}",
|
|
targetId))
|
|
{
|
|
do { recipeSpells.push_back(sp->Fetch()[0].Get<uint32>()); }
|
|
while (sp->NextRow());
|
|
}
|
|
|
|
// Recipe talents: collected up front so we can pre-flight AE+TE.
|
|
uint32 const tePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
uint32 const aePerRank = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.TalentLearnCost", 1);
|
|
|
|
struct RecipeTalent { uint8 spec; uint32 tid; uint8 rank; };
|
|
std::vector<RecipeTalent> recipeTalents;
|
|
uint32 talentTeCost = 0;
|
|
uint32 talentAeCost = 0;
|
|
if (QueryResult pt = CharacterDatabase.Query(
|
|
"SELECT spec, talent_id, `rank` FROM character_paragon_build_talents "
|
|
"WHERE build_id = {} ORDER BY spec ASC, talent_id ASC", targetId))
|
|
{
|
|
do
|
|
{
|
|
Field const* f = pt->Fetch();
|
|
RecipeTalent rt{ f[0].Get<uint8>(), f[1].Get<uint32>(), f[2].Get<uint8>() };
|
|
TalentEntry const* te = sTalentStore.LookupEntry(rt.tid);
|
|
if (!te || !rt.rank)
|
|
continue;
|
|
recipeTalents.push_back(rt);
|
|
talentTeCost += static_cast<uint32>(rt.rank) * tePerRank;
|
|
if (te->addToSpellBook)
|
|
talentAeCost += static_cast<uint32>(rt.rank) * aePerRank;
|
|
} while (pt->NextRow());
|
|
}
|
|
|
|
uint32 spellAeCost = 0;
|
|
for (uint32 sid : recipeSpells)
|
|
spellAeCost += LookupSpellAECost(sid);
|
|
|
|
uint32 const totalAe = spellAeCost + talentAeCost;
|
|
if (GetAE(pl) < totalAe)
|
|
{
|
|
*err = fmt::format("not enough AE to load build (need {} have {})",
|
|
totalAe, GetAE(pl));
|
|
SetActiveBuildId(lowGuid, 0);
|
|
SaveCurrencyToDb(pl);
|
|
PushCurrency(pl);
|
|
PushSnapshot(pl);
|
|
PushBuildCatalog(pl);
|
|
return false;
|
|
}
|
|
if (GetTE(pl) < talentTeCost)
|
|
{
|
|
*err = fmt::format("not enough TE to load build (need {} have {})",
|
|
talentTeCost, GetTE(pl));
|
|
SetActiveBuildId(lowGuid, 0);
|
|
SaveCurrencyToDb(pl);
|
|
PushCurrency(pl);
|
|
PushSnapshot(pl);
|
|
PushBuildCatalog(pl);
|
|
return false;
|
|
}
|
|
|
|
// Apply spells (TrySpendAE per chain mirrors HandleCommit; the
|
|
// PanelLearnSpellChain call records DB rows for us).
|
|
for (uint32 sid : recipeSpells)
|
|
{
|
|
uint32 cost = LookupSpellAECost(sid);
|
|
if (!TrySpendAE(pl, cost))
|
|
break;
|
|
PanelLearnSpellChain(pl, sid);
|
|
}
|
|
|
|
// Apply talents per spec. OnPlayerLearnTalents (this same script)
|
|
// debits TE per rank and AE+TE for addToSpellBook talents -- so we
|
|
// do NOT pre-deduct currency here, only invoke LearnTalent.
|
|
if (!recipeTalents.empty())
|
|
{
|
|
uint8 const origSpec = pl->GetActiveSpec();
|
|
uint8 lastSpec = 0xFF;
|
|
for (RecipeTalent const& rt : recipeTalents)
|
|
{
|
|
if (rt.spec != lastSpec)
|
|
{
|
|
pl->ActivateSpec(rt.spec);
|
|
lastSpec = rt.spec;
|
|
}
|
|
for (uint8 r = 0; r < rt.rank; ++r)
|
|
pl->LearnTalent(rt.tid, r, /*command=*/true);
|
|
// Mirror HandleCommit's panel-talent persistence (the
|
|
// OnPlayerLearnTalents hook spends currency but does NOT
|
|
// write to character_paragon_panel_talents).
|
|
DbUpsertPanelTalent(lowGuid, rt.tid, rt.rank);
|
|
}
|
|
if (pl->GetActiveSpec() != origSpec)
|
|
pl->ActivateSpec(origSpec);
|
|
}
|
|
|
|
SetActiveBuildId(lowGuid, targetId);
|
|
SaveCurrencyToDb(pl);
|
|
PushCurrency(pl);
|
|
PushSnapshot(pl);
|
|
|
|
// -------------------------------------------------------------
|
|
// Phase 4: restore the target build's parked pet (if any).
|
|
// -------------------------------------------------------------
|
|
RestoreParkedPetForBuild(pl, targetId);
|
|
|
|
PushBuildCatalog(pl);
|
|
|
|
// -------------------------------------------------------------
|
|
// Phase 5: cross-swap cleanup.
|
|
//
|
|
// - Pet-talent cheese close. We deferred this from Phase 2 so the
|
|
// check sees the FINAL talent layout. ResetPetTalents requires a
|
|
// summoned hunter pet, which is why this runs AFTER Phase 4's
|
|
// RestoreParkedPetForBuild (so the parked pet is back when we
|
|
// check) -- otherwise a player swapping into a non-BM build with
|
|
// a parked-while-summoned BM pet would skip the reset and arrive
|
|
// at the new build with stale +4 pet talents allocated.
|
|
//
|
|
// - Self-cast aura sweep. The build swap is meant to be a clean
|
|
// state transition; any buff the player cast on themselves
|
|
// before the swap drops here. Closes the Power-Word:-Fortitude
|
|
// style cheese vector for buffs whose source spell is in the
|
|
// OUTGOING recipe but not the INCOMING one (per-spell unlearns
|
|
// during Phase 2 already drop their auras, but this makes the
|
|
// overall semantic predictable for the whole swap).
|
|
// -------------------------------------------------------------
|
|
MaybeForcePetTalentResetForBeastMasteryLoss(pl, hadBeastMasteryPreSwap);
|
|
SweepSelfCastSpellAuras(pl);
|
|
|
|
LOG_INFO("module", "Paragon build: {} {} build {}",
|
|
pl->GetName(), sameBuild ? "reverted to snapshot of" : "loaded", targetId);
|
|
return true;
|
|
}
|
|
|
|
class Paragon_Essence_PlayerScript : public PlayerScript
|
|
{
|
|
public:
|
|
Paragon_Essence_PlayerScript() : PlayerScript("Paragon_Essence_PlayerScript", {
|
|
PLAYERHOOK_ON_LOGIN,
|
|
PLAYERHOOK_ON_LOGOUT,
|
|
PLAYERHOOK_ON_SAVE,
|
|
PLAYERHOOK_ON_CREATE,
|
|
PLAYERHOOK_ON_LEVEL_CHANGED,
|
|
PLAYERHOOK_CAN_LEARN_TALENT,
|
|
PLAYERHOOK_ON_PLAYER_LEARN_TALENTS,
|
|
PLAYERHOOK_ON_BEFORE_SEND_CHAT_MESSAGE
|
|
}) { }
|
|
|
|
void OnPlayerLogin(Player* player) override
|
|
{
|
|
LoadCurrencyFromDb(player);
|
|
// Verify AE/TE matches what the player's level + panel spend
|
|
// permit. Self-heals admin / crash drift in either direction
|
|
// and is a no-op (just two small SELECTs) when the balance is
|
|
// already correct. Has to run BEFORE PushCurrency so the
|
|
// client's first balance update of the session is the
|
|
// reconciled one.
|
|
ReconcileEssenceForPlayer(player);
|
|
PushCurrency(player);
|
|
PushSnapshot(player);
|
|
PushBuildCatalog(player);
|
|
|
|
// AC's character load sequence runs _LoadSkills (which fires
|
|
// learnSkillRewardedSpells) and _LoadSpells before this hook,
|
|
// so any active dependents we revoked at panel-commit time
|
|
// (Blood Presence / Death Coil / Death Grip / ...) have been
|
|
// silently re-granted by the skill cascade. Walk our persisted
|
|
// revoke list and remove them again.
|
|
//
|
|
// `removeSpell` triggers SMSG_REMOVED_SPELL on the client which
|
|
// generates "You have unlearned X" CHAT_MSG_SYSTEM toasts. The
|
|
// chat frame buffers system messages while the loading screen
|
|
// is up and only flushes them after PLAYER_ENTERING_WORLD, so
|
|
// a paired OPEN/CLOSE we send here would already be CLOSED by
|
|
// the time those buffered toasts reach the filter. We open the
|
|
// silence window from the server side as a defensive measure,
|
|
// but rely on the client to keep the window open across the
|
|
// login flush via its own PA.Silence:Open({}) call in the
|
|
// PLAYER_LOGIN handler. The window auto-closes via the addon's
|
|
// fail-open timer (PA.Silence.WINDOW_SECONDS).
|
|
if (player && player->getClass() == CLASS_PARAGON
|
|
&& sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
{
|
|
std::vector<std::pair<uint32, uint32>> emptySpells;
|
|
std::vector<std::pair<uint32, uint32>> emptyTalents;
|
|
SendSilenceOpenForCommit(player, emptySpells, emptyTalents);
|
|
|
|
uint32 const lowGuid = player->GetGUID().GetCounter();
|
|
|
|
// Step 1: explicit per-row revoke pass. Cheap — just walks the
|
|
// persisted revoke table — and the only step that catches
|
|
// (active dep, parent) rows the diff recorded at commit time.
|
|
RevokeBlockedSpellsForPlayer(player);
|
|
|
|
// Step 2: legacy passive-attach migration. MUST run before the
|
|
// scoped sweep so any cascade re-fire from `learnSpell` here
|
|
// (Blood Presence / Death Coil / Forceful Deflection / ...)
|
|
// is caught by Step 3 instead of leaking into the spellbook.
|
|
//
|
|
// 2a) A brief intermediate build of mod-paragon attached the
|
|
// on-target *debuff* IDs (55078 / 55095) as panel children
|
|
// of Plague Strike / Icy Touch. Those debuff rows render
|
|
// as castable spellbook icons because they aren't passive
|
|
// in Spell.dbc. Drop the panel_spell_children row and
|
|
// unlearn the debuff. No-op for unaffected characters.
|
|
struct LegacyBad { uint32 parent; uint32 child; };
|
|
static LegacyBad const kLegacy[] = {
|
|
{ 45462, 55078 },
|
|
{ 45477, 55095 },
|
|
};
|
|
for (auto const& lb : kLegacy)
|
|
{
|
|
if (CharacterDatabase.Query(
|
|
"SELECT 1 FROM character_paragon_panel_spell_children "
|
|
"WHERE guid = {} AND parent_spell_id = {} AND child_spell_id = {} LIMIT 1",
|
|
lowGuid, lb.parent, lb.child))
|
|
{
|
|
CharacterDatabase.DirectExecute(
|
|
"DELETE FROM character_paragon_panel_spell_children "
|
|
"WHERE guid = {} AND parent_spell_id = {} AND child_spell_id = {}",
|
|
lowGuid, lb.parent, lb.child);
|
|
if (player->HasSpell(lb.child))
|
|
player->removeSpell(lb.child, SPEC_MASK_ALL, false);
|
|
LOG_INFO("module",
|
|
"Paragon panel: stripped legacy debuff-as-passive {} (parent {}) for {}",
|
|
lb.child, lb.parent, player->GetName());
|
|
}
|
|
}
|
|
// 2b) Re-attach the correct passive spellbook entries for any
|
|
// panel-purchased parent that is missing them. After the
|
|
// class-skill cascade guard in
|
|
// Player::learnSkillRewardedSpells, the cascade no longer
|
|
// fires for Paragons, so these attachments are the ONLY
|
|
// source for the disease passive icons (Blood Plague /
|
|
// Frost Fever) and the small DK weapon passives (Forceful
|
|
// Deflection from Blood Strike, Runic Focus from Icy
|
|
// Touch). Existing characters predating the guard may
|
|
// have FD/RF in their spellbook from the cascade but no
|
|
// panel_spell_children row tying them to the parent;
|
|
// re-running learnSpell when they already have the spell
|
|
// just records the child row and is a no-op otherwise.
|
|
struct LegacyFix { uint32 parent; uint32 correctChild; };
|
|
static LegacyFix const kFixup[] = {
|
|
{ 45462, 59879 }, // Plague Strike -> Blood Plague (passive)
|
|
{ 45477, 59921 }, // Icy Touch -> Frost Fever (passive)
|
|
{ 45477, 61455 }, // Icy Touch -> Runic Focus
|
|
{ 45902, 49410 }, // Blood Strike -> Forceful Deflection
|
|
|
|
// Runeforging -> 8 basic rune-enchants. Mirror of
|
|
// PanelLearnSpellChain::kAttached: the SLA rows for
|
|
// these (skill 776) ship with AcquireMethod=0 so the
|
|
// engine's normal cascade never grants them, and for
|
|
// the substitute Lua runeforging UI to actually be
|
|
// able to cast them HasActiveSpell needs to return
|
|
// true. Existing Paragon characters that bought
|
|
// Runeforging before this fix landed get them
|
|
// retro-granted on their next login.
|
|
{ 53428, 53344 }, // Runeforging -> Fallen Crusader
|
|
{ 53428, 53343 }, // Runeforging -> Razorice
|
|
{ 53428, 53341 }, // Runeforging -> Cinderglacier
|
|
{ 53428, 53331 }, // Runeforging -> Lichbane
|
|
{ 53428, 53342 }, // Runeforging -> Spellshattering
|
|
{ 53428, 53323 }, // Runeforging -> Swordshattering
|
|
{ 53428, 54447 }, // Runeforging -> Spellbreaking
|
|
{ 53428, 54446 }, // Runeforging -> Swordbreaking
|
|
};
|
|
for (auto const& lf : kFixup)
|
|
{
|
|
if (!CharacterDatabase.Query(
|
|
"SELECT 1 FROM character_paragon_panel_spells "
|
|
"WHERE guid = {} AND spell_id = {} LIMIT 1",
|
|
lowGuid, lf.parent))
|
|
continue;
|
|
if (player->HasSpell(lf.correctChild))
|
|
{
|
|
DbInsertPanelSpellChild(lowGuid, lf.parent, lf.correctChild);
|
|
continue;
|
|
}
|
|
player->learnSpell(lf.correctChild, false);
|
|
DbInsertPanelSpellChild(lowGuid, lf.parent, lf.correctChild);
|
|
std::unordered_set<uint32> chain;
|
|
CollectSpellChainIds(lf.correctChild, chain);
|
|
if (chain.empty())
|
|
chain.insert(lf.correctChild);
|
|
DbDeletePanelSpellRevokedForChain(lowGuid, chain);
|
|
}
|
|
|
|
// Step 3: scoped sweep across SkillLines we activated via panel
|
|
// purchases. Final pass — catches every cascade leak: those
|
|
// the commit-time diff missed, those re-fired by `_LoadSkills`,
|
|
// AND those re-fired by Step 2's legacy `learnSpell` calls.
|
|
// Only walks SkillLines we activated, so racials / weapon
|
|
// skills / Defense are never touched.
|
|
RevokeUnwantedCascadeSpellsForPlayer(player);
|
|
|
|
// Step 4: Blood Elf only -- strip rogue/DK Arcane Torrent
|
|
// clones (skill-line overlay taught all three; see
|
|
// 2026_05_10_03.sql).
|
|
RevokeDuplicateBloodElfArcaneTorrent(player);
|
|
|
|
// Intentionally NOT calling SendSilenceClose here -- the chat
|
|
// frame buffers system messages during the loading screen and
|
|
// would flush them after the CLOSE arrives. The addon's
|
|
// fail-open timer (8s) closes the window after the flush.
|
|
}
|
|
}
|
|
|
|
void OnPlayerLogout(Player* player) override
|
|
{
|
|
SaveCurrencyToDb(player);
|
|
RemoveCacheEntry(player->GetGUID().GetCounter());
|
|
}
|
|
|
|
void OnPlayerSave(Player* player) override
|
|
{
|
|
SaveCurrencyToDb(player);
|
|
}
|
|
|
|
void OnPlayerCreate(Player* player) override
|
|
{
|
|
if (!player || player->getClass() != CLASS_PARAGON)
|
|
return;
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
return;
|
|
|
|
uint32 const lowGuid = player->GetGUID().GetCounter();
|
|
uint32 const ae = ComputeStartingAE(player->GetLevel());
|
|
uint32 const te = ComputeStartingTE(player->GetLevel());
|
|
DbUpsertCurrency(lowGuid, ae, te);
|
|
ParagonCurrencyData& d = GetOrCreateCacheEntry(lowGuid);
|
|
d.abilityEssence = ae;
|
|
d.talentEssence = te;
|
|
// Player isn't fully in-world here; OnPlayerLogin will push.
|
|
}
|
|
|
|
void OnPlayerLevelChanged(Player* player, uint8 /*oldLevel*/) override
|
|
{
|
|
if (!player || player->getClass() != CLASS_PARAGON)
|
|
return;
|
|
|
|
// Cache is authoritative once OnPlayerLogin loaded it; reloading
|
|
// from DB here would clobber any AE/TE the player has spent since
|
|
// the last save (e.g., panel Lock-In followed by a level-up before
|
|
// the next OnPlayerSave tick), effectively refunding the spend.
|
|
// Hydrate ONLY if the cache is unexpectedly empty.
|
|
uint32 const lowGuid = player->GetGUID().GetCounter();
|
|
if (gParagonCurrencyCache.find(lowGuid) == gParagonCurrencyCache.end())
|
|
LoadCurrencyFromDb(player);
|
|
|
|
// Single source of truth: ComputeStartingAE/TE(newLevel) - spent.
|
|
// Subsumes the old GrantLevelUpEssence per-level delta AND catches
|
|
// drift in both directions (cheese clamp + restore-from-loss).
|
|
// SaveCurrencyToDb runs inside Reconcile when drift is detected;
|
|
// call it once more here so a no-drift level-up still flushes any
|
|
// pending cache changes from this session.
|
|
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
|
|
{
|
|
if (!player || player->getClass() != CLASS_PARAGON)
|
|
return true;
|
|
|
|
if (!talent)
|
|
return false;
|
|
|
|
uint32 const minLevelForTier = 10u + talent->Row * 5u;
|
|
if (player->GetLevel() < minLevelForTier)
|
|
return false;
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
return true;
|
|
|
|
// addToSpellBook talents cost both AE and TE per rank.
|
|
if (talent->addToSpellBook)
|
|
{
|
|
uint32 const aeCost = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.TalentLearnCost", 1);
|
|
uint32 const teCost = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
return GetAE(player) >= aeCost && GetTE(player) >= teCost;
|
|
}
|
|
uint32 const cost = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
return GetTE(player) >= cost;
|
|
}
|
|
|
|
// ParagonAdvancement addon -> server: addon-channel chat from a Paragon
|
|
// player that begins with our PARAA prefix is treated as a control
|
|
// request. Supported requests:
|
|
// "Q CURRENCY" -- push R CURRENCY back to refresh bars
|
|
// "Q SNAPSHOT" -- push R SPELLS and R TALENTS for Overview
|
|
// "C COMMIT s:... t:..." -- apply pending learns from the panel
|
|
// "C RESET ABILITIES" / "C RESET TALENTS" / "C RESET ALL" / "C RESET EVERYTHING"
|
|
// "C RESET PET TALENTS" -- free + instant pet talent reset (no popup,
|
|
// no gold). Routes to Player::ResetPetTalents
|
|
// which itself calls Pet::resetTalents and
|
|
// refreshes the talent points.
|
|
void OnPlayerBeforeSendChatMessage(Player* player, uint32& /*type*/, uint32& lang, std::string& msg) override
|
|
{
|
|
if (!player || player->getClass() != CLASS_PARAGON)
|
|
return;
|
|
if (lang != LANG_ADDON)
|
|
return;
|
|
|
|
std::string const expectedPrefix = std::string(kAddonPrefix) + "\t";
|
|
if (msg.compare(0, expectedPrefix.size(), expectedPrefix) != 0)
|
|
return;
|
|
|
|
std::string body = msg.substr(expectedPrefix.size());
|
|
|
|
if (body == "Q CURRENCY")
|
|
{
|
|
PushCurrency(player);
|
|
return;
|
|
}
|
|
if (body == "Q SNAPSHOT")
|
|
{
|
|
PushSnapshot(player);
|
|
return;
|
|
}
|
|
|
|
// Combat lockdown: any mutating control message ("C ...") is
|
|
// rejected while the player is in combat. The client also
|
|
// self-gates the buttons that would emit these (see
|
|
// ParagonAdvancement.lua), but the authoritative check lives
|
|
// here so a hand-crafted addon message can't bypass it.
|
|
// Read-only "Q ..." queries above are allowed in combat so
|
|
// the panel can keep its currency / snapshot displays current.
|
|
if (!body.empty() && body[0] == 'C' && player->IsInCombat())
|
|
{
|
|
SendAddonMessage(player,
|
|
"R ERR cannot use Character Advancement while in combat");
|
|
return;
|
|
}
|
|
|
|
if (body.compare(0, 9, "C COMMIT ") == 0)
|
|
{
|
|
std::string err;
|
|
if (HandleCommit(player, body, &err))
|
|
{
|
|
SendAddonMessage(player, fmt::format("R OK {} {}", GetAE(player), GetTE(player)));
|
|
PushCurrency(player);
|
|
PushSnapshot(player);
|
|
|
|
// If the player has a build loaded, the commit just
|
|
// mutated their panel state -- archive the previous
|
|
// share_code + recipe (so old Discord codes still
|
|
// import that frozen loadout), snapshot the new panel
|
|
// into the live build, assign a fresh share_code for
|
|
// the new recipe, and re-push the catalog.
|
|
uint32 const lowGuid = player->GetGUID().GetCounter();
|
|
uint32 const activeId = GetActiveBuildId(lowGuid);
|
|
if (activeId)
|
|
{
|
|
PersistActiveBuildSnapshotAfterLearnAllCommit(player, activeId);
|
|
PushBuildCatalog(player);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SendAddonMessage(player, "R ERR " + err);
|
|
LOG_INFO("module", "Paragon commit rejected for player {}: {}",
|
|
player->GetName(), err);
|
|
}
|
|
return;
|
|
}
|
|
if (body == "C RESET ABILITIES")
|
|
{
|
|
std::string err;
|
|
if (!HandleParagonResetAbilities(player, &err))
|
|
SendAddonMessage(player, "R ERR " + err);
|
|
return;
|
|
}
|
|
if (body == "C RESET TALENTS")
|
|
{
|
|
std::string err;
|
|
if (!HandleParagonResetTalents(player, &err))
|
|
SendAddonMessage(player, "R ERR " + err);
|
|
return;
|
|
}
|
|
if (body == "C RESET ALL" || body == "C RESET EVERYTHING")
|
|
{
|
|
std::string err;
|
|
if (!HandleParagonResetAll(player, &err))
|
|
SendAddonMessage(player, "R ERR " + err);
|
|
return;
|
|
}
|
|
// ---------------------------------------------------------------
|
|
// Build catalog (saved Character Advancement loadouts).
|
|
// See PushBuildCatalog / HandleBuild* near the top of this file
|
|
// for wire format and behavior.
|
|
// ---------------------------------------------------------------
|
|
if (body == "Q BUILDS")
|
|
{
|
|
PushBuildCatalog(player);
|
|
return;
|
|
}
|
|
if (body.compare(0, 12, "C BUILD NEW ") == 0)
|
|
{
|
|
std::string err;
|
|
if (!HandleBuildNew(player, body.substr(12), &err))
|
|
SendAddonMessage(player, "R ERR " + err);
|
|
return;
|
|
}
|
|
if (body.compare(0, 21, "C BUILD SAVE_CURRENT ") == 0)
|
|
{
|
|
std::string err;
|
|
if (!HandleBuildSaveCurrent(player, body.substr(21), &err))
|
|
SendAddonMessage(player, "R ERR " + err);
|
|
return;
|
|
}
|
|
if (body.compare(0, 13, "C BUILD EDIT ") == 0)
|
|
{
|
|
std::string err;
|
|
if (!HandleBuildEdit(player, body.substr(13), &err))
|
|
SendAddonMessage(player, "R ERR " + err);
|
|
return;
|
|
}
|
|
if (body.compare(0, 15, "C BUILD DELETE ") == 0)
|
|
{
|
|
std::string err;
|
|
if (!HandleBuildDelete(player, body.substr(15), &err))
|
|
SendAddonMessage(player, "R ERR " + err);
|
|
return;
|
|
}
|
|
if (body.compare(0, 15, "C BUILD IMPORT ") == 0)
|
|
{
|
|
std::string err;
|
|
if (!HandleBuildImport(player, body.substr(15), &err))
|
|
SendAddonMessage(player, "R ERR " + err);
|
|
return;
|
|
}
|
|
if (body.compare(0, 13, "C BUILD LOAD ") == 0)
|
|
{
|
|
std::string err;
|
|
if (!HandleBuildLoad(player, body.substr(13), &err))
|
|
SendAddonMessage(player, "R ERR " + err);
|
|
return;
|
|
}
|
|
// "C BUILD UNLOAD" -- clears the active-build pointer without
|
|
// touching learned spells/talents or parking pets. Recovery
|
|
// path for a stale active pointer (e.g. a load that was
|
|
// interrupted between Phase 3 and Phase 4 in HandleBuildLoad,
|
|
// leaving the row pointing at a build whose recipe was already
|
|
// re-applied). Player retains current learns; the catalog push
|
|
// refreshes the UI so the "Active" glow + tooltip clear.
|
|
if (body == "C BUILD UNLOAD")
|
|
{
|
|
if (player->getClass() != CLASS_PARAGON)
|
|
return;
|
|
uint32 const lowGuid = player->GetGUID().GetCounter();
|
|
SetActiveBuildId(lowGuid, 0);
|
|
PushBuildCatalog(player);
|
|
return;
|
|
}
|
|
|
|
if (body == "C RESET PET TALENTS")
|
|
{
|
|
// Pet talent reset: deliberately bypasses the engine's
|
|
// gold-cost confirmation flow. Player::ResetPetTalents
|
|
// wraps Pet::resetTalents (which only refunds and unlearns;
|
|
// does NOT charge gold or dismiss the pet) and re-sends the
|
|
// talent UI to the client. Pre-conditions:
|
|
// - the player must own a HUNTER_PET (the only pet kind
|
|
// with a talent tree in 3.3.5)
|
|
// - the pet must have spent at least 1 talent point
|
|
// If either fails Player::ResetPetTalents returns silently;
|
|
// we ack with R OK so the client UI can refresh either way.
|
|
Pet* pet = player->GetPet();
|
|
if (!pet || pet->getPetType() != HUNTER_PET)
|
|
{
|
|
SendAddonMessage(player,
|
|
"R ERR No active hunter pet to reset.");
|
|
return;
|
|
}
|
|
player->ResetPetTalents();
|
|
SendAddonMessage(player, "R OK PET TALENTS RESET");
|
|
return;
|
|
}
|
|
}
|
|
|
|
void OnPlayerLearnTalents(Player* player, uint32 talentId, uint32 /*talentRank*/, uint32 /*spellid*/) override
|
|
{
|
|
if (!player || player->getClass() != CLASS_PARAGON)
|
|
return;
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
return;
|
|
|
|
TalentEntry const* talent = sTalentStore.LookupEntry(talentId);
|
|
bool const dualCost = talent && talent->addToSpellBook;
|
|
|
|
if (dualCost)
|
|
{
|
|
uint32 const aeCost = sConfigMgr->GetOption<uint32>("Paragon.Currency.AE.TalentLearnCost", 1);
|
|
uint32 const teCost = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
if (!TrySpendTE(player, teCost))
|
|
{
|
|
LOG_ERROR("module",
|
|
"Paragon TE spend failed post-learn for talent {} (player {}) — currency desync?",
|
|
talentId, player->GetName());
|
|
return;
|
|
}
|
|
if (!TrySpendAE(player, aeCost))
|
|
{
|
|
ParagonCurrencyData& d = GetOrCreateCacheEntry(player->GetGUID().GetCounter());
|
|
d.talentEssence += teCost;
|
|
SaveCurrencyToDb(player);
|
|
PushCurrency(player);
|
|
LOG_ERROR("module",
|
|
"Paragon AE spend failed post-learn for talent {} (player {}) — refunded TE; currency desync?",
|
|
talentId, player->GetName());
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uint32 const cost = sConfigMgr->GetOption<uint32>("Paragon.Currency.TE.TalentLearnCost", 1);
|
|
if (!TrySpendTE(player, cost))
|
|
{
|
|
LOG_ERROR("module",
|
|
"Paragon TE spend failed post-learn for talent {} (player {}) — currency desync?",
|
|
talentId, player->GetName());
|
|
return;
|
|
}
|
|
}
|
|
PushCurrency(player);
|
|
}
|
|
};
|
|
|
|
class Paragon_Essence_CommandScript : public CommandScript
|
|
{
|
|
public:
|
|
Paragon_Essence_CommandScript() : CommandScript("Paragon_Essence_CommandScript") { }
|
|
|
|
ChatCommandTable GetCommands() const override
|
|
{
|
|
static ChatCommandTable paragonSubTable =
|
|
{
|
|
{ "currency", HandleCurrency, rbac::RBAC_PERM_COMMAND_LEARN, Console::No },
|
|
{ "learn", HandleLearn, rbac::RBAC_PERM_COMMAND_LEARN, Console::No },
|
|
{ "runes", HandleRunes, rbac::RBAC_PERM_COMMAND_LEARN, Console::No },
|
|
{ "hat", HandleHat, rbac::RBAC_PERM_COMMAND_LEARN, Console::No },
|
|
{ "recalibrate", HandlePanelRecalibrate, rbac::RBAC_PERM_COMMAND_MODIFY, Console::No },
|
|
};
|
|
|
|
static ChatCommandTable commandTable =
|
|
{
|
|
{ "paragon", paragonSubTable },
|
|
};
|
|
|
|
return commandTable;
|
|
}
|
|
|
|
// Full Character Advancement reset for the selected player (or self):
|
|
// unlearn all panel spells/talents, clear panel DB + active build pointer,
|
|
// then clamp AE/TE to the level-correct totals (same math as login
|
|
// reconciliation). Does not delete saved build catalog rows — only
|
|
// clears the active build link like RESET ALL from the addon.
|
|
static bool HandlePanelRecalibrate(ChatHandler* handler)
|
|
{
|
|
Player* target = handler->getSelectedPlayerOrSelf();
|
|
if (!target || target->getClass() != CLASS_PARAGON)
|
|
{
|
|
handler->SendErrorMessage("Target must be a Paragon character.", false);
|
|
return false;
|
|
}
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
{
|
|
handler->SendErrorMessage("Paragon.Currency.Enabled is off.", false);
|
|
return false;
|
|
}
|
|
|
|
LoadCurrencyFromDb(target);
|
|
std::string err;
|
|
if (!HandleParagonResetAll(target, &err))
|
|
{
|
|
handler->PSendSysMessage("Paragon recalibrate failed: {}", err);
|
|
return false;
|
|
}
|
|
|
|
ReconcileEssenceForPlayer(target);
|
|
PushCurrency(target);
|
|
PushSnapshot(target);
|
|
PushBuildCatalog(target);
|
|
|
|
handler->PSendSysMessage(
|
|
"Paragon recalibrate complete for {} (level {}): panel cleared, AE={}, TE={} (level-correct).",
|
|
target->GetName(),
|
|
uint32(target->GetLevel()),
|
|
GetAE(target),
|
|
GetTE(target));
|
|
return true;
|
|
}
|
|
|
|
static bool HandleCurrency(ChatHandler* handler)
|
|
{
|
|
Player* pl = handler->GetPlayer();
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
handler->SendErrorMessage("Paragon currency is only tracked for Paragon characters.", false);
|
|
return false;
|
|
}
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
{
|
|
handler->SendErrorMessage("Paragon.Currency.Enabled is off.", false);
|
|
return false;
|
|
}
|
|
|
|
LoadCurrencyFromDb(pl);
|
|
handler->PSendSysMessage("Ability Essence: {} | Talent Essence: {}", GetAE(pl), GetTE(pl));
|
|
return true;
|
|
}
|
|
|
|
// .paragon runes — diagnostic dump of rune state (server-side truth) and
|
|
// forced ResyncRunes packet to the client. Helps diagnose visual-vs-server
|
|
// desync where the rune pip animates to ready but the spell cast still
|
|
// returns SPELL_FAILED_NO_POWER because GetRuneCooldown(i) > 0 server-side.
|
|
static bool HandleRunes(ChatHandler* handler)
|
|
{
|
|
Player* pl = handler->GetPlayer();
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
handler->SendErrorMessage("Only Paragon characters have a rune block to inspect.", false);
|
|
return false;
|
|
}
|
|
|
|
for (uint8 i = 0; i < MAX_RUNES; ++i)
|
|
{
|
|
handler->PSendSysMessage("rune[{}] base={} cur={} cd={}ms grace={}ms",
|
|
i,
|
|
uint32(pl->GetBaseRune(i)),
|
|
uint32(pl->GetCurrentRune(i)),
|
|
uint32(pl->GetRuneCooldown(i)),
|
|
uint32(pl->GetGracePeriod(i)));
|
|
}
|
|
|
|
for (uint8 t = 0; t < NUM_RUNE_TYPES; ++t)
|
|
{
|
|
handler->PSendSysMessage("regen[{}] = {} (1/cooldown_ms)",
|
|
uint32(t),
|
|
pl->GetFloatValue(PLAYER_RUNE_REGEN_1 + t));
|
|
}
|
|
|
|
// Force a fresh client snapshot so we can see if visual catches up.
|
|
pl->ResyncRunes(MAX_RUNES);
|
|
handler->PSendSysMessage("|cff00ff00ResyncRunes packet sent.|r");
|
|
return true;
|
|
}
|
|
|
|
static bool HandleLearn(ChatHandler* handler, SpellInfo const* spell)
|
|
{
|
|
Player* pl = handler->GetPlayer();
|
|
if (!pl || pl->getClass() != CLASS_PARAGON)
|
|
{
|
|
handler->SendErrorMessage("Only Paragon characters use AE for this command.", false);
|
|
return false;
|
|
}
|
|
|
|
if (!sConfigMgr->GetOption<bool>("Paragon.Currency.Enabled", true))
|
|
{
|
|
handler->SendErrorMessage("Paragon.Currency.Enabled is off.", false);
|
|
return false;
|
|
}
|
|
|
|
if (!spell)
|
|
return false;
|
|
|
|
LoadCurrencyFromDb(pl);
|
|
|
|
uint32 const cost = LookupSpellAECost(spell->Id);
|
|
if (GetAE(pl) < cost)
|
|
{
|
|
handler->PSendSysMessage("Not enough Ability Essence (need {}, have {}).", cost, GetAE(pl));
|
|
return false;
|
|
}
|
|
|
|
if (!SpellMgr::IsSpellValid(spell))
|
|
{
|
|
handler->SendErrorMessage("Invalid spell.", false);
|
|
return false;
|
|
}
|
|
|
|
if (pl->HasSpell(spell->Id))
|
|
{
|
|
handler->SendErrorMessage("You already know this spell.", false);
|
|
return false;
|
|
}
|
|
|
|
if (!TrySpendAE(pl, cost))
|
|
return false;
|
|
|
|
PanelLearnSpellChain(pl, spell->Id);
|
|
SaveCurrencyToDb(pl);
|
|
PushCurrency(pl);
|
|
|
|
handler->PSendSysMessage("Learned spell {} ({} AE spent, {} AE remaining).", spell->Id, cost, GetAE(pl));
|
|
return true;
|
|
}
|
|
|
|
// .paragon hat — diagnostic for Honor Among Thieves on a Paragon.
|
|
// Prints HasTalent, HasAura, HasSpell, EquippedItemClass, ProcEvent
|
|
// hookup, and re-applies the talent's passive aura if missing.
|
|
//
|
|
// HAT in 3.3.5: rank ids 51698 (R1) / 51700 (R2) / 51701 (R3).
|
|
// Effect 0 is APPLY_AREA_AURA_PARTY -> SPELL_AURA_PROC_TRIGGER_SPELL
|
|
// (52916) which targets the rogue (the original caster) when ANY
|
|
// party member crits, and 52916 in turn casts 51699 to grant +1 CP.
|
|
static bool HandleHat(ChatHandler* handler)
|
|
{
|
|
Player* pl = handler->GetPlayer();
|
|
if (!pl)
|
|
return false;
|
|
|
|
constexpr std::array<uint32, 3> kHatRanks = { 51698u, 51700u, 51701u };
|
|
constexpr uint32 kHatProc = 52916u;
|
|
constexpr uint32 kHatTrigger = 51699u;
|
|
|
|
handler->PSendSysMessage("|cff00ffff[paragon hat]|r class={} lvl={} group={}",
|
|
uint32(pl->getClass()), pl->GetLevel(),
|
|
pl->GetGroup() ? "yes" : "no");
|
|
|
|
uint32 ownedRank = 0;
|
|
uint32 ownedRankId = 0;
|
|
for (uint32 i = 0; i < kHatRanks.size(); ++i)
|
|
{
|
|
uint32 const id = kHatRanks[i];
|
|
bool hasTalent = pl->HasTalent(id, pl->GetActiveSpec());
|
|
bool hasAura = pl->HasAura(id);
|
|
SpellInfo const* info = sSpellMgr->GetSpellInfo(id);
|
|
handler->PSendSysMessage(
|
|
" R{} ({}): HasTalent={} HasAura={} HasSpell={} info={}",
|
|
i + 1, id,
|
|
hasTalent ? "Y" : "n",
|
|
hasAura ? "Y" : "n",
|
|
pl->HasSpell(id) ? "Y" : "n",
|
|
info ? "ok" : "MISSING");
|
|
if (hasTalent && !ownedRank)
|
|
{
|
|
ownedRank = i + 1;
|
|
ownedRankId = id;
|
|
}
|
|
}
|
|
|
|
SpellInfo const* procInfo = sSpellMgr->GetSpellInfo(kHatProc);
|
|
SpellInfo const* trigInfo = sSpellMgr->GetSpellInfo(kHatTrigger);
|
|
handler->PSendSysMessage(" proc52916 info={} trig51699 info={}",
|
|
procInfo ? "ok" : "MISSING",
|
|
trigInfo ? "ok" : "MISSING");
|
|
|
|
if (!ownedRank)
|
|
{
|
|
handler->PSendSysMessage("|cffff8000No HAT rank in active spec.|r");
|
|
return true;
|
|
}
|
|
|
|
SpellInfo const* rank = sSpellMgr->GetSpellInfo(ownedRankId);
|
|
if (!rank)
|
|
return true;
|
|
|
|
// Inspect the talent rank effects so we can see exactly what AC
|
|
// thinks should be applied.
|
|
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
|
|
{
|
|
SpellEffectInfo const& eff = rank->Effects[i];
|
|
if (eff.Effect == 0)
|
|
continue;
|
|
handler->PSendSysMessage(
|
|
" eff[{}] effect={} aura={} targetA={} trigger={} basePts={}",
|
|
i, uint32(eff.Effect), uint32(eff.ApplyAuraName),
|
|
uint32(eff.TargetA.GetTarget()), eff.TriggerSpell, eff.BasePoints);
|
|
}
|
|
|
|
// Force-apply the rank passive aura if it isn't already there. We
|
|
// use Aura::TryRefreshStackOrCreate so we don't go through CheckCast
|
|
// (which can fail silently for various reasons).
|
|
if (!pl->HasAura(ownedRankId))
|
|
{
|
|
Aura* a = Aura::TryRefreshStackOrCreate(rank, MAX_EFFECT_MASK, pl, pl);
|
|
handler->PSendSysMessage(" force-apply rank aura -> {}",
|
|
a ? "OK" : "FAILED");
|
|
}
|
|
else
|
|
{
|
|
handler->PSendSysMessage(" rank aura already on player.");
|
|
}
|
|
|
|
// Dump the live SpellProcEntry the engine will use when checking
|
|
// "should this aura proc". Confirms the ProcFlags fallback from
|
|
// SpellInfo, and the SpellPhase / Hit gates.
|
|
if (SpellProcEntry const* pe = sSpellMgr->GetSpellProcEntry(ownedRankId))
|
|
{
|
|
handler->PSendSysMessage(
|
|
" ProcEntry({}): ProcFlags=0x{:X} SpellTypeMask=0x{:X} SpellPhaseMask=0x{:X} HitMask=0x{:X} chance={} cd={}ms",
|
|
ownedRankId,
|
|
pe->ProcFlags, pe->SpellTypeMask, pe->SpellPhaseMask,
|
|
pe->HitMask, pe->Chance,
|
|
uint32(pe->Cooldown.count()));
|
|
}
|
|
else
|
|
{
|
|
handler->PSendSysMessage(
|
|
" ProcEntry({}): NONE (proc system will not fire this aura)",
|
|
ownedRankId);
|
|
}
|
|
|
|
// Walk the player's applied auras and report whether the engine
|
|
// currently sees an effect-mask flag turned on for the rank's
|
|
// PROC_TRIGGER_SPELL effect. If the aura is up but the flag is
|
|
// off, the engine won't proc it.
|
|
if (AuraApplication* aa = pl->GetAuraApplication(ownedRankId))
|
|
{
|
|
handler->PSendSysMessage(
|
|
" AuraApp: effectMask=0x{:X} effectsToApply=0x{:X} flags=0x{:X}",
|
|
uint32(aa->GetEffectMask()),
|
|
uint32(aa->GetEffectsToApply()),
|
|
uint32(aa->GetFlags()));
|
|
}
|
|
else
|
|
{
|
|
handler->PSendSysMessage(" AuraApp: NONE on player");
|
|
}
|
|
|
|
// Force-fire the trigger chain (52916 -> dummy -> 51699 -> +CP) on
|
|
// the player's current target. If this works, the proc machinery
|
|
// is at fault. If THIS fails, the trigger spells are at fault.
|
|
if (Unit* tgt = pl->GetSelectedUnit())
|
|
{
|
|
uint32 const cpBefore = pl->GetComboPoints(tgt);
|
|
// Mimic spell_rog_honor_among_thieves::HandleProc: cast 52916
|
|
// FROM tgt -> tgt with the rogue/Paragon as original caster.
|
|
tgt->CastSpell(tgt, kHatProc, true, nullptr, nullptr, pl->GetGUID());
|
|
uint32 const cpAfter = pl->GetComboPoints(tgt);
|
|
handler->PSendSysMessage(
|
|
" force-fire 52916 on {}: CP {} -> {}",
|
|
tgt->GetName(), cpBefore, cpAfter);
|
|
}
|
|
else
|
|
{
|
|
handler->PSendSysMessage(
|
|
" no target selected: pick a unit and run again to force-fire 52916.");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
} // namespace (anonymous)
|
|
|
|
void AddSC_paragon_essence()
|
|
{
|
|
new Paragon_Essence_PlayerScript();
|
|
new Paragon_Essence_CommandScript();
|
|
}
|