Files
ClassicAPI/src/aura/Delta.cpp
T
Brues 492085ac0c feat(aura): add aura instance IDs and the UNIT_AURA_DELTA event
1.12 has no aura identity: a unit's descriptor holds 48 spell IDs and
nothing that tells one application from the next. Aura::Instance gives
each visible aura an ID when it lands in a slot and keeps it until the
aura leaves; IDs are never reused. One sync step (recorded slot vs live
descriptor) drives everything: the existing Aura::Source add / remove /
stacks observers sync the slot they name, the getters sync before
answering, and a per-frame reconcile catches bulk clears and rebuilt
objects. No new engine hooks.

UNIT_AURA_DELTA(unitTarget, updateInfo) carries retail's UNIT_AURA
payload under its own name, so the engine's UNIT_AURA is untouched. It
fires once per unit per frame, per token, with instance-ID lists only,
in four reused tables, so a fire allocates nothing. With no listener,
no change sets are kept. Timing-only refreshes (cache rewrites, the
player's duration packet) are reported as updated.

Also:
- auraInstanceID on every AuraData table and on C_LossOfControl CC
  entries
- C_UnitAuras.GetAuraDataByAuraInstanceID(unit, id [, buf]); the buf
  form fills the caller's table
- Game::Lua::Ref, the shared luaL_ref binding, replacing two local
  typedefs in the animation code
2026-10-26 18:39:03 -05:00

152 lines
5.7 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.
// UNIT_AURA_DELTA(unitTarget, updateInfo) — retail's UNIT_AURA payload under
// its own name, so the engine's UNIT_AURA stays exactly as it is.
//
// Once per frame, from the world tick, each unit whose auras changed fires
// once per unit token it has (`Unit::Identity::TokensForGUID`), the way the
// engine fires UNIT_AURA. The change set is `Aura::Instance`'s.
//
// The payload is built to cost no garbage. It carries instance IDs only —
// never AuraData; a handler reads the auras it cares about with
// `C_UnitAuras.GetAuraDataByAuraInstanceID(unit, id, buf)` — and the
// `updateInfo` table and its three ID lists are the same four tables on every
// fire, refilled each time. So they are valid only during the handler; a
// handler that keeps one must copy it.
//
// With nothing registered for the event, the tick reads one pointer and stops:
// `Aura::Instance` records no change set, and nothing here runs.
#include "Game.h"
#include "aura/Instance.h"
#include "event/Custom.h"
#include "tick/WorldTick.h"
#include "unit/Identity.h"
#include <cstdint>
namespace Aura::Delta {
namespace {
const Game::Doc::Field kInfoFields[] = {
Game::Doc::Req("isFullUpdate", "bool",
"True when the unit's auras must be read again in full; the lists are then nil."),
Game::Doc::Opt("addedAuraInstanceIDs", "table", nullptr,
"Instance IDs of the auras added to the unit."),
Game::Doc::Opt("updatedAuraInstanceIDs", "table", nullptr,
"Instance IDs of the unit's auras that changed in place."),
Game::Doc::Opt("removedAuraInstanceIDs", "table", nullptr,
"Instance IDs of the auras removed from the unit."),
};
const Game::Doc::Structure kInfo{
"UnitAuraDeltaInfo", "UnitAuras", kInfoFields,
"What changed in a unit's auras. Valid only while the event handler runs."};
const Game::Doc::Field kPayload[] = {
Game::Doc::Req("unitTarget", "UnitToken"),
Game::Doc::Req("updateInfo", "UnitAuraDeltaInfo"),
};
const Game::Doc::Event kDoc{
"UnitAuras",
"Fires when a unit's auras change, with the instance IDs of the auras that "
"were added, changed, or removed.",
kPayload};
const Event::Custom::AutoReserve _evt{"UNIT_AURA_DELTA", &kDoc};
// The reused payload tables, anchored in the registry of the Lua state that
// made them. LUA_NOREF until first use in each state.
constexpr int kNoRef = -2;
int g_infoRef = kNoRef;
int g_addedRef = kNoRef;
int g_updatedRef = kNoRef;
int g_removedRef = kNoRef;
// Pushes the table anchored at `ref`, making it on first use.
void PushTable(void *L, int &ref) {
if (ref == kNoRef) {
Game::Lua::NewTable(L);
ref = Game::Lua::Ref(L, Game::Lua::REGISTRY_INDEX);
}
Game::Lua::RawGetI(L, Game::Lua::REGISTRY_INDEX, ref);
}
// Sets `key` on the table at the top to the list at `ref` refilled with `ids`,
// or to nil when there are none.
void SetList(void *L, const char *key, int &ref, const uint32_t *ids, int count) {
Game::Lua::PushString(L, key);
if (count == 0) {
Game::Lua::PushNil(L);
Game::Lua::SetTable(L, -3);
return;
}
PushTable(L, ref);
for (int i = 0; i < count; ++i) {
Game::Lua::PushNumber(L, static_cast<double>(i + 1));
Game::Lua::PushNumber(L, static_cast<double>(ids[i]));
Game::Lua::RawSet(L, -3);
}
// Clear what lies past the new end: a longer earlier list, or anything a
// handler appended.
for (int i = count + 1;; ++i) {
Game::Lua::RawGetI(L, -1, i);
const bool end = Game::Lua::Type(L, -1) == Game::Lua::TYPE_NIL;
Game::Lua::SetTop(L, -2);
if (end)
break;
Game::Lua::PushNumber(L, static_cast<double>(i));
Game::Lua::PushNil(L);
Game::Lua::RawSet(L, -3);
}
Game::Lua::SetN(L, -1, count);
Game::Lua::SetTable(L, -3);
}
void Fire(const Aura::Instance::Delta &d) {
char tokens[16][32];
const int n = Unit::Identity::TokensForGUID(d.guid, tokens, 16);
void *L = Game::Lua::State();
if (n == 0 || L == nullptr)
return;
const int top = Game::Lua::GetTop(L);
for (int i = 0; i < n; ++i) {
// Refilled for each token: a handler may have changed the tables.
Game::Lua::PushString(L, tokens[i]);
PushTable(L, g_infoRef);
Game::Lua::SetFieldBool(L, "isFullUpdate", d.fullUpdate);
SetList(L, "addedAuraInstanceIDs", g_addedRef, d.added, d.addedCount);
SetList(L, "updatedAuraInstanceIDs", g_updatedRef, d.updated, d.updatedCount);
SetList(L, "removedAuraInstanceIDs", g_removedRef, d.removed, d.removedCount);
Event::Custom::FireValues(_evt.Slot(), L, top + 1, 2);
Game::Lua::SetTop(L, top);
}
}
void OnWorldTick() {
const bool listening = Event::Custom::HasListeners(_evt.Slot());
Aura::Instance::SetRecording(listening);
if (listening)
Aura::Instance::Drain(&Fire);
}
const Tick::WorldTick::AutoSubscribe _tick{&OnWorldTick};
// Each registration pass is a new Lua state; the old state's refs are gone.
void ResetRefs() {
g_infoRef = g_addedRef = g_updatedRef = g_removedRef = kNoRef;
}
const Game::ModuleAutoRegister _autoreg{&ResetRefs};
} // namespace
} // namespace Aura::Delta