diff --git a/docs/API.md b/docs/API.md index bdeecbc7..c5eb6afc 100644 --- a/docs/API.md +++ b/docs/API.md @@ -13717,7 +13717,7 @@ end **Filter tokens.** `filter` uses the modern AuraFilters format: tokens separated by `|` or spaces, each token optionally negated with a -leading `!`. This build honors two: +leading `!`. This build honors: - `HELPFUL` / `HARMFUL` — buffs / debuffs. With neither token the query returns both (the indexed getter defaults to helpful). @@ -13725,8 +13725,12 @@ leading `!`. This build honors two: auras the player did not cast. Caster data comes from casts this session, so an aura present before you saw it cast has no caster and counts as not-player. +- `DISPELLABLE` / `!DISPELLABLE` — only auras that can be dispelled, + purged, or stolen (dispel type Magic, Curse, Disease, or Poison), or + only auras that cannot. This is "can it be removed at all", not "can + you remove it". -All other AuraFilters tokens (`RAID`, `CANCELABLE`, `DISPELLABLE`, +All other AuraFilters tokens (`RAID`, `CANCELABLE`, `INCLUDE_NAME_PLATE_ONLY`, `MAW`, and the rest) are accepted and ignored — vanilla has no data for them. Token matching is whole-token, so `RAID_PLAYER_DISPELLABLE` is not read as `PLAYER`. diff --git a/src/aura/Api.cpp b/src/aura/Api.cpp index c9c5920a..fcbe64e0 100644 --- a/src/aura/Api.cpp +++ b/src/aura/Api.cpp @@ -21,11 +21,14 @@ // tokens separated by `|` and/or whitespace, each optionally negated with a // leading `!`. Whole-token matching, so `RAID_PLAYER_DISPELLABLE` is not // mistaken for `PLAYER` and `!PLAYER` is a negation rather than a match. -// Honored: `HELPFUL` / `HARMFUL` (descriptor slot ranges) and `PLAYER` / -// `!PLAYER` (caster == / != the local player, from the Aura::Source cache). -// Every other modern token (`RAID`, `CANCELABLE`, `DISPELLABLE`, -// `INCLUDE_NAME_PLATE_ONLY`, `MAW`, …) is accepted and ignored — they need a -// class-dispel matrix or systems vanilla has no data for. +// Honored: `HELPFUL` / `HARMFUL` (descriptor slot ranges), `PLAYER` / +// `!PLAYER` (caster == / != the local player, from the Aura::Source cache), +// and `DISPELLABLE` / `!DISPELLABLE` (dispel type is / isn't one a +// dispel/purge/steal can remove — Spell.dbc Dispel ∈ Magic/Curse/Disease/ +// Poison, matching the server's DISPEL_ALL_MASK). Every other modern token +// (`RAID`, `CANCELABLE`, `INCLUDE_NAME_PLATE_ONLY`, `MAW`, …) is accepted and +// ignored — they need a class-dispel matrix or systems vanilla has no data +// for. #include "Data.h" @@ -70,6 +73,9 @@ struct ParsedFilter { bool helpful = false; bool harmful = false; Data::CasterMode caster = Data::CasterMode::Any; + Data::DispelMode dispel = Data::DispelMode::Any; + + Data::Match ToMatch() const { return Data::Match{caster, dispel}; } }; // Reduces the parsed range tokens to the single `Data::Filter` the indexed / @@ -116,6 +122,9 @@ ParsedFilter ParseFilters(const char *filter) { else if (strcmp(tok, "PLAYER") == 0) out.caster = negate ? Data::CasterMode::NotPlayer : Data::CasterMode::PlayerOnly; + else if (strcmp(tok, "DISPELLABLE") == 0) + out.dispel = negate ? Data::DispelMode::NotDispellable + : Data::DispelMode::DispellableOnly; // else: accepted and ignored (retail-only / unimplemented token). } return out; @@ -143,11 +152,10 @@ const char *ArgOptString(void *L, int idx) { // or nil if no such aura. Used by `GetAuraDataByIndex` and the // filter-locked aliases. int PushAuraByIndex(void *L, const char *unitToken, int index, - Data::Filter filter, - Data::CasterMode caster = Data::CasterMode::Any) { + Data::Filter filter, Data::Match match = {}) { const uint8_t *unit = ResolveUnit(unitToken); if (unit != nullptr) { - const int slot = Data::FindNthSlot(unit, index, filter, caster); + const int slot = Data::FindNthSlot(unit, index, filter, match); if (slot >= 0) { Data::Push(L, unit, slot); return 1; @@ -155,14 +163,14 @@ int PushAuraByIndex(void *L, const char *unitToken, int index, // Descriptor exhausted — an aura the engine dropped from the slot array // (rogue stealth, nearby party range fluctuation) may still be live in // the Aura::Source cache. Surface it after the descriptor entries. - if (Data::PushNthCacheFallback(L, unit, index, filter, caster)) + if (Data::PushNthCacheFallback(L, unit, index, filter, match)) return 1; } else { // No live CGUnit — an out-of-range / cross-map groupmate. The server // still sends their aura spell IDs via SMSG_PARTY_MEMBER_STATS; read // them the same way the built-in UnitBuff/UnitDebuff do. if (Data::PushNthGroupAura(L, GuidForOutOfRange(unitToken), index, - filter, caster)) + filter, match)) return 1; } Game::Lua::PushNil(L); @@ -178,7 +186,7 @@ int __fastcall Script_GetAuraDataByIndex(void *L) { return 1; } const ParsedFilter pf = ParseFilters(filterStr); - return PushAuraByIndex(L, unit, index, RangeFilter(pf), pf.caster); + return PushAuraByIndex(L, unit, index, RangeFilter(pf), pf.ToMatch()); } int __fastcall Script_GetBuffDataByIndex(void *L) { @@ -215,14 +223,14 @@ int __fastcall Script_GetUnitAuraBySpellID(void *L) { const Data::Filter *fp = (pf.helpful || pf.harmful) ? &f : nullptr; if (unit != nullptr) { const int slot = Data::FindSlotBySpellID( - unit, static_cast(spellID), fp, pf.caster); + unit, static_cast(spellID), fp, pf.ToMatch()); if (slot >= 0) { Data::Push(L, unit, slot); return 1; } } else if (Data::PushGroupAuraBySpellID(L, GuidForOutOfRange(unitToken), static_cast(spellID), fp, - pf.caster)) { + pf.ToMatch())) { // Out-of-range groupmate — read from the group-member aura array. return 1; } @@ -243,13 +251,13 @@ int __fastcall Script_GetAuraDataBySpellName(void *L) { Data::Filter f = RangeFilter(pf); const Data::Filter *fp = (pf.helpful || pf.harmful) ? &f : nullptr; if (unit != nullptr) { - const int slot = Data::FindSlotBySpellName(unit, spellName, fp, pf.caster); + const int slot = Data::FindSlotBySpellName(unit, spellName, fp, pf.ToMatch()); if (slot >= 0) { Data::Push(L, unit, slot); return 1; } } else if (Data::PushGroupAuraBySpellName(L, GuidForOutOfRange(unitToken), - spellName, fp, pf.caster)) { + spellName, fp, pf.ToMatch())) { // Out-of-range groupmate — read from the group-member aura array. return 1; } @@ -277,8 +285,7 @@ int __fastcall Script_GetPlayerAuraBySpellID(void *L) { // sequential keys starting from `nextKey`. Updates `nextKey` so a // follow-up call can append to the same outer table. void AppendRangeToArray(void *L, const uint8_t *unit, int outerIdx, - Data::Filter filter, int &nextKey, - Data::CasterMode caster) { + Data::Filter filter, int &nextKey, Data::Match match) { const int start = (filter == Data::Filter::Harmful) ? Offsets::UNIT_AURA_BUFF_COUNT : 0; @@ -288,14 +295,15 @@ void AppendRangeToArray(void *L, const uint8_t *unit, int outerIdx, for (int slot = start; slot < end; ++slot) { if (!Data::IsSlotPopulated(unit, slot)) continue; - if (!Data::CasterMatches(caster, Data::IsPlayerCast(unit, slot))) + if (!Data::MatchesAura(match, Data::IsPlayerCast(unit, slot), + Data::ReadSpellID(unit, slot))) continue; Game::Lua::PushNumber(L, static_cast(nextKey++)); Data::Push(L, unit, slot); Game::Lua::SetTable(L, outerIdx); } // Append auras the descriptor dropped but Aura::Source still has live. - Data::AppendCacheFallbacks(L, unit, filter, caster, outerIdx, nextKey); + Data::AppendCacheFallbacks(L, unit, filter, match, outerIdx, nextKey); } int __fastcall Script_GetUnitAuras(void *L) { @@ -315,18 +323,18 @@ int __fastcall Script_GetUnitAuras(void *L) { int nextKey = 1; if (unit != nullptr) { if (pf.helpful || both) - AppendRangeToArray(L, unit, 1, Data::Filter::Helpful, nextKey, pf.caster); + AppendRangeToArray(L, unit, 1, Data::Filter::Helpful, nextKey, pf.ToMatch()); if (pf.harmful || both) - AppendRangeToArray(L, unit, 1, Data::Filter::Harmful, nextKey, pf.caster); + AppendRangeToArray(L, unit, 1, Data::Filter::Harmful, nextKey, pf.ToMatch()); } else { // No live CGUnit — out-of-range / cross-map groupmate. Enumerate the // group-member aura array (spell IDs the server still transmits), the // same source the built-in UnitBuff/UnitDebuff read out of range. const uint64_t guid = GuidForOutOfRange(unitToken); if (pf.helpful || both) - Data::AppendGroupAuras(L, guid, Data::Filter::Helpful, pf.caster, 1, nextKey); + Data::AppendGroupAuras(L, guid, Data::Filter::Helpful, pf.ToMatch(), 1, nextKey); if (pf.harmful || both) - Data::AppendGroupAuras(L, guid, Data::Filter::Harmful, pf.caster, 1, nextKey); + Data::AppendGroupAuras(L, guid, Data::Filter::Harmful, pf.ToMatch(), 1, nextKey); } return 1; } diff --git a/src/aura/Data.cpp b/src/aura/Data.cpp index 752b03f1..b9e36b71 100644 --- a/src/aura/Data.cpp +++ b/src/aura/Data.cpp @@ -268,6 +268,31 @@ bool CasterMatches(CasterMode caster, bool isPlayerCast) { } } +bool IsDispellable(uint32_t spellID) { + const uint8_t *rec = SpellRecord(spellID); + if (rec == nullptr) + return false; + const uint32_t dispelType = *reinterpret_cast( + rec + Offsets::OFF_SPELL_DISPEL_TYPE); + // Magic(1) / Curse(2) / Disease(3) / Poison(4) — the server's + // DISPEL_ALL_MASK. None(0) / Stealth(5) / Invisibility(6) / Enrage(9) + // etc. are not dispellable by any mechanism. + return dispelType >= 1 && dispelType <= 4; +} + +bool DispelMatches(DispelMode dispel, uint32_t spellID) { + switch (dispel) { + case DispelMode::DispellableOnly: return IsDispellable(spellID); + case DispelMode::NotDispellable: return !IsDispellable(spellID); + default: return true; // Any + } +} + +bool MatchesAura(const Match &match, bool isPlayerCast, uint32_t spellID) { + return CasterMatches(match.caster, isPlayerCast) && + DispelMatches(match.dispel, spellID); +} + // Group-array analog of IsPlayerCast: the group aura carries no caster, so we // consult the Aura::Source cache by (guid, spellID). A miss counts as "not the // player" (same as IsPlayerCast). @@ -280,7 +305,7 @@ bool GroupIsPlayerCast(uint64_t guid, uint32_t spellID) { } int FindNthSlot(const uint8_t *unit, int oneBasedIndex, Filter filter, - CasterMode caster) { + Match match) { if (unit == nullptr || oneBasedIndex < 1) return -1; const int start = (filter == Filter::Harmful) @@ -293,7 +318,7 @@ int FindNthSlot(const uint8_t *unit, int oneBasedIndex, Filter filter, for (int slot = start; slot < end; ++slot) { if (!IsSlotPopulated(unit, slot)) continue; - if (!CasterMatches(caster, IsPlayerCast(unit, slot))) + if (!MatchesAura(match, IsPlayerCast(unit, slot), ReadSpellID(unit, slot))) continue; if (++matches == oneBasedIndex) return slot; @@ -302,7 +327,7 @@ int FindNthSlot(const uint8_t *unit, int oneBasedIndex, Filter filter, } int FindSlotBySpellID(const uint8_t *unit, uint32_t spellID, - const Filter *filter, CasterMode caster) { + const Filter *filter, Match match) { if (unit == nullptr || spellID == 0) return -1; const int start = (filter != nullptr && *filter == Filter::Harmful) @@ -316,7 +341,7 @@ int FindSlotBySpellID(const uint8_t *unit, uint32_t spellID, continue; if (ReadSpellID(unit, slot) != spellID) continue; - if (!CasterMatches(caster, IsPlayerCast(unit, slot))) + if (!MatchesAura(match, IsPlayerCast(unit, slot), ReadSpellID(unit, slot))) continue; return slot; } @@ -324,7 +349,7 @@ int FindSlotBySpellID(const uint8_t *unit, uint32_t spellID, } int FindSlotBySpellName(const uint8_t *unit, const char *spellName, - const Filter *filter, CasterMode caster) { + const Filter *filter, Match match) { if (unit == nullptr || spellName == nullptr || *spellName == '\0') return -1; const int start = (filter != nullptr && *filter == Filter::Harmful) @@ -339,7 +364,7 @@ int FindSlotBySpellName(const uint8_t *unit, const char *spellName, const char *name = LocalizedSpellName(SpellRecord(ReadSpellID(unit, slot))); if (name == nullptr || std::strcmp(name, spellName) != 0) continue; - if (!CasterMatches(caster, IsPlayerCast(unit, slot))) + if (!MatchesAura(match, IsPlayerCast(unit, slot), ReadSpellID(unit, slot))) continue; return slot; } @@ -570,7 +595,7 @@ bool DescriptorHasVisibleAura(const uint8_t *unit) { } // Counts populated descriptor slots matching `filter` (and `caster`). -int CountSlots(const uint8_t *unit, Filter filter, CasterMode caster) { +int CountSlots(const uint8_t *unit, Filter filter, Match match) { if (unit == nullptr) return 0; const int start = (filter == Filter::Harmful) @@ -582,7 +607,7 @@ int CountSlots(const uint8_t *unit, Filter filter, CasterMode caster) { for (int slot = start; slot < end; ++slot) { if (!IsSlotPopulated(unit, slot)) continue; - if (!CasterMatches(caster, IsPlayerCast(unit, slot))) + if (!MatchesAura(match, IsPlayerCast(unit, slot), ReadSpellID(unit, slot))) continue; ++n; } @@ -598,15 +623,15 @@ constexpr int kFallbackMax = Offsets::UNIT_AURA_TOTAL; // dispelled auras are kept out of the cache by `Aura::Source`'s removal // eviction, not filtered here. bool FallbackEligible(const uint8_t *unit, const Aura::Source::CachedAura &c, - Filter filter, CasterMode caster) { + Filter filter, Match match) { if (!IsVisible(SpellRecord(c.spellId))) return false; // hidden/internal aura (e.g. SPELL_ATTR_HIDDEN_CLIENTSIDE): // the descriptor path drops these via IsSlotPopulated, so // the cache path must apply the same engine predicate or // they leak through as tooltip-less phantom buffs. - if (FindSlotBySpellID(unit, c.spellId, &filter, CasterMode::Any) >= 0) + if (FindSlotBySpellID(unit, c.spellId, &filter, Match{}) >= 0) return false; // still in the descriptor — returned via the slot path - if (!CasterMatches(caster, c.casterGuid == Unit::Identity::PlayerGuid())) + if (!MatchesAura(match, c.casterGuid == Unit::Identity::PlayerGuid(), c.spellId)) return false; return true; } @@ -614,7 +639,7 @@ bool FallbackEligible(const uint8_t *unit, const Aura::Source::CachedAura &c, } // namespace bool PushNthCacheFallback(void *L, const uint8_t *unit, int oneBasedIndex, - Filter filter, CasterMode caster) { + Filter filter, Match match) { if (unit == nullptr) return false; ReconcileCache(unit); // drop entries the (synced) descriptor contradicts @@ -623,7 +648,7 @@ bool PushNthCacheFallback(void *L, const uint8_t *unit, int oneBasedIndex, // The descriptor held `descCount` matches; the caller already found fewer // than `oneBasedIndex` there, so the cache supplies index // `oneBasedIndex - descCount` (1-based) of the entries it didn't. - const int target = oneBasedIndex - CountSlots(unit, filter, caster); + const int target = oneBasedIndex - CountSlots(unit, filter, match); if (target < 1) return false; const uint64_t guid = UnitGuid(unit); @@ -634,7 +659,7 @@ bool PushNthCacheFallback(void *L, const uint8_t *unit, int oneBasedIndex, guid, filter == Filter::Harmful, buf, kFallbackMax); int seen = 0; for (int i = 0; i < n; ++i) { - if (!FallbackEligible(unit, buf[i], filter, caster)) + if (!FallbackEligible(unit, buf[i], filter, match)) continue; if (++seen == target) { PushFromCache(L, unit, buf[i], filter == Filter::Helpful); @@ -645,7 +670,7 @@ bool PushNthCacheFallback(void *L, const uint8_t *unit, int oneBasedIndex, } void AppendCacheFallbacks(void *L, const uint8_t *unit, Filter filter, - CasterMode caster, int outerIdx, int &nextKey) { + Match match, int outerIdx, int &nextKey) { if (unit == nullptr) return; ReconcileCache(unit); // drop entries the (synced) descriptor contradicts @@ -658,7 +683,7 @@ void AppendCacheFallbacks(void *L, const uint8_t *unit, Filter filter, const int n = Aura::Source::Enumerate( guid, filter == Filter::Harmful, buf, kFallbackMax); for (int i = 0; i < n; ++i) { - if (!FallbackEligible(unit, buf[i], filter, caster)) + if (!FallbackEligible(unit, buf[i], filter, match)) continue; Game::Lua::PushNumber(L, static_cast(nextKey++)); PushFromCache(L, unit, buf[i], filter == Filter::Helpful); @@ -693,11 +718,11 @@ uint32_t GroupSpellID(const uint16_t *arr, int slot) { // cast to the local player (a miss excludes it — we can't confirm the caster // from the group array alone). bool GroupSlotEligible(uint64_t guid, const uint16_t *arr, int slot, - CasterMode caster) { + Match match) { const uint32_t id = GroupSpellID(arr, slot); if (id == 0 || !IsVisible(SpellRecord(id))) return false; - if (!CasterMatches(caster, GroupIsPlayerCast(guid, id))) + if (!MatchesAura(match, GroupIsPlayerCast(guid, id), id)) return false; return true; } @@ -730,13 +755,13 @@ bool GroupArrayHasVisibleAura(const uint16_t *arr) { // aura, not already present in the array, and — when player-filtered — cast by // us. See GroupArrayHasVisibleAura for when this path runs. bool GroupFallbackEligible(const uint16_t *arr, const Aura::Source::CachedAura &c, - CasterMode caster) { + Match match) { if (!IsVisible(SpellRecord(c.spellId))) return false; for (int slot = 0; slot < Offsets::UNIT_AURA_TOTAL; ++slot) if (GroupSpellID(arr, slot) == c.spellId) return false; - if (!CasterMatches(caster, c.casterGuid == Unit::Identity::PlayerGuid())) + if (!MatchesAura(match, c.casterGuid == Unit::Identity::PlayerGuid(), c.spellId)) return false; return true; } @@ -744,13 +769,13 @@ bool GroupFallbackEligible(const uint16_t *arr, const Aura::Source::CachedAura & // Nth (1-based) cache-fallback aura of `filter`'s kind for an out-of-range // member whose group array is empty. Pushes the AuraData table on a hit. bool PushNthGroupCacheFallback(void *L, uint64_t guid, const uint16_t *arr, - int oneBasedIndex, Filter filter, CasterMode caster) { + int oneBasedIndex, Filter filter, Match match) { Aura::Source::CachedAura buf[kFallbackMax]; const int n = Aura::Source::Enumerate(guid, filter == Filter::Harmful, buf, kFallbackMax); int seen = 0; for (int i = 0; i < n; ++i) { - if (!GroupFallbackEligible(arr, buf[i], caster)) + if (!GroupFallbackEligible(arr, buf[i], match)) continue; if (++seen == oneBasedIndex) { PushEnriched(L, guid, buf[i].spellId, filter == Filter::Helpful, 1, @@ -763,14 +788,14 @@ bool PushNthGroupCacheFallback(void *L, uint64_t guid, const uint16_t *arr, // Append every cache-fallback aura of `filter`'s kind into the array table. void AppendGroupCacheFallbacks(void *L, uint64_t guid, const uint16_t *arr, - Filter filter, CasterMode caster, int outerIdx, + Filter filter, Match match, int outerIdx, int &nextKey) { Aura::Source::CachedAura buf[kFallbackMax]; const int n = Aura::Source::Enumerate(guid, filter == Filter::Harmful, buf, kFallbackMax); const int level = GroupMemberLevel(guid); for (int i = 0; i < n; ++i) { - if (!GroupFallbackEligible(arr, buf[i], caster)) + if (!GroupFallbackEligible(arr, buf[i], match)) continue; Game::Lua::PushNumber(L, static_cast(nextKey++)); PushEnriched(L, guid, buf[i].spellId, filter == Filter::Helpful, 1, level, @@ -783,7 +808,7 @@ void AppendGroupCacheFallbacks(void *L, uint64_t guid, const uint16_t *arr, // (when non-null), of the given kind. Backs the by-ID / by-name group queries. bool PushGroupCacheFallbackMatch(void *L, uint64_t guid, const uint16_t *arr, bool harmful, uint32_t spellID, - const char *spellName, CasterMode caster) { + const char *spellName, Match match) { Aura::Source::CachedAura buf[kFallbackMax]; const int n = Aura::Source::Enumerate(guid, harmful, buf, kFallbackMax); for (int i = 0; i < n; ++i) { @@ -794,7 +819,7 @@ bool PushGroupCacheFallbackMatch(void *L, uint64_t guid, const uint16_t *arr, if (nm == nullptr || std::strcmp(nm, spellName) != 0) continue; } - if (!GroupFallbackEligible(arr, buf[i], caster)) + if (!GroupFallbackEligible(arr, buf[i], match)) continue; PushEnriched(L, guid, buf[i].spellId, !harmful, 1, GroupMemberLevel(guid), false); @@ -806,7 +831,7 @@ bool PushGroupCacheFallbackMatch(void *L, uint64_t guid, const uint16_t *arr, } // namespace bool PushNthGroupAura(void *L, uint64_t guid, int oneBasedIndex, Filter filter, - CasterMode caster) { + Match match) { if (guid == 0 || oneBasedIndex < 1) return false; const uint16_t *arr = Group::MemberStats::AuraArray(guid); @@ -817,7 +842,7 @@ bool PushNthGroupAura(void *L, uint64_t guid, int oneBasedIndex, Filter filter, GroupRange(filter, start, end); int matches = 0; for (int slot = start; slot < end; ++slot) { - if (!GroupSlotEligible(guid, arr, slot, caster)) + if (!GroupSlotEligible(guid, arr, slot, match)) continue; if (++matches == oneBasedIndex) { PushEnriched(L, guid, GroupSpellID(arr, slot), @@ -829,12 +854,12 @@ bool PushNthGroupAura(void *L, uint64_t guid, int oneBasedIndex, Filter filter, // Empty array (server delta-resend gap): supplement from the cache. if (!GroupArrayHasVisibleAura(arr)) return PushNthGroupCacheFallback(L, guid, arr, oneBasedIndex, filter, - caster); + match); return false; } bool PushGroupAuraBySpellID(void *L, uint64_t guid, uint32_t spellID, - const Filter *filter, CasterMode caster) { + const Filter *filter, Match match) { if (guid == 0 || spellID == 0) return false; const uint16_t *arr = Group::MemberStats::AuraArray(guid); @@ -850,7 +875,7 @@ bool PushGroupAuraBySpellID(void *L, uint64_t guid, uint32_t spellID, for (int slot = start; slot < end; ++slot) { if (GroupSpellID(arr, slot) != spellID) continue; - if (!GroupSlotEligible(guid, arr, slot, caster)) + if (!GroupSlotEligible(guid, arr, slot, match)) continue; PushEnriched(L, guid, spellID, slot < Offsets::UNIT_AURA_BUFF_COUNT, 1, GroupMemberLevel(guid), false); @@ -860,18 +885,18 @@ bool PushGroupAuraBySpellID(void *L, uint64_t guid, uint32_t spellID, const bool both = (filter == nullptr); if ((both || *filter == Filter::Helpful) && PushGroupCacheFallbackMatch(L, guid, arr, false, spellID, nullptr, - caster)) + match)) return true; if ((both || *filter == Filter::Harmful) && PushGroupCacheFallbackMatch(L, guid, arr, true, spellID, nullptr, - caster)) + match)) return true; } return false; } bool PushGroupAuraBySpellName(void *L, uint64_t guid, const char *spellName, - const Filter *filter, CasterMode caster) { + const Filter *filter, Match match) { if (guid == 0 || spellName == nullptr || *spellName == '\0') return false; const uint16_t *arr = Group::MemberStats::AuraArray(guid); @@ -891,7 +916,7 @@ bool PushGroupAuraBySpellName(void *L, uint64_t guid, const char *spellName, const char *name = LocalizedSpellName(SpellRecord(id)); if (name == nullptr || std::strcmp(name, spellName) != 0) continue; - if (!GroupSlotEligible(guid, arr, slot, caster)) + if (!GroupSlotEligible(guid, arr, slot, match)) continue; PushEnriched(L, guid, id, slot < Offsets::UNIT_AURA_BUFF_COUNT, 1, GroupMemberLevel(guid), false); @@ -901,17 +926,17 @@ bool PushGroupAuraBySpellName(void *L, uint64_t guid, const char *spellName, const bool both = (filter == nullptr); if ((both || *filter == Filter::Helpful) && PushGroupCacheFallbackMatch(L, guid, arr, false, 0, spellName, - caster)) + match)) return true; if ((both || *filter == Filter::Harmful) && PushGroupCacheFallbackMatch(L, guid, arr, true, 0, spellName, - caster)) + match)) return true; } return false; } -void AppendGroupAuras(void *L, uint64_t guid, Filter filter, CasterMode caster, +void AppendGroupAuras(void *L, uint64_t guid, Filter filter, Match match, int outerIdx, int &nextKey) { if (guid == 0) return; @@ -923,7 +948,7 @@ void AppendGroupAuras(void *L, uint64_t guid, Filter filter, CasterMode caster, GroupRange(filter, start, end); const int level = GroupMemberLevel(guid); for (int slot = start; slot < end; ++slot) { - if (!GroupSlotEligible(guid, arr, slot, caster)) + if (!GroupSlotEligible(guid, arr, slot, match)) continue; Game::Lua::PushNumber(L, static_cast(nextKey++)); PushEnriched(L, guid, GroupSpellID(arr, slot), @@ -932,7 +957,7 @@ void AppendGroupAuras(void *L, uint64_t guid, Filter filter, CasterMode caster, } // Empty array (server delta-resend gap): supplement from the cache. if (!GroupArrayHasVisibleAura(arr)) - AppendGroupCacheFallbacks(L, guid, arr, filter, caster, outerIdx, + AppendGroupCacheFallbacks(L, guid, arr, filter, match, outerIdx, nextKey); } diff --git a/src/aura/Data.h b/src/aura/Data.h index 35a91843..a53e0ca7 100644 --- a/src/aura/Data.h +++ b/src/aura/Data.h @@ -41,6 +41,22 @@ enum class Filter { Helpful, Harmful }; // `NotPlayer` includes it — matching `IsPlayerCast`'s miss semantics). enum class CasterMode { Any, PlayerOnly, NotPlayer }; +// Restriction from the `DISPELLABLE` / `!DISPELLABLE` aura filter tokens. +// `Any` = no restriction; `DispellableOnly` = only auras that can be +// dispelled / purged / stolen by SOME mechanism (dispel type Magic, Curse, +// Disease, or Poison — the server's DISPEL_ALL_MASK); `NotDispellable` = the +// complement. "Regardless of whether the local player can dispel it" — +// matching the modern AuraFilters semantics. +enum class DispelMode { Any, DispellableOnly, NotDispellable }; + +// A parsed aura-filter's per-aura predicates (beyond the helpful/harmful +// range, which is the separate `Filter`). Extensible: new orthogonal filter +// dimensions add a field here rather than another function parameter. +struct Match { + CasterMode caster = CasterMode::Any; + DispelMode dispel = DispelMode::Any; +}; + // Reads the spell ID at the given absolute slot (0..47). Returns 0 // if the slot is empty or the unit pointer is null. uint32_t ReadSpellID(const uint8_t *unit, int slot); @@ -58,21 +74,21 @@ bool IsSlotPopulated(const uint8_t *unit, int slot); // UNIT_AURA_TOTAL-1 for Harmful. When `playerOnly` is true, only auras // the local player cast (per `IsPlayerCast`) are counted/returned. int FindNthSlot(const uint8_t *unit, int oneBasedIndex, Filter filter, - CasterMode caster = CasterMode::Any); + Match match = {}); // Finds the absolute slot of a populated aura with the given spell // ID, optionally restricted to one filter range. `filter` of // nullptr searches both ranges (helpful first, then harmful). // `playerOnly` restricts to player-cast auras. Returns -1 if not found. int FindSlotBySpellID(const uint8_t *unit, uint32_t spellID, - const Filter *filter, CasterMode caster = CasterMode::Any); + const Filter *filter, Match match = {}); // Finds the absolute slot of a populated aura whose locale-resolved // spell name exactly matches `spellName`. Case-sensitive. Otherwise // same semantics as `FindSlotBySpellID`. Returns -1 if not found // or if `spellName` is null/empty. int FindSlotBySpellName(const uint8_t *unit, const char *spellName, - const Filter *filter, CasterMode caster = CasterMode::Any); + const Filter *filter, Match match = {}); // True iff the aura at `slot` was cast by the local player, per the // `Aura::Source` cache. False on a cache miss (caster unknown) — so a @@ -83,6 +99,16 @@ bool IsPlayerCast(const uint8_t *unit, int slot); // `Any` → always true; `PlayerOnly` → the answer; `NotPlayer` → its negation. bool CasterMatches(CasterMode caster, bool isPlayerCast); +// True iff the spell's dispel type is one a dispel/purge/steal can remove — +// Magic, Curse, Disease, or Poison (`Spell.dbc` Dispel ∈ 1..4). None, +// Stealth, Invisibility, Enrage, etc. are not dispellable. Verified against +// the server's DISPEL_ALL_MASK. +bool IsDispellable(uint32_t spellID); + +// Applies a full `Match` (caster + dispel predicates) to one aura, given the +// per-aura "was cast by the local player" answer and its spell ID. +bool MatchesAura(const Match &match, bool isPlayerCast, uint32_t spellID); + // Display stack count for the given slot (engine stores stacks-1, // we add 1). Returns 0 if the unit is null. int ReadStacks(const uint8_t *unit, int slot); @@ -134,7 +160,7 @@ void Push(void *L, const uint8_t *unit, int slot); // helpful/harmful classification matches `filter` and that aren't already in a // populated descriptor slot are considered. bool PushNthCacheFallback(void *L, const uint8_t *unit, int oneBasedIndex, - Filter filter, CasterMode caster = CasterMode::Any); + Filter filter, Match match = {}); // Appends every eligible `Aura::Source` cache fallback for `unit` matching // `filter` into the array table at `outerIdx`, continuing from `nextKey` @@ -142,7 +168,7 @@ bool PushNthCacheFallback(void *L, const uint8_t *unit, int oneBasedIndex, // for `GetUnitAuras`. Skips entries already present in a populated descriptor // slot so it never double-lists. void AppendCacheFallbacks(void *L, const uint8_t *unit, Filter filter, - CasterMode caster, int outerIdx, int &nextKey); + Match match, int outerIdx, int &nextKey); // ── Out-of-range groupmate path ──────────────────────────────────────────── // @@ -166,23 +192,23 @@ void AppendCacheFallbacks(void *L, const uint8_t *unit, Filter filter, // matching `filter`. On a hit pushes the table and returns true; otherwise // pushes nothing and returns false (caller pushes nil). bool PushNthGroupAura(void *L, uint64_t guid, int oneBasedIndex, Filter filter, - CasterMode caster = CasterMode::Any); + Match match = {}); // Pushes AuraData for the group-array aura with `spellID` on `guid`, optionally // restricted to one filter range (nullptr = both, helpful first). Returns true // on a hit (table pushed), false otherwise (nothing pushed). bool PushGroupAuraBySpellID(void *L, uint64_t guid, uint32_t spellID, - const Filter *filter, CasterMode caster = CasterMode::Any); + const Filter *filter, Match match = {}); // As `PushGroupAuraBySpellID` but matched by locale-resolved spell name // (case-sensitive exact match), mirroring `FindSlotBySpellName`. bool PushGroupAuraBySpellName(void *L, uint64_t guid, const char *spellName, - const Filter *filter, CasterMode caster = CasterMode::Any); + const Filter *filter, Match match = {}); // Appends every group-array aura on `guid` matching `filter` into the array // table at `outerIdx`, continuing from `nextKey` (updated in place). The // bulk-enumeration analog of `PushNthGroupAura`, for `GetUnitAuras`. -void AppendGroupAuras(void *L, uint64_t guid, Filter filter, CasterMode caster, +void AppendGroupAuras(void *L, uint64_t guid, Filter filter, Match match, int outerIdx, int &nextKey); } // namespace Aura::Data diff --git a/src/lossofcontrol/Info.cpp b/src/lossofcontrol/Info.cpp index 377e68de..d2a69cb9 100644 --- a/src/lossofcontrol/Info.cpp +++ b/src/lossofcontrol/Info.cpp @@ -203,7 +203,7 @@ int BuildList(LocEntry *out, int maxOut) { 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, Aura::Data::CasterMode::Any); + player, i, Aura::Data::Filter::Harmful, Aura::Data::Match{}); if (slot < 0) break; const uint32_t spellID = Aura::Data::ReadSpellID(player, slot);