mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 16:10:36 +00:00
GetSpellBonusDamage(school) reads the player's per-school spell damage
directly from the CGPlayer sub-struct at [player+0xE68]+0xFD4 (POS) / +0xFF0
(NEG), net = POS-NEG. That field isn't in the broadcast descriptor (+0x110
reads zero — the vanilla server never sends it there), but the client keeps a
fully-computed copy at +0xE68 with gear/enchants/buffs/talents/sets baked in.
Same source nampower's GetSpellPower reads; verified 613 generic / 647 Fire on
a geared mage. 1-based school, matching 3.3.5's Script_GetSpellBonusDamage.
GetSpellBonusHealing() has no such field (vanilla lacks a healing-done field
entirely), so it's derived to mirror the server's SpellBaseHealingBonusDone:
- flat healing: SPELL_AURA_MOD_HEALING_DONE (135) off gear equip-effects,
item enchants, random suffixes, and active buffs
- Spirit conversion: SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT (175) x
total Spirit / 100 (Priest Spiritual Guidance)
- Armor conversion: SPELL_AURA_MOD_SPELL_HEALING_OF_ARMOR_PERCENT (199) x
armor / 100 (Turtle Ironclad)
Percents are read straight from Spell.dbc, so it's generic across any
aura-175/199 talent/buff including Turtle customs, and gated on SPELL_ATTR_
PASSIVE for the known-spell-bitmap walk. Spirit/Armor come from UNIT_FIELD_
STAT4 (+0x250) / UNIT_FIELD_RESISTANCES[0] (+0x254).
Item flat healing routes through the shared Item::StatAccum engine rather than
re-implementing the item spell/suffix/enchant walk: extract a reusable
ApplyEnchant() (from ApplyRandomSuffix) plus a Value() reader, and read
ITEM_MOD_SPELL_HEALING_DONE_SHORT.
The healing sum is expensive (StatAccum over 19 items + buff table + the 27k
known-spell bitmap), so it's cached and recomputed only when a player stat
input changes. New Player::StatSignal (a pull-based epoch) is bumped from the
aura hooks (player-guarded), the equipment observer, and the spell learn/
unlearn writers (0x4B25B0 / 0x4B2C50) -- so buffs, gear, and talent respecs
all invalidate instantly. A coarse world-tick recompute remains only as a
backstop against a missed signal.
223 lines
10 KiB
C++
223 lines
10 KiB
C++
// This file is part of ClassicAPI.
|
|
//
|
|
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
|
// of the GNU General Public License as published by the Free Software Foundation, either
|
|
// version 3 of the License, or (at your option) any later version.
|
|
//
|
|
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
// PURPOSE. See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License along with
|
|
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
// `PLAYER_EQUIPMENT_CHANGED(equipmentSlot, hasCurrent)` — the WotLK-era
|
|
// per-slot paperdoll event. Vanilla only fires UNIT_INVENTORY_CHANGED for
|
|
// the player, which doesn't say WHICH slot changed; gear trackers and stat
|
|
// sheets built against 3.3+ gate their refresh on this event.
|
|
//
|
|
// Fully event-driven via the engine's own descriptor-field observer system
|
|
// (see the FUN_DESC_OBSERVER_REGISTER block in Offsets.h). The engine's
|
|
// inventory setup (FUN_INV_OBSERVER_SETUP, once per enter-world) registers
|
|
// change observers for the bag/backpack/bank/keyring GUID fields of the
|
|
// player descriptor — but never for the 19 equipment slots (0x4A8..0x538).
|
|
// We co-hook that setup and register our own observer per equipment field,
|
|
// mirroring the engine's registration shape exactly (bank 4, size 8). The
|
|
// dispatcher invokes us only when a slot's item GUID actually changed
|
|
// (per-node mirror memcmp), so there's no polling and no diff bookkeeping
|
|
// on our side, and the nodes share the engine observers' lifetime (they
|
|
// die with the player object; the setup re-runs each enter-world).
|
|
//
|
|
// `equipmentSlot` is the 1-based Lua inventory slot (1 = head … 19 =
|
|
// tabard), matching modern. `hasCurrent` is 1 when the slot now holds an
|
|
// item and nil when it's empty (the engine dispatcher has no `%b`; 1/nil
|
|
// keeps the idiomatic `if hasCurrent then` working — see FireIdSuccess).
|
|
//
|
|
// Also `UPDATE_INVENTORY_DURABILITY` (no payload) — fires when any
|
|
// equipped item's durability changes (combat damage, death, repairs) —
|
|
// via a co-hook on the engine's inventory-alerts recompute
|
|
// (FUN_INVENTORY_ALERTS_RECOMPUTE): the engine itself calls that whenever
|
|
// an owned item's fields change (its item post-update handler FUN_005D9A90
|
|
// routes every item values-update through it) and on equip/enter-world
|
|
// paths, so it IS the engine's own "durability may have changed" signal.
|
|
// Post-original we diff a per-slot {itemGuid, durability} snapshot and
|
|
// fire only on a real change. NOT done with bank-1 (ITEM field) descriptor
|
|
// observers: those register without error but are never invoked — the
|
|
// registrar's internal wrapper lookup (FUN_00464890, the observer
|
|
// registry, distinct from the object manager) silently no-ops for item
|
|
// objects, verified empirically (item values-updates arrive and the
|
|
// player-bank observers fire, item-bank ones never do).
|
|
|
|
#include "Game.h"
|
|
#include "Offsets.h"
|
|
#include "equipmentset/Locations.h"
|
|
#include "event/Custom.h"
|
|
#include "player/StatSignal.h"
|
|
#include "unit/Identity.h"
|
|
|
|
#include <cstdint>
|
|
|
|
namespace Player::Equipment {
|
|
|
|
namespace {
|
|
|
|
constexpr const char *kEvtEquipmentChanged = "PLAYER_EQUIPMENT_CHANGED";
|
|
const Event::Custom::AutoReserve _r{kEvtEquipmentChanged};
|
|
constexpr const char *kEvtDurability = "UPDATE_INVENTORY_DURABILITY";
|
|
const Event::Custom::AutoReserve _r2{kEvtDurability};
|
|
|
|
// Whether the slot currently holds an item — read from the player's
|
|
// inventory-manager GUID array, the same source the engine's own bag
|
|
// observer (FUN_004F8DB0) treats as the post-change truth when its field
|
|
// observer fires. The player is resolved from the GUID the observer
|
|
// callback receives, via the NON-THROWING object resolver — the same call
|
|
// FUN_004F8DB0 makes. NOT via FUN_RESOLVE_UNIT_TOKEN("player"): that's the
|
|
// assert-frame helper that raises a Lua error when the token doesn't
|
|
// resolve, and this runs inside SMSG_UPDATE_OBJECT processing, where the
|
|
// player object can be mid-create and momentarily unresolvable — a Lua
|
|
// error thrown from there unwinds through raw engine code.
|
|
bool SlotHasItem(uint32_t guidLo, uint32_t guidHi, int slot0Based) {
|
|
using ResolveByGUID_t = void *(__fastcall *)(uint32_t typeMask,
|
|
const char *debugName,
|
|
uint32_t guidLo, uint32_t guidHi,
|
|
int line);
|
|
auto resolve =
|
|
reinterpret_cast<ResolveByGUID_t>(Offsets::FUN_OBJECT_RESOLVE_BY_GUID);
|
|
auto *player = static_cast<const uint8_t *>(resolve(
|
|
Offsets::OBJ_TYPE_PLAYER, "ClassicAPI", guidLo, guidHi, 0x172));
|
|
if (player == nullptr)
|
|
return false;
|
|
const uint8_t *invMgr = player + Offsets::OFF_PLAYER_INVENTORY_MANAGER;
|
|
const uint32_t count = *reinterpret_cast<const uint32_t *>(
|
|
invMgr + Offsets::OFF_INVMGR_SLOT_COUNT);
|
|
if (static_cast<uint32_t>(slot0Based) >= count)
|
|
return false;
|
|
const uint64_t *guids = *reinterpret_cast<const uint64_t *const *>(
|
|
invMgr + Offsets::OFF_INVMGR_GUID_ARRAY);
|
|
return guids != nullptr && guids[slot0Based] != 0;
|
|
}
|
|
|
|
// --- PLAYER_EQUIPMENT_CHANGED (player-descriptor observers) -------------
|
|
|
|
// Descriptor-field observer callback — ABI per the Offsets.h note:
|
|
// __fastcall(fieldOffset /*ecx*/, size /*edx*/, guidLo, guidHi, oldValue*,
|
|
// userArg), return 1, callee cleans 0x10. Invoked by the dispatcher only
|
|
// when the watched equipment GUID field actually changed.
|
|
int __fastcall EquipSlotChanged_cb(uint32_t fieldOffset, uint32_t /*size*/,
|
|
uint32_t guidLo, uint32_t guidHi,
|
|
const uint32_t * /*oldValue*/,
|
|
void * /*userArg*/) {
|
|
const int slot0 =
|
|
static_cast<int>(fieldOffset - Offsets::OFF_DESC_PLAYER_EQUIP_FIRST) >> 3;
|
|
if (slot0 >= 0 && slot0 < Offsets::DESC_PLAYER_EQUIP_SLOTS) {
|
|
Event::Custom::FireIdSuccess(Event::Custom::Lookup(kEvtEquipmentChanged),
|
|
slot0 + 1,
|
|
SlotHasItem(guidLo, guidHi, slot0));
|
|
// Gear swap changes item +healing and Spirit/Armor — invalidate the
|
|
// GetSpellBonusHealing cache.
|
|
Player::StatSignal::Notify();
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
// Co-hook on the engine's inventory observer setup: after it registers the
|
|
// bag-range observers, register ours for the equipment range it skips.
|
|
// Same registrar, same shape — only the field offsets differ.
|
|
using RegisterObserver_t = void(__fastcall *)(
|
|
int bank, uint32_t fieldOffset, uint32_t guidLo, uint32_t guidHi, int size,
|
|
const void *callback, void *userArg1, void *userArg2);
|
|
using ObserverSetup_t = void(__fastcall *)();
|
|
ObserverSetup_t g_origSetup = nullptr;
|
|
|
|
// One-time (per process) seed latch for the durability diff below — the
|
|
// very first recompute seeds the snapshot silently instead of firing for
|
|
// the initial gear population. Deliberately NOT reset per enter-world:
|
|
// death/release/graveyard teleports re-run the setup, and a per-setup
|
|
// reset made the post-teleport recompute re-seed silently — swallowing
|
|
// the death's own durability loss (verified in-game: repairs fired,
|
|
// deaths didn't). Keeping the snapshot across loading screens means
|
|
// changes that land around them diff normally; the cost is at most one
|
|
// spurious fire on relog to a different character, which matches
|
|
// modern's login-time fire anyway.
|
|
bool g_durSnapValid = false;
|
|
|
|
void __fastcall ObserverSetup_h() {
|
|
g_origSetup();
|
|
|
|
const uint64_t guid = Unit::Identity::PlayerGuid();
|
|
if (guid == 0)
|
|
return;
|
|
auto reg = reinterpret_cast<RegisterObserver_t>(
|
|
Offsets::FUN_DESC_OBSERVER_REGISTER);
|
|
for (int slot = 0; slot < Offsets::DESC_PLAYER_EQUIP_SLOTS; ++slot) {
|
|
reg(Offsets::DESC_OBSERVER_BANK_PLAYER,
|
|
Offsets::OFF_DESC_PLAYER_EQUIP_FIRST + slot * 8,
|
|
static_cast<uint32_t>(guid), static_cast<uint32_t>(guid >> 32),
|
|
/*size*/ 8, reinterpret_cast<const void *>(&EquipSlotChanged_cb),
|
|
nullptr, nullptr);
|
|
}
|
|
}
|
|
|
|
static const Game::HookAutoRegister _setupHook{
|
|
Offsets::FUN_INV_OBSERVER_SETUP,
|
|
reinterpret_cast<void *>(&ObserverSetup_h),
|
|
reinterpret_cast<void **>(&g_origSetup)};
|
|
|
|
// --- UPDATE_INVENTORY_DURABILITY (alerts-recompute co-hook) --------------
|
|
|
|
struct SlotDurability {
|
|
uint64_t guid; // equipped item, 0 = empty slot
|
|
uint32_t durability; // ITEM_FIELD_DURABILITY, 0 when empty/unresolved
|
|
};
|
|
SlotDurability g_durSnap[EquipmentSet::SLOT_COUNT];
|
|
|
|
uint32_t ItemDurability(uint64_t guid) {
|
|
if (guid == 0)
|
|
return 0;
|
|
const uint8_t *item = EquipmentSet::Locations::ResolveItemByGUID(guid);
|
|
if (item == nullptr)
|
|
return 0;
|
|
const uint8_t *descriptor = *reinterpret_cast<const uint8_t *const *>(
|
|
item + Offsets::OFF_ITEM_DESCRIPTOR);
|
|
if (descriptor == nullptr)
|
|
return 0;
|
|
return *reinterpret_cast<const uint32_t *>(
|
|
descriptor + Offsets::OFF_DESCRIPTOR_DURABILITY);
|
|
}
|
|
|
|
using AlertsRecompute_t = void(__fastcall *)();
|
|
AlertsRecompute_t g_origAlertsRecompute = nullptr;
|
|
|
|
void __fastcall AlertsRecompute_h() {
|
|
g_origAlertsRecompute();
|
|
|
|
uint64_t paperdoll[EquipmentSet::SLOT_COUNT];
|
|
EquipmentSet::Locations::SnapshotPaperdoll(paperdoll);
|
|
|
|
bool changed = false;
|
|
for (int i = 0; i < EquipmentSet::SLOT_COUNT; ++i) {
|
|
const SlotDurability cur{paperdoll[i], ItemDurability(paperdoll[i])};
|
|
if (g_durSnap[i].guid != cur.guid ||
|
|
g_durSnap[i].durability != cur.durability) {
|
|
changed = true;
|
|
g_durSnap[i] = cur;
|
|
}
|
|
}
|
|
|
|
if (!g_durSnapValid) {
|
|
g_durSnapValid = true; // first recompute of the session seeds only
|
|
return;
|
|
}
|
|
if (changed)
|
|
Event::Custom::Fire(Event::Custom::Lookup(kEvtDurability), "");
|
|
}
|
|
|
|
static const Game::HookAutoRegister _alertsHook{
|
|
Offsets::FUN_INVENTORY_ALERTS_RECOMPUTE,
|
|
reinterpret_cast<void *>(&AlertsRecompute_h),
|
|
reinterpret_cast<void **>(&g_origAlertsRecompute)};
|
|
|
|
} // namespace
|
|
|
|
} // namespace Player::Equipment
|