HighSocietyRaiding/Fractured
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 21 Wiki Activity

Paragon: add Builds catalog (saved loadouts with pet park/unpark)

Browse Source 
Server-side Character Advancement now stores named, icon-tagged build
recipes (panel-purchased spells + per-spec talent ranks) and atomically
swaps between them by snapshotting the active build, refunding AE/TE
through HandleParagonReset{Talents,Abilities}, and re-spending on the
target recipe. Hunter pets attached to a build are parked to
PET_SAVE_NOT_IN_SLOT (mirroring HandleStableSwapPet) so name, talents,
and exp survive swaps; non-hunter pets (warlock demon, DK ghoul, mage
water elemental) are NOT parked because the engine resummons them from
a fresh template each cast.

New PARAA verbs: Q BUILDS / C BUILD NEW / C BUILD EDIT / C BUILD
DELETE / C BUILD FAVORITE / C BUILD LOAD. The catalog is pushed on
login and after every mutation as a single addon message.

Schema (mod-paragon migration 2026_05_10_03.sql):
- character_paragon_builds (build_id PK, guid, name, icon, is_favorite,
  pet_number, created_at)
- character_paragon_build_spells (build_id, spell_id)
- character_paragon_build_talents (build_id, spec, talent_id, rank)
- character_paragon_active_build (guid PK, build_id)

The talent recipe table is spec-keyed so a build remembers tank/dps
dual-spec layouts independently. Swaps are blocked while in combat.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Docker Build
2026-05-10 02:35:55 -04:00
parent abb25f56d1
commit 7de018f7eb
3 changed files with 857 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/mod-paragon/src/Paragon_Essence.cpp
+786
View File
@@ -29,6 +29,8 @@
#include <fmt/format.h>
#include <algorithm>
#include <array>
#include <cctype>
#include <cstdlib>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
@@ -1540,6 +1542,743 @@ void PushSnapshot(Player* 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 EDIT <id>\t<name>\t<icon> -- rename / re-icon
// C BUILD DELETE <id> -- delete + drop parked pet
// C BUILD FAVORITE <id> <0|1> -- toggle favorite flag
// C BUILD LOAD <id> -- swap to this build
//
// Server replies push `R BUILDS` after every mutation. Format:
//
// R BUILDS active=<id|->\t<id>:<fav>:<haspet>:<name>:<icon>; ...
//
// 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;
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;
}
void PushBuildCatalog(Player* pl)
{
if (!pl || pl->getClass() != CLASS_PARAGON)
return;
uint32 const lowGuid = pl->GetGUID().GetCounter();
uint32 const active = GetActiveBuildId(lowGuid);
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, is_favorite, pet_number, name, icon "
"FROM character_paragon_builds WHERE guid = {} "
"ORDER BY is_favorite DESC, build_id ASC", lowGuid))
{
bool first = true;
do
{
Field const* f = r->Fetch();
uint32 id = f[0].Get<uint32>();
uint8 fav = f[1].Get<uint8>();
bool haspet = !f[2].IsNull() && f[2].Get<uint32>() != 0;
std::string name = f[3].Get<std::string>();
std::string icon = f[4].Get<std::string>();
if (!first)
body += ';';
first = false;
body += fmt::format("{}:{}:{}:{}:{}", id,
static_cast<unsigned>(fav),
haspet ? 1 : 0,
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;
}
}
CharacterDatabase.DirectExecute(
"INSERT INTO character_paragon_builds (guid, name, icon) VALUES ({}, '{}', '{}')",
lowGuid, name, icon);
PushBuildCatalog(pl);
LOG_INFO("module", "Paragon build: {} created build '{}'", pl->GetName(), name);
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>();
// If the build being deleted is currently active, clear the
// active pointer first so the player ends up in the "no active
// build" state. Their currently-learned spells/talents are
// preserved (the client warns them about this -- they keep the
// loadout but lose the named slot and the parked pet).
uint32 const active = GetActiveBuildId(lowGuid);
if (active == buildId)
SetActiveBuildId(lowGuid, 0);
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;
}
bool HandleBuildFavorite(Player* pl, std::string const& payload, std::string* err)
{
if (!pl || pl->getClass() != CLASS_PARAGON)
{
*err = "not a Paragon";
return false;
}
auto sp = payload.find(' ');
if (sp == std::string::npos)
{
*err = "BUILD FAVORITE malformed";
return false;
}
uint32 buildId = static_cast<uint32>(std::strtoul(payload.substr(0, sp).c_str(), nullptr, 10));
int flag = std::atoi(payload.substr(sp + 1).c_str());
if (!buildId)
{
*err = "BUILD FAVORITE bad id";
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 is_favorite = {} WHERE build_id = {}",
flag ? 1 : 0, buildId);
PushBuildCatalog(pl);
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);
// No-op swap: target is already active. Refresh catalog so client
// UI re-syncs and bail.
if (activeId == targetId)
{
PushBuildCatalog(pl);
return true;
}
// -------------------------------------------------------------
// Phase 1: snapshot + park the current build's state, if any.
// -------------------------------------------------------------
if (activeId)
{
SnapshotBuildFromCurrent(pl, activeId);
ParkActivePetForBuild(pl, activeId);
}
// -------------------------------------------------------------
// Phase 2: reset all panel-bought spells/talents (refunds AE/TE
// through the existing reset path).
// -------------------------------------------------------------
std::string sub;
if (!HandleParagonResetTalents(pl, &sub))
{
*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);
LOG_INFO("module", "Paragon build: {} loaded build {}", pl->GetName(), targetId);
return true;
}
class Paragon_Essence_PlayerScript : public PlayerScript
{
public:
@@ -1559,6 +2298,7 @@ public:
LoadCurrencyFromDb(player);
PushCurrency(player);
PushSnapshot(player);
PushBuildCatalog(player);
// AC's character load sequence runs _LoadSkills (which fires
// learnSkillRewardedSpells) and _LoadSpells before this hook,
@@ -1770,6 +2510,52 @@ public:
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, 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, 17, "C BUILD FAVORITE ") == 0)
{
std::string err;
if (!HandleBuildFavorite(player, body.substr(17), &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;
}
if (body == "C RESET PET TALENTS")
{
// Pet talent reset: deliberately bypasses the engine's