// This file is part of ClassicAPI. // // ClassicAPI is free software: you can redistribute it and/or modify it under the terms // of the GNU Lesser 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 Lesser General Public License for more details. // See `Source.h` for the contract. This is the backend: a co-hook on // `FUN_SPELL_GO` that mirrors nampower's `SpellGoHook` parse to capture the // caster + duration of every aura-applying cast, and a small fixed-size // cache `Aura::Data::Push` reads from. #include "Source.h" #include "Game.h" #include "Offsets.h" #include "spell/Lookup.h" #include "tick/WorldTick.h" #include "unit/Identity.h" #include namespace Aura::Source { namespace { // Minimal view of the engine's CDataStore packet reader. Only the fields // the read path touches; layout matches nampower's `CDataStore`. Incoming // SMSG packets are a single contiguous buffer (`m_base == 0`, // `m_alloc == size`), so the simple `m_buffer - m_base + m_read` read with // an `m_size` bound is sufficient — same critical guard as the engine's // `CDataStore::Get`. // // CDataStore is POLYMORPHIC in the engine (virtual Internal*/Reset/etc.), // so a vtable pointer occupies offset 0 and the data members start at // +0x04. Omitting `vtable` here would shift every field by 4 and make // `m_buffer` read the vptr — yielding a garbage read address (the cause of // an early ACCESS_VIOLATION in the SpellGo hook). struct CDataStore { void *vtable; // +0x00 uint8_t *m_buffer; // +0x04 uint32_t m_base; // +0x08 uint32_t m_alloc; // +0x0C uint32_t m_size; // +0x10 uint32_t m_read; // +0x14 }; template T ReadField(CDataStore *p) { T val{}; const uint32_t end = p->m_read + sizeof(T); if (end > p->m_size) { p->m_read = p->m_size + 1; // poison: further reads short-circuit return val; } val = *reinterpret_cast(p->m_buffer - p->m_base + p->m_read); p->m_read += sizeof(T); return val; } // A cast applies an aura iff any of its three effects names an aura. The // EffectApplyAuraName[3] int32 array sits at `+0x16C` (already used by the // shapeshift / mechanic-immunity code). Gating on this keeps pure-damage // and utility casts out of the cache. bool SpellAppliesAura(const uint8_t *spellRecord) { if (spellRecord == nullptr) return false; const auto *auraNames = reinterpret_cast( spellRecord + Offsets::OFF_SPELL_RECORD_EFFECT_APPLY_AURA_NAME); for (int i = 0; i < Offsets::SPELL_RECORD_EFFECT_COUNT; ++i) { if (auraNames[i] != 0) return true; } return false; } uint32_t NowMs() { using TickCount_t = uint32_t(__fastcall *)(); return reinterpret_cast( static_cast(Offsets::FUN_OS_TICKCOUNT_MS))(); } // Server-authoritative duration (ms). When the local player is the caster // we let the engine fold in the player's duration modifiers (skipMod = 0); // for any other caster we take the unmodified base (skipMod = 1) since we // only have the local player's mod tables. `unit = 0` selects the player // mod context per FUN_GET_SPELL_DURATION's signature. uint32_t SpellDurationMs(const uint8_t *spellRecord, bool casterIsPlayer) { using GetDuration_t = int(__fastcall *)(const uint8_t *spellRecord, int unit, char skipMod); const int ms = reinterpret_cast( static_cast(Offsets::FUN_GET_SPELL_DURATION))( spellRecord, 0, casterIsPlayer ? 0 : 1); return ms > 0 ? static_cast(ms) : 0; } // ---- Cache --------------------------------------------------------------- struct Entry { uint64_t targetGuid; uint64_t casterGuid; uint32_t spellId; uint32_t expirationMs; // 0 = infinite / unknown duration bool used; }; constexpr int kCacheSize = 256; Entry g_cache[kCacheSize]; int g_writeCursor = 0; void Store(uint64_t targetGuid, uint32_t spellId, uint64_t casterGuid, uint32_t expirationMs) { if (targetGuid == 0 || spellId == 0 || casterGuid == 0) return; // Update an existing entry for this exact aura instance. for (auto &e : g_cache) { if (e.used && e.targetGuid == targetGuid && e.spellId == spellId) { e.casterGuid = casterGuid; e.expirationMs = expirationMs; return; } } // Take a free slot, else an expired one, else evict round-robin. const uint32_t now = NowMs(); for (auto &e : g_cache) { if (!e.used || (e.expirationMs != 0 && now >= e.expirationMs)) { e = {targetGuid, casterGuid, spellId, expirationMs, true}; return; } } Entry &slot = g_cache[g_writeCursor]; g_writeCursor = (g_writeCursor + 1) % kCacheSize; slot = {targetGuid, casterGuid, spellId, expirationMs, true}; } // Drop entries whose timed aura has elapsed so the table doesn't fill with // stale combat debuffs. Infinite-duration entries (expirationMs == 0) stay // until overwritten. void OnWorldTick() { const uint32_t now = NowMs(); for (auto &e : g_cache) { if (e.used && e.expirationMs != 0 && now >= e.expirationMs) e.used = false; } } const Tick::WorldTick::AutoSubscribe _tickSub{&OnWorldTick}; // ---- SMSG_SPELL_GO co-hook ---------------------------------------------- // The hit-target list is all we need: each entry is a unit the cast landed // on, which is exactly where an aura gets applied. We deliberately stop // before the missed-target list / target mask — the post-mask "intended" // target is redundant with the hit list for aura purposes, and skipping it // keeps the parse short and robust. constexpr int kMaxTargets = 16; using SpellGo_t = void(__fastcall *)(uint64_t *itemGUID, uint64_t *casterGUID, uint32_t spellId, CDataStore *packet); SpellGo_t g_origSpellGo = nullptr; void __fastcall SpellGo_h(uint64_t *itemGUID, uint64_t *casterGUID, uint32_t spellId, CDataStore *packet) { uint64_t targets[kMaxTargets]; int numTargets = 0; if (packet != nullptr) { const uint32_t savedRead = packet->m_read; ReadField(packet); // castFlags (unused) const uint8_t numHit = ReadField(packet); for (int i = 0; i < numHit; ++i) { const uint64_t guid = ReadField(packet); if (numTargets < kMaxTargets) targets[numTargets++] = guid; } packet->m_read = savedRead; // restore so the engine re-parses cleanly } g_origSpellGo(itemGUID, casterGUID, spellId, packet); const uint64_t caster = (casterGUID != nullptr) ? *casterGUID : 0; if (caster == 0 || spellId == 0) return; const uint8_t *rec = Spell::Lookup::RecordForID(static_cast(spellId)); if (!SpellAppliesAura(rec)) return; const bool casterIsPlayer = (caster == Unit::Identity::PlayerGuid()); const uint32_t durationMs = SpellDurationMs(rec, casterIsPlayer); const uint32_t expirationMs = durationMs > 0 ? NowMs() + durationMs : 0; if (numTargets == 0) { // No explicit hit list (self-cast with caster-implicit target). Store(caster, spellId, caster, expirationMs); return; } for (int i = 0; i < numTargets; ++i) Store(targets[i], spellId, caster, expirationMs); } const Game::HookAutoRegister _hook{Offsets::FUN_SPELL_GO, reinterpret_cast(&SpellGo_h), reinterpret_cast(&g_origSpellGo)}; } // namespace bool Get(uint64_t unitGuid, uint32_t spellId, uint64_t *outCaster, uint32_t *outExpirationMs) { if (unitGuid == 0 || spellId == 0) return false; for (const auto &e : g_cache) { if (e.used && e.targetGuid == unitGuid && e.spellId == spellId) { *outCaster = e.casterGuid; *outExpirationMs = e.expirationMs; return true; } } return false; } } // namespace Aura::Source