// 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 . // `C_LossOfControl` — active loss-of-control effects on the LOCAL PLAYER. // Vanilla 1.12 has no such aggregation layer (it's a MoP addition), so we // synthesize it from two sources: // // 1. SCHOOL_INTERRUPT — the Counterspell/Kick school lockout. The server // (Player::ProhibitSpellSchool) delivers it as a single // SMSG_SPELL_COOLDOWN carrying every spell of the interrupted school, // all with the same duration. That "player-GUID packet, >=2 spells, one // uniform duration" shape is produced by nothing else (normal cooldowns // are single-spell or applied client-side), so co-hooking the cooldown // handler and matching it yields an authoritative school + duration. // The interrupting spell isn't in the packet, so spellID is 0 and // displayText is a fixed "Interrupted" — the mechanically-relevant data // (school, duration, timing) is exact. // // 2. CC debuffs — stun / fear / root / confuse / charm / possess / silence / // pacify / disarm are real debuff auras. We scan the player's debuffs and // classify each by its spell's EffectApplyAuraName. Timing is best-effort // from the Aura::Source cache (nil when the cast wasn't observed — the // LoC timing fields are nullable, so that's contract-valid). // // Placeholders for fields with no vanilla equivalent: priority = 0, // displayType = 2 (show for full duration), auraInstanceID = nil. iconTexture // is the spell's icon PATH (vanilla has no FileDataIDs; a path is the // functional equivalent). #include "Game.h" #include "Offsets.h" #include "aura/Data.h" #include "aura/Source.h" #include "dbc/Lookup.h" #include "event/Custom.h" #include "net/PacketReader.h" #include "spell/Lookup.h" #include "tick/WorldTick.h" #include "unit/Identity.h" #include namespace LossOfControl { namespace { using TickMs_t = uint32_t(__fastcall *)(); int NowMs() { return static_cast( reinterpret_cast(Offsets::FUN_OS_TICKCOUNT_MS)()); } // Spell.dbc field readers (mirrors the small locals in Spell::Cast). constexpr int OFF_NAME = 0x1E0; // localized name[9] constexpr int OFF_ICON_ID = 0x1D4; // -> SpellIcon.dbc const char *SpellName(const uint8_t *rec) { const int locale = *reinterpret_cast(Offsets::VAR_LOCALE_INDEX); const char *n = *reinterpret_cast(rec + OFF_NAME + locale * 4); return (n != nullptr) ? n : ""; } const char *SpellIconPath(const uint8_t *rec) { const int iconID = *reinterpret_cast(rec + OFF_ICON_ID); const uint8_t *iconRec = DBC::Record(Offsets::VAR_SPELL_ICON_RECORDS, Offsets::VAR_SPELL_ICON_COUNT, static_cast(iconID)); if (iconRec == nullptr) return ""; const char *p = *reinterpret_cast(iconRec + 0x04); return (p != nullptr) ? p : ""; } int SpellSchoolIndex(const uint8_t *rec) { return *reinterpret_cast(rec + Offsets::OFF_SPELL_SCHOOL); } // Classify a spell's control-loss type from its EffectApplyAuraName array, or // null if it applies no control-loss aura. Priority-ordered (strongest control // first) so a multi-effect spell resolves to one locType, matching retail. const char *ClassifyControlLoss(const uint8_t *rec) { const int32_t *aura = reinterpret_cast( rec + Offsets::OFF_SPELL_RECORD_EFFECT_APPLY_AURA_NAME); auto has = [&](int type) { for (int i = 0; i < Offsets::SPELL_RECORD_EFFECT_COUNT; ++i) if (aura[i] == type) return true; return false; }; if (has(Offsets::SPELL_AURA_MOD_POSSESS)) return "POSSESS"; if (has(Offsets::SPELL_AURA_MOD_CHARM)) return "CHARM"; if (has(Offsets::SPELL_AURA_MOD_STUN)) return "STUN"; if (has(Offsets::SPELL_AURA_MOD_FEAR)) return "FEAR"; if (has(Offsets::SPELL_AURA_MOD_CONFUSE)) return "CONFUSE"; if (has(Offsets::SPELL_AURA_MOD_PACIFY_SILENCE)) return "PACIFYSILENCE"; if (has(Offsets::SPELL_AURA_MOD_SILENCE)) return "SILENCE"; if (has(Offsets::SPELL_AURA_MOD_PACIFY)) return "PACIFY"; if (has(Offsets::SPELL_AURA_MOD_ROOT)) return "ROOT"; if (has(Offsets::SPELL_AURA_MOD_DISARM)) return "DISARM"; return nullptr; } // ---- School-interrupt lockout state (fed by the SMSG_SPELL_COOLDOWN hook) -- // One active lockout per school index (0..6); active while now < endMs. // Self-expiring, per-process — a stale entry from before a relog is already // in the past on the shared uptime clock, so no reset is needed. struct SchoolLock { int startMs; int endMs; }; SchoolLock g_schoolLock[Offsets::SPELL_SCHOOL_COUNT] = {}; using CooldownHandler_t = int(__stdcall *)(uint32_t *opCode, Net::CDataStore *packet); CooldownHandler_t g_origCooldown = nullptr; int __stdcall Cooldown_h(uint32_t *opCode, Net::CDataStore *packet) { if (packet != nullptr) { const uint32_t saved = packet->m_read; const uint64_t guid = Net::Read(packet); if (guid != 0 && guid == Unit::Identity::PlayerGuid()) { int count = 0; int firstDur = 0; bool uniform = true; int schoolIdx = -1; while (packet->m_read + 8 <= packet->m_size && count < 256) { const uint32_t spellID = Net::Read(packet); const int dur = static_cast(Net::Read(packet)); if (count == 0) firstDur = dur; else if (dur != firstDur) uniform = false; if (schoolIdx < 0) { const uint8_t *rec = Spell::Lookup::RecordForID(static_cast(spellID)); if (rec != nullptr) { const int s = SpellSchoolIndex(rec); if (s >= 0 && s < Offsets::SPELL_SCHOOL_COUNT) schoolIdx = s; } } ++count; } // A uniform-duration batch of >=2 same-school spells is a school // lockout (ProhibitSpellSchool); single/varied packets are normal // cooldowns and ignored. if (count >= 2 && uniform && firstDur > 0 && schoolIdx >= 0) { const int now = NowMs(); g_schoolLock[schoolIdx].startMs = now; g_schoolLock[schoolIdx].endMs = now + firstDur; } } packet->m_read = saved; // restore before the engine re-parses } return g_origCooldown(opCode, packet); } const Game::HookAutoRegister _cooldownHook{ Offsets::FUN_SPELL_COOLDOWN_HANDLER, reinterpret_cast(&Cooldown_h), reinterpret_cast(&g_origCooldown)}; // ---- Aggregated active-effect list ---------------------------------------- struct LocEntry { const char *locType; int spellID; // 0 = unknown (school interrupt) const uint8_t *rec; // spell record for name/icon; null for school interrupt int schoolMask; // lockoutSchool int startMs; // 0 = unknown int endMs; // 0 = unknown / no timing }; int BuildList(LocEntry *out, int maxOut) { const int now = NowMs(); int n = 0; // School-interrupt lockouts first. for (int s = 0; s < Offsets::SPELL_SCHOOL_COUNT && n < maxOut; ++s) { if (g_schoolLock[s].endMs != 0 && now < g_schoolLock[s].endMs) { LocEntry &e = out[n++]; e.locType = "SCHOOL_INTERRUPT"; e.spellID = 0; e.rec = nullptr; e.schoolMask = 1 << s; e.startMs = g_schoolLock[s].startMs; e.endMs = g_schoolLock[s].endMs; } } // CC debuffs on the player. const uint8_t *player = Unit::Identity::PlayerObject(); if (player != nullptr) { const uint64_t playerGuid = Unit::Identity::PlayerGuid(); for (int i = 1; n < maxOut; ++i) { const int slot = Aura::Data::FindNthSlot( player, i, Aura::Data::Filter::Harmful, false); if (slot < 0) break; const uint32_t spellID = Aura::Data::ReadSpellID(player, slot); if (spellID == 0) continue; const uint8_t *rec = Spell::Lookup::RecordForID(static_cast(spellID)); if (rec == nullptr) continue; const char *locType = ClassifyControlLoss(rec); if (locType == nullptr) continue; LocEntry &e = out[n++]; e.locType = locType; e.spellID = static_cast(spellID); e.rec = rec; e.schoolMask = 0; e.startMs = 0; e.endMs = 0; uint64_t caster = 0; uint32_t expMs = 0, durMs = 0; if (Aura::Source::Get(playerGuid, spellID, &caster, &expMs, &durMs) && expMs != 0) { e.endMs = static_cast(expMs); if (durMs != 0) e.startMs = static_cast(expMs - durMs); } } } return n; } // ---- LOSS_OF_CONTROL_ADDED / _UPDATE events (WorldTick poll-and-diff) ------ // // Effect *expiry* (a school lockout timing out, a CC aura falling off) has no // engine packet or callback, so a per-frame diff is the only complete signal. // Firing from the WorldTick tail also keeps the Lua handlers out of the // mid-packet contexts the state is updated in (the OnTooltipSetItem fire-safety // lesson). The scan is bounded (16 debuff slots) and early-outs when idle, so // the per-frame cost is negligible. constexpr const char *kEventAdded = "LOSS_OF_CONTROL_ADDED"; constexpr const char *kEventUpdate = "LOSS_OF_CONTROL_UPDATE"; // Identity of an active effect for frame-to-frame diffing: a CC is keyed by // spellID, a school interrupt by its school mask (spellID 0). struct EffectKey { int spellID; int schoolMask; }; EffectKey g_prev[32]; int g_prevCount = 0; bool ContainsKey(const EffectKey *list, int count, EffectKey key) { for (int i = 0; i < count; ++i) if (list[i].spellID == key.spellID && list[i].schoolMask == key.schoolMask) return true; return false; } void OnWorldTick() { LocEntry entries[32]; const int n = BuildList(entries, 32); EffectKey cur[32]; for (int i = 0; i < n; ++i) cur[i] = EffectKey{entries[i].spellID, entries[i].schoolMask}; bool changed = false; for (int i = 0; i < n; ++i) { if (!ContainsKey(g_prev, g_prevCount, cur[i])) { // A newly-applied effect -> LOSS_OF_CONTROL_ADDED(eventIndex). Event::Custom::Fire(Event::Custom::Lookup(kEventAdded), "%d", i + 1); changed = true; } } for (int i = 0; i < g_prevCount && !changed; ++i) { if (!ContainsKey(cur, n, g_prev[i])) changed = true; // an effect ended (fell off / lockout expired) } // Any add or removal fires one coalesced "re-scan" signal. The payload is // the affected unit — always "player" here (vanilla only exposes the local // player's control-loss state), but passing it keeps the event shape // forward-compatible with per-unit tracking and matches modern WoW, whose // LOSS_OF_CONTROL_UPDATE carries the unit token. if (changed) Event::Custom::Fire(Event::Custom::Lookup(kEventUpdate), "%s", "player"); for (int i = 0; i < n; ++i) g_prev[i] = cur[i]; g_prevCount = n; } static const Event::Custom::AutoReserve _reserveAdded{kEventAdded}; static const Event::Custom::AutoReserve _reserveUpdate{kEventUpdate}; static const Tick::WorldTick::AutoSubscribe _tick{&OnWorldTick}; // `C_LossOfControl.GetActiveLossOfControlDataCount()` -> number. int __fastcall Script_GetActiveLossOfControlDataCount(void *L) { LocEntry entries[32]; const int n = BuildList(entries, 32); Game::Lua::PushNumber(L, static_cast(n)); return 1; } // `C_LossOfControl.GetActiveLossOfControlData(index)` -> LossOfControlData, or // nil if index is out of range. int __fastcall Script_GetActiveLossOfControlData(void *L) { if (!Game::Lua::IsNumber(L, 1)) { Game::Lua::Error( L, "Usage: C_LossOfControl.GetActiveLossOfControlData(index)"); return 0; } const int index = static_cast(Game::Lua::ToNumber(L, 1)); LocEntry entries[32]; const int n = BuildList(entries, 32); if (index < 1 || index > n) return 0; // nil const LocEntry &e = entries[index - 1]; const int now = NowMs(); Game::Lua::NewTable(L); Game::Lua::SetFieldString(L, "locType", e.locType); Game::Lua::SetFieldNumber(L, "spellID", static_cast(e.spellID)); Game::Lua::SetFieldString( L, "displayText", (e.rec != nullptr) ? SpellName(e.rec) : "Interrupted"); Game::Lua::SetFieldString( L, "iconTexture", (e.rec != nullptr) ? SpellIconPath(e.rec) : ""); // Timing (seconds, GetTime() epoch). Nullable — leave a field unset (nil) // when we don't know it, per the modern contract. if (e.endMs != 0 && now < e.endMs) { Game::Lua::SetFieldNumber(L, "timeRemaining", (e.endMs - now) * 0.001); if (e.startMs != 0) { Game::Lua::SetFieldNumber(L, "startTime", e.startMs * 0.001); Game::Lua::SetFieldNumber(L, "duration", (e.endMs - e.startMs) * 0.001); } } Game::Lua::SetFieldNumber(L, "lockoutSchool", static_cast(e.schoolMask)); Game::Lua::SetFieldNumber(L, "priority", 0); Game::Lua::SetFieldNumber(L, "displayType", 2); // show for full duration // auraInstanceID: nil (vanilla has no aura instance IDs) — field omitted. return 1; } } // namespace static void RegisterLuaFunctions() { Game::Lua::RegisterTableFunction( "C_LossOfControl", "GetActiveLossOfControlDataCount", &Script_GetActiveLossOfControlDataCount); Game::Lua::RegisterTableFunction("C_LossOfControl", "GetActiveLossOfControlData", &Script_GetActiveLossOfControlData); } static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; } // namespace LossOfControl