mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-15 23:50:38 +00:00
7caee620e81ae60d55d72b0c10a7c1997ebb35dd
18
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
7caee620e8 |
fix(aura): make C_UnitAuras sourceGUID persist and infer self-buff casters
Two changes so an aura's source stops vanishing: Pin observed casters. The WorldTick expiry sweep (and Store's slot reuse) dropped a cache entry once its computed expirationMs elapsed — but that time is only a base-duration estimate for non-player casters (we lack their mod tables), so a talent-extended debuff expired in the cache while still live on the target. The entry took the caster with it, and the descriptor path then rendered the aura with no sourceGUID. Now an entry whose aura the owning unit's live descriptor still lists is never timer-reclaimed (DescriptorListsAura resolves the GUID through the object manager); only genuinely orphaned entries — unit out of range / stealthed / despawned — expire. The fallback path already skips expired entries, so no phantom can resurface. PushEnriched also reports an already-elapsed cached expiration as unknown rather than a negative remaining time. Infer self-buff casters. On a caster miss (no cache entry, or one with no caster), a self-only-target aura can only have been self-cast, so the unit carrying it is its own source. Factor the record scan out of the C_Spell.IsSelfBuff Lua wrapper into Spell::IsSelfBuff::IsSelfBuff and call it from PushEnriched to recover sourceUnit/sourceGUID for pre-existing self-buffs we never saw applied. Caster is exact; timing stays unknown. |
||
|
|
8a434fea0e |
fix(aura): keep SMSG_SPELL_GO caster through the descriptor-sync race
C_UnitAuras dropped sourceGUID/sourceUnit for buffs cast by other units (e.g. a druid's Mark of the Wild / Gift of the Wild on the player). SMSG_SPELL_GO arrives before the SMSG_UPDATE_OBJECT that adds the aura to the target's descriptor. In that window an addon aura poll runs ReconcileCache, which calls EvictAbsent. The just-captured cache entry named an aura the descriptor did not list yet, so EvictAbsent dropped it and lost the caster. OnAuraAdded then recreated the entry with no caster, so sourceGUID stayed nil. Verified by trace: every "Store NEW caster=0x8" was followed at once by "EvictAbsent (had caster=0x8)". Give each cache entry a write timestamp (stampMs) and exempt entries younger than kEvictGraceMs (2s) from EvictAbsent. A real removal is far older and still gets dropped, and OnAuraRemoved evicts genuine removals directly, so stale-aura cleanup is unaffected. Verified in-game: a remote druid buff now reports sourceGUID; a self-cast buff still reports sourceGUID + sourceUnit="player". |
||
|
|
1da06d4a73 |
frame: attribute backport, modern script args, and SMSG hook consolidation (#13)
* frame: backport Frame:SetAttribute/GetAttribute + unit-frame mouseover/click Adds native SetAttribute / SetAttributeNoHandler / GetAttribute on the base Frame registry: a per-frame, case-insensitive value store with the 3.3.5 prefix/name/suffix getter precedence, stored on the frame's own Lua table. A `unit` attribute makes the frame a mouseover source. A WorldTick poll of the engine's mouse-focus frame (GetMouseFocus's global) calls the real mouseover setter (FUN_00492890) for its unit -- 1:1 with hovering the 3D model: model highlight, mouseover tooltip, UPDATE_MOUSEOVER_UNIT, and the native GUID slot. Stomp-proof (the engine's 3D-hover setter is event-driven) and independent of the frame's scripts, so an addon setting its own OnEnter can't break it. A `type1`/`type2`/`type` attribute installs a chained OnClick on that frame only (PCall-guarded, Button-only) that dispatches target / assist / focus on the unit at click time, then runs any prior handler. No global hooks: mouseover reads the mouse-focus global; clicks use the frame's own OnClick. Deliberately does NOT MinHook the button-click dispatcher (FUN_00779540) -- SuperWoW's click-casting owns that prologue and a second inline hook corrupts the trampoline (ERROR #132). * frame: extend attribute backport (one-verb click dispatcher + OnAttributeChanged) The `type*` click path now mirrors retail's SecureActionButton_OnClick: resolve ONE verb per click from the modifier/button-qualified `type` attribute and perform it, instead of a fixed `type1=target`. - Modifier/button resolution: `[alt-/ctrl-/shift-]type[1..5]` with prefix..name..suffix -> name..suffix -> name precedence, read from the live key state and the click's button. - Verbs: target (with the engine's default-interaction precedence - cast a pending spell / drop a cursor item on the unit instead of switching target), assist, focus, spell, stopcasting, macro, and menu. - Own-the-click: when a verb resolves we perform it and do NOT chain the frame's previous OnClick, so a configured `type1` no longer double- dispatches alongside an addon's own conditional click handler. - Self-healing wire: addons that re-SetScript OnClick (pfUI on every raid relayout) clobber our closure; WireOnClick re-wraps a clobbered Lua handler but skips its own C closure, so re-setting `type*` recovers without double-chaining. Dispatch goes straight to C++ where we own the code - no Lua round-trip through the global table: spell -> Spell::AtUnit::CastByName (a native unit-targeted cast; the unit's GUID is fed to the engine's dispatcher so there's no target juggling, and ground-target spells land at the unit's feet), focus -> Unit::Focus::Set, and the target verb's predicates -> Spell::AtCursor::IsPlacementActive / Cursor::Info::HasItem. Only genuine engine entries (TargetUnit/AssistUnit/SpellTargetUnit/DropItemOnUnit/ SpellStopCasting) and addon-provided functions still go through Lua globals. Spell::AtUnit gains a C++ header sharing its CastCore with the C_Spell.CastAtUnit Lua entry. macro verb: takes the content from the `macrotext`/`macro` attribute and prefers an addon-provided RunMacro (SuperCleveRoidMacros etc. - handles named macros and extended macro text), falling back to running the text natively when no RunMacro global is present. The native path runs each line through the stock FrameXML ChatEdit_ParseText via a throwaway edit-box (GetText closure + no-op __index), so it needs no addon. menu/togglemenu verb: pops the standard unit dropdown at the cursor via the new ClassicAPI_ToggleUnitMenu (Util/SecureUnitMenu.lua), resolving the unit -> menu type with Blizzard's own generic resolver (self->SELF, pet->PET, grouped player->PARTY, other player->PLAYER, NPC->RAID_TARGET_ICON). Keeps the FrameXML dropdown logic in Lua with the C side as a thin call. OnAttributeChanged is now a real SetScript/GetScript/HookScript-able frame script on every frame: SetAttribute fires it, SetAttributeNoHandler suppresses it. Made settable by co-hooking the base-frame script-name resolver FUN_0076a0d0 (the one every frame type delegates through) and handing back an external per-frame {handler, context} cell for that name - frames are immortal in 1.12, so the cell never goes stale. One hook does it (vs the tooltip OnTooltipSet* work's five) because we already own the firing side. 1.12 convention: the handler reads this = frame, arg1 = name, arg2 = value. Recursion-guarded so a handler may itself SetAttribute. * frame: add Frame:ClearAttribute (retail 11.2.0) `cleared = frame:ClearAttribute(name)` removes an attribute and returns whether it was set. Registered on the base Frame method registry next to SetAttribute/GetAttribute, so every frame has it. Routes through DoSet's nil-value path (removes the stored key, drops a `unit` mouseover binding) but does NOT fire OnAttributeChanged — verified against a live retail 11.2 client: SetAttribute fires the handler, ClearAttribute fires nothing, and the return is true for a set attribute / false when there was nothing to clear. * frame: store attributes in the Lua registry, hidden from Lua Attributes were kept as a subtable on the frame's own Lua table under a control-char key ("\1ClassicAPIAttributes"). That key, while collision- safe, is still enumerable via pairs(frame) and readable/writable from Lua. Move the store to registry[frame] in the Lua registry (LUA_REGISTRYINDEX), which has no _G path — so the attribute map is invisible to pairs(frame) and can't be read or tampered with from script, matching how retail keeps attributes C-side. Only PushSub changed (create/fetch now key the registry by the frame table); GetAttribute/DoSet/CopyAttr sit on top unchanged. 1.12 frames are immortal, so the strong registry key never leaks. The dead kAttrKey constant is removed. Verified in-game: SetAttribute/GetAttribute still round-trip, and a pairs(frame) scan no longer finds any ClassicAPI key. * frame: add the `item` click verb (SecureActionButton item action) type*="item" uses the modifier-qualified `item` attribute: - a "bag slot" string (e.g. "0 1") -> UseContainerItem(bag, slot); - otherwise an item name / itemID / link -> C_Item.UseItemByName(item, unit), passing the unit as the use target (self-use items ignore it, targeted ones like scrolls/bandages apply to it); - the deprecated `bag` + `slot` attributes are honored when `item` is unset. Both bag paths go through lua_call (new CallTableFunc2Str / CallGlobalNum2) rather than a direct C++ call: the item-use bag walk does SetTop(L, 0), so it needs its own Lua stack frame — a direct call would wipe the dispatcher's stack. (spell stays direct because Spell::AtUnit is stack-free; the helper comment records the distinction.) Retail's "bag slot" string is the preferred form; the deprecated per-attribute form is supported too. * docs: format the attribute click verbs as a table The verbs were one long paragraph of nested parentheticals - hard to scan. Replace it with a Verb | Extra attributes | Action table so each verb's inputs and behavior are legible at a glance. Content-equivalent; no API change. * frame: clear target on the `target` verb when unit is "none" Retail's SecureActionButton target action treats a "none" unit as "clear target". Match it: the `target` verb calls ClearTarget() when the resolved `unit` is "none" (case-insensitive), before the normal cursor/spell precedence. Mouseover already handles "none" implicitly (it resolves to GUID 0 = no unit). Docs' target-verb row updated. * frame: pass modern positional args to script handlers Vanilla always invokes frame-script handlers with zero Lua args; the handler reads this/arg1/event as globals. Modern addon ports write SetScript("OnMouseWheel", function(self, delta) ...) and get nothing. Co-hook both script runners -- FUN_FRAME_INVOKE_SCRIPT (no-arg scripts) and FUN_FRAME_RUN_SCRIPT_ARGS (scripts with values) -- and reimplement their pcall tail: keep the engine's exact this/argN global save-set- restore and message-handler errfunc, but additionally push self + arg1..argN as real positional arguments and pcall with nargs = 1+N. Purely additive: a zero-param vanilla handler ignores the extras and reads globals; a modern (self, delta) handler binds them. OnEvent gets (self, event, arg1..argN), detected structurally by matching the invoked handler ref against the frame OnEvent slot (frame+0x0C) -- exact, since each SetScript makes a distinct ref. Runtime switch SetModernScriptArgs()/GetModernScriptArgs(), default on; when off both detours are a straight passthrough to the original runner, which matters because FUN_FRAME_RUN_SCRIPT_ARGS is the hottest Lua path in the engine (every OnUpdate frame). Verified in-game across OnMouseWheel/OnClick/OnValueChanged/OnUpdate/OnEnter/OnLeave/OnEvent. * net: consolidate spell SMSG hooks onto one dispatch funnel The spell subsystem's per-opcode SMSG handlers (SpellGo, SpellStart, SpellDelayed, ChannelStart/Update, SpellFailure, SpellFailedOther, SpellCooldown) were each co-hooked directly -- and nampower (hadesmem) plus SuperWoW detour the same prologues. Two inline hookers on one prologue is the documented MinHook collision risk, and a whole-protocol bisect fingered exactly this cluster as the crash-suspect surface. Add Net::PacketDispatch: a receive-side mirror of Net::SendObserver that co-hooks the single incoming-SMSG dispatch funnel FUN_NET_MESSAGE_DISPATCH (0x00537AA0) -- a chokepoint nampower does NOT hook (it detours the leaf handlers) -- and fans each packet out to opcode subscribers with the cursor at the body and centralized save/restore. Migrate all eight handlers to subscribers: aura/Source (SpellGo, which re-decodes the packed guids + spellId the leaf handler used to hand it pre-decoded), spell/Cast (Start/Delayed/Channel*/Failure*), and lossofcontrol (Cooldown). The parse bodies are unchanged; only the hook site moved. Subscribers run before the engine's leaf handler instead of after a co-hook's original -- verified order-independent for all eight (self-contained cache/state updates; SpellGo's aura-application handoff rides a separate SMSG_UPDATE_OBJECT). Cuts the ClassicAPI-nampower shared spell prologues from 10 to 3 (the OnAura* method hooks, which have no packet chokepoint to relocate to). One hook on an uncontended function replaces eight on contended ones. Verified in-game: cast bars, channels (incl. Mind Control cast-then- channel), pushback, remote-cast interrupt eviction, and C_LossOfControl school lockouts all intact. * ScriptArgs is back to opt-in * frame: fix ScriptArgs comments to match opt-in default * frame/net: dedupe packet observers, reuse Lua/token helpers, fix attr edge cases Post-review cleanup of the attribute + SMSG-consolidation work. - net: extract the shared packet-observer plumbing (PacketObserver.h) — the intrusive subscriber list, Subscribe(), and the read-opcode / reset-cursor / fan-out / restore loop — so Net::PacketDispatch (SMSG, u16) and Net::SendObserver (CMSG, u32) each reduce to a one-line hook thunk over FanOutByOpcode<OpcodeT>. Drops the dead per-namespace Callback aliases rather than keeping them as compat shims. - Game::Lua: promote PushGlobalFunction / CallGlobal / CallGlobalString into the shared Lua helpers (a pattern several modules open-code); Frame attributes use them instead of private copies. - frame/Attributes: resolve unit tokens through Unit::Identity::GuidForToken (engine resolver + player fast-path) instead of a duplicate raw-cast wrapper. - frame/Attributes: wire the chained OnClick for every "type" action attribute the click resolver reads (IsTypeAttr: modifier prefixes + type1..type5), not just type/type1/type2 — a middle-click or modifier-only binding now installs. - frame/Attributes: FireAttributeChanged snapshots and restores the caller's arg1/arg2 around the fire, so calling SetAttribute from inside a running script handler no longer clobbers its globals. |
||
|
|
29e3dab24a |
UNIT_SPELLCAST_* event family + GUID unit tokens (#11)
* spell: backport UNIT_SPELLCAST_* events for the local player
Adds the TBC+ cast/channel events (START, STOP, DELAYED, SUCCEEDED,
INTERRUPTED, FAILED, SENT, CHANNEL_START, CHANNEL_UPDATE, CHANNEL_STOP)
for the player, so cast-bar / rotation addons written against the modern
signature work on 1.12. Each carries (unit, castGUID, spellID, spellName,
rank) -- SENT inserts `target` at arg2 -- with a synthesized modern-shape
castGUID (Cast-3-0-0-0-<spellID>-<castUID>) shared across all of a cast's
events so START pairs with STOP. arg1 is always "player" (player-only phase).
The events are derived, not independently tracked: Spell::Cast already
hooks every cast/channel path for UnitCastingInfo/UnitChannelInfo, so
Spell::CastEvents reuses that state.
- START/STOP/DELAYED/CHANNEL_START/STOP: polled from Cast's OnWorldTick
against the previous snapshot.
- SUCCEEDED: fired from the SMSG_SPELL_GO hook (covers instants too).
Deferred for channels so it lands after CHANNEL_START (modern order).
- INTERRUPTED/FAILED: split by result code in a Spell_C_SpellFailed
co-hook -- a started cast that aborts (kick/move/LoS) fires INTERRUPTED
(repeated per retry, reusing the cast guid); a pre-cast rejection fires
FAILED.
- SENT: minted from the CMSG_CAST_SPELL send, threading its castGUID
forward so all of a cast's events share one guid.
- CHANNEL_UPDATE: from a new MSG_CHANNEL_UPDATE co-hook, which also
re-anchors g_channel.endMs to the server's remaining time so channel
pushback (which shortens vanilla channels) shows in UnitChannelInfo.
Every fire is gated on Event::Custom::HasListeners (new), so the system
costs one pointer-compare per transition when no addon registers.
Supporting changes:
- Net::SendObserver: shared co-hook on the NetClient send funnel with an
AutoSubscribe list, so CastEvents (SENT) and ComboDuration (combo-point
capture) both watch outgoing packets without owning the hook. Extracted
from ComboDuration's private hook.
- Cast.cpp: player channel now self-expires at its computed endMs in the
poll (was cleared only by the ~1s-lagged +0x228 field, so CHANNEL_STOP
trailed the real end by ~1s); wrap-safe delta compare so a long-uptime
ms tick past 2^31 can't misfire it.
Player-only; remote-unit fan-out, FAILED_QUIET, and empowered casts are
not implemented.
* spell: extend UNIT_SPELLCAST_* to non-player units (phase 2)
Fires the six observable cast/channel events -- START, STOP,
CHANNEL_START, CHANNEL_STOP, SUCCEEDED, INTERRUPTED -- for other units,
not just the player. Each is fanned out once per unit token currently
mapping to the caster (target / focus / nameplateN / party / raid / pet /
mouseover), so a target frame, a party frame, and a nameplate cast bar
all get their own event with a shared castGUID -- matching retail.
Token fan-out reuses the engine's own GUID->token reverse map
(FUN_00515c50, nampower's unfilled GetNamesFromGUID) for native tokens,
plus focus/nameplate which the engine can't see, via
Unit::Identity::TokensForGUID. SuperWoW's raw-GUID token ("0x...") is
filtered out so only standard tokens fan out.
Remote events are derived from Spell::Cast's existing packet hooks:
- START / CHANNEL_START from HandleSpellStart (SMSG_SPELL_START)
- SUCCEEDED from the SPELL_GO hook (Aura::Source)
- STOP / CHANNEL_STOP at the computed end, or on abort
- INTERRUPTED (casts only) from HandleCastAborted (ClearCastingSpell /
failure packets)
A per-caster state machine (PollRemote, from OnWorldTick) fires them in
modern order; a channel's SPELL_GO cast->channel ClearCastingSpell is
filtered so it doesn't self-interrupt at its own start.
Not fired for remotes (data is caster-only / client-local): SENT,
DELAYED, FAILED, CHANNEL_UPDATE.
Also in this change:
- castGUID follows type rule from https://warcraft.wiki.gg/wiki/GUID#Cast : real casts are Type 3 with a
time-based castUID (low 23 bits = UNIX second, high bits = per-second
counter, matching retail's structure), threaded across a cast's events
(player and remote converge on the same value); FAILED is Type 2 with
a flat incrementing integer.
- Channels never fire INTERRUPTED (player or remote) -- retail emits
only CHANNEL_STOP whether a channel completes or is cut short.
arg1 is the caster's unit token ("player" or another token); the
spellName / rank tail extensions are unchanged.
* spell: return the castGUID as UnitCastingInfo's castID
UnitCastingInfo / CastingInfo now return the cast's castGUID as castID
(return 7) instead of nil -- the same string the UNIT_SPELLCAST_* events
carry, so an addon can correlate the polled info with the events. It's
pulled from Spell::CastEvents (the single source of the castUID) via a new
CurrentCastGuid accessor, and works for the player and remote units. The
timing stays sourced from Spell::Cast -- only the castGUID crosses over,
so there's no duplication of cast state.
UnitChannelInfo is left retail-exact (no castID; channels don't carry
one), even though our channel events do include the shared castGUID.
Also corrects the spell-cast-GUID spec attribution in comments/docs to
warcraft.wiki.gg/wiki/GUID#Cast (it was wrongly credited to Wowhead).
* spell: add UNIT_SPELLCAST_RETICLE_TARGET / _CLEAR events
Backports the ground-target reticle events for the player:
RETICLE_TARGET when an AoE placement reticle comes up (Blizzard, Flare,
Rain of Fire, ...), RETICLE_CLEAR when it's cancelled. Args are
(unit, "", spellID, spellName, rank); arg1 is always "player".
Driven by polling the engine's targeting-flag global (0x00CECAC0 -- the
predicate behind SpellIsTargeting) from OnWorldTick: 0->nonzero fires
RETICLE_TARGET with the pending spellID (0x00CEAC58, written by
Spell_C_CastSpell); nonzero->0 fires RETICLE_CLEAR. CLEAR is suppressed
on placement (a CMSG_CAST_SPELL for the reticle spell went out, seen via
the shared send observer), so it fires only on a genuine cancel --
matching retail, which emits no CLEAR when the spell is placed/cast.
The castGUID slot (arg2) is "" rather than retail's nil: there's no cast
to identify yet, and the engine's event dispatcher can't emit a nil
mid-argument-list (a NULL %s corrupts the args after it -- the nil trick
only survives as the last arg). unit (arg1) and spellID (arg3) are exact.
* spell: fire UNIT_SPELLCAST_FAILED_QUIET for the quiet result whitelist
Vanilla's Spell_C_SpellFailed dropped SPELL_FAILED_DONT_REPORT silently.
Modern surfaces suppressed (no-error-text) failures as
UNIT_SPELLCAST_FAILED_QUIET rather than FAILED.
Verified against the 3.3.5 client's unit-spellcast dispatch (FUN_007fecc0),
which selects the QUIET event for a fixed 3-code whitelist, mapped to 1.12's
SpellCastResult enum (FUN_006e23e0):
CHARMED (0x14) . DONT_REPORT (0x17) . SPELL_IN_PROGRESS (0x61)
SPELL_IN_PROGRESS (casting while already casting / a nampower spell-queue
rejection) is the common case that previously mis-fired as a loud FAILED.
* unit: accept raw GUID literals as unit tokens
Fold a "0x<hex>" branch into the existing FUN_TOKEN_TO_GUID hook so every
Unit* function (UnitName, UnitHealth, UnitClass, UnitExists, ...) accepts a
64-bit GUID literal in place of a token. The parsed GUID goes straight to
the engine's own object-manager lookup (the path "player" takes), so an
unloaded/out-of-range GUID resolves to nil like any absent unit, no error.
Reuses the existing suffix walker, so "0x...target" composes.
Gated on SuperWoW's absence (GetModuleHandleA("SuperWoWhook.dll"), cached):
SuperWoW already provides GUID input via its own resolver hook, so when it
is loaded we defer to avoid two layers parsing the same string. Behaves
identically either way. Input direction only.
|
||
|
|
1f3f3cb9f6 |
aura: infer server-side DoT-duration changes from the triggering cast
C_UnitAuras expirationTime for a debuff on another unit is derived from
SMSG_SPELL_GO at cast time; the vanilla server never retransmits a LATER
server-side duration change on a non-self unit (verified in the server
source: SetAuraDuration/RefreshHolder, and UpdateAuraDuration is self-
scoped -- on a mob no packet is built at all). So a refresh/consume goes
stale in our cache. We can't hear the change, but we DO see the triggering
cast, so mirror the server's edit off that.
Aura::Source gains a rule engine applied in SpellGo_h (before the aura
gate -- triggers apply no aura themselves): a trigger matched by exact
spellID OR by SpellFamilyName + school index, an affected aura matched by
family + family-flag overlap (+ optional icon, rank-proof like the server
scripts), and an op (refresh/reduce/set/remove). Proc-applied affected
auras enter the cache unattributed (casterGuid 0); the rule accepts those
and attributes them to the trigger caster (also gives them a sourceUnit).
Lua: C_UnitAuras.RegisterAuraDurationModifier (exact-ID trigger) and
RegisterAuraDurationModifierByTrigger (family+school trigger), so the
server-specific ruleset lives in the addon, not the DLL.
Default Turtle ruleset (AuraDurationModifiers.lua, gated on
TURTLE_WOW_VERSION; IDs/flags DBC-verified):
Conflagrate -> reduce Immolate 3s
Molten Blast -> refresh Flame Shock
Shadow Weaving (5/5 talent 15334) -> priest shadow-school casts refresh
Shadow Vulnerability 15258 (covers the max-stack refresh blind spot;
Turtle reworked it, so stock DBC proc masks don't apply -- match by
school). Best-effort: DoT-tick procs emit no cast packet.
Carnage's roll-gated Rip/Rake refresh is deliberately excluded (the client
can't know the server roll).
Verified in-game (debug trace): Conflagrate/Molten Blast, and Mind Blast /
SW:P / Mind Flay all refresh 15258 with advancing expiration + sourceUnit.
|
||
|
|
60479677c1 |
aura: best-effort duration guess for out-of-range group/raid auras
An out-of-range party/raid member has no CGUnit and never yields SMSG_SPELL_GO, so the caster/duration cache never learned their auras' timing and expirationTime stayed 0. But SMSG_PARTY_MEMBER_STATS carries their aura spell IDs and the server sends it on change (SendUpdateToOutOfRangeGroupMembers flushes the moment an aura add/remove dirties the group mask), so a spell ID that newly appears in the group array did so ~one tick + latency after the real application. Aura::Source::ObserveGroupAuras (called from the group enumerate paths in Aura::Data) keeps a per-member snapshot of the last-seen spell-ID set and, on a genuine absent->present transition, stamps now + base duration into the same cache PushEnriched already reads. Covers party and raid alike (AuraArray reads the raid slot too; snapshot table sized for a 40-man). Base duration only (no remote caster mods) and no caster recorded (sourceUnit/GUID stay nil). Auras already present at first sight have unknown age and are not stamped; snapshots reset on map change and after 30s unpolled. The Store guard keeps any real SpellGo timing, so this never downgrades better data. |
||
|
|
e447c70ca3 |
aura: recover player-talented DoT duration in the application hooks
A player DoT with a duration talent (e.g. Improved Shadow Word: Pain, 2/2 -> 24s vs 18s base) intermittently showed the base duration. The displayed value is the Aura::Source cache entry's durationMs, which is computed two ways: SpellGo knows caster == player so it applies the player's duration mods (skipMod 0 -> 24s), while the OnAuraAdded / OnAuraStacksChanged application hooks have no caster and take the unmodified base (skipMod 1 -> 18s). Normally SpellGo owns the entry and the application hooks can't clobber it, but the base value wins whenever SpellGo can't land its talented value on THIS target's entry: an empty SMSG_SPELL_GO hit list files it under the caster instead (numTargets == 0), or a slot reshuffle evicts + refills the entry after SpellGo ran. Both are packet-order dependent, hence the flicker. Fix: SpellGo (which knows caster == player) records recent player aura casts by spellId; the application hooks recompute with skipMod 0 and attribute the caster when the spellId matches a recent player cast. Robust against both the attribution miss and the refill race, and leaves other units' auras on the base path (we lack their mod tables). |
||
|
|
a20e1206fb |
totem: add GetTotemInfo(slot) with a self-tracking totem subsystem
Vanilla 1.12 tracks nothing about totems client-side (the totem bar, PLAYER_TOTEM_UPDATE, and GetTotemInfo are all TBC additions), so Totem::Tracker tracks the four element slots itself — data-driven: - Slot from the summon spell's Spell.dbc effect (87-90 = SUMMON_TOTEM_SLOT1..4 = Fire/Earth/Water/Air; slot = effect - 86). - Creature entry from the effect's EffectMiscValue (for death detection). - Duration from SpellDuration.dbc via the engine duration helper. - haveTotem tool item from the spell's Totem[0] field (0xA0) — the totem the spell requires (a tool, not a consumed reagent) — resolved from the player's spellbook on SPELLS_CHANGED, not hardcoded. Casts are observed through Aura::Source's existing SMSG_SPELL_GO hook (a one-line notify before its aura gate, since a summon applies no aura) — no new hook, respects one-hook-per-target. Tool items resolve on SPELLS_CHANGED (a no-arg event via the shared Event::SignalHook), when the spellbook is populated. A slot clears when its duration elapses OR when the totem creature disappears early (killed / Totemic Recall / destroyed), detected by a throttled WorldTick object-manager scan for the player-owned creature of that entry (seen-then-gone latch; CreatedBy == player so another shaman's same-entry totem can't mask yours). GetTotemInfo returns haveTotem, totemName, startTime, duration, icon, modRate=1, spellID. Turtle-custom totems are tracked automatically. Also exposes Item::Count::InInventory (equipped + bags) as a shared helper for the tool-presence check. Verified in-game: Earthbind lands in slot 2, haveTotem reflects the Earth Totem tool, and Totemic Recall clears the slot early. |
||
|
|
e8a03d584b |
spell: add GetSpellBonusDamage / GetSpellBonusHealing
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.
|
||
|
|
81434f7014 |
aura: evict phantom cache entries on removal and descriptor reconcile
C_UnitAuras' descriptor-drop fallback could surface a "phantom" aura that was actually gone — enumerated with a spellId but SetUnitAura rendering an empty tooltip. Two cases, both fixed: - Owner cancels a buff (e.g. a flask) while dead: the server keeps death-persistent auras through death without changing any field, so death itself fires no OnAuraRemoved. Any OnAuraRemoved we do receive for one is genuine (cancel/dispel/expiry), so always evict the cache entry — including death-persistent auras on dead units. Fixes the phantom for the caster and nearby observers (both receive the removal packet). - A buff cancelled while its owner is out of an observer's range sends no packet, so the stale entry lingers. Reconcile on return: when a unit's descriptor holds >=1 raw aura it's in view and fully synced, so it's authoritative — evict any cached entry whose spell isn't in the array (Aura::Data::ReconcileCache -> Aura::Source::EvictAbsent, run at the top of the fallback path). Reads raw slots so a flag-hidden aura still counts as present; skips an empty array (can't tell out-of-range from buffless). The only residual is a buff cancelled while the owner is still out of range, which vanilla can't report until they return. |
||
|
|
bb9579c398 |
aura: flush source cache on map transition (stuck buffs after leaving BG)
Leaving a battleground (incl. the /afk teleport out while dead) bulk- clears the player's aura descriptor WITHOUT firing per-aura OnAuraRemoved, so Aura::Source entries for auras that are now gone lingered and Aura::Data's descriptor-empty fallback kept surfacing them. The tell from the report: a real buff (filling a descriptor slot) temporarily masks the phantoms, removing it brings them back. Can't evict on descriptor-empty — that's the exact state the fallback must survive (rogue stealth, party-range drops). The clean distinguisher is a map transition: a BG/instance/continent change moves the Map.dbc ID, while stealth/range don't. OnWorldTick now polls VAR_CURRENT_MAP_ID and flushes the whole cache on any change (no new hook). Every other unit from the old map has despawned, and the player's real auras re-sync from the descriptor / PLAYER_BUFF tables on entering the new world, so a full flush loses nothing legitimate. Reported via pfUI issue #20. |
||
|
|
d6bf05c12c |
Combo-point finisher durations for C_UnitAuras
Rupture at 4 combo points reported duration=6 (the SpellDuration.dbc base) instead of the real 14s: finisher durations are computed server-side at cast time and 1.12 never transmits them for debuffs the player puts on other units. Verified with a whole-protocol sniff -- SMSG_UPDATE_AURA_DURATION (0x137) is self-scoped (slot+duration for the player's own aura array), 0x2DD has no client handler and never arrives, and nothing else carries the value. (pfUI issue #17.) Mirror the server's computation instead (new Aura::ComboDuration): - Snapshot combo points ([player+0xE68]+0x1029, the field behind Script_GetComboPoints) the instant CMSG_CAST_SPELL leaves, via a co-hook on the NetClient send funnel (FUN_NET_SEND 0x005379A0). The server consumes CP before SMSG_SPELL_GO returns, so reading at SpellGo time is too late; the send funnel also covers nampower-queued casts, which bypass any Spell_C_CastSpell co-hook via trampoline re-entry. - Compute base + (max - base) * CP / 5 from the spell's own SpellDuration.dbc row ((v)mangos CalculateSpellDuration), then apply the player's duration SpellMods, matching server order. DBC-driven and spell-agnostic: finishers are exactly the rows with base != max (Rupture 6/16s, Kidney Shot 1/6s, r1 0/5s, Slice and Dice 6/21s; Expose Armor 30/30 self-disables). Consumed by Aura::Source's SpellGo hook; 0 falls through to the existing base path. - Turtle's reworked Rip (8s + 2s per CP) has NO client data: all six ranks' DurationIndex points at SpellDuration row 87, which Turtle added server-side only -- the client table jumps 86 -> 105. Built-in values cover it, gated on the dangling-row condition itself (the only dangling cross-reference in the entire client Spell.dbc, per a full DurationIndex/CastingTimeIndex/RangeIndex sweep) rather than on realm detection: stock clients resolve Rip's index normally, and if Turtle ships the missing row the DBC takes over automatically. - C_UnitAuras.RegisterComboDuration(spellID, baseSec, maxSec) as an escape hatch for other servers with the same class of client-data gap; a registered override beats DBC and built-ins. Verified in-game: Rupture at 4 CP now reads duration=14. |
||
|
|
d9102bae3b |
Relicense source headers from LGPL to GPL v3
The repo was internally inconsistent: the LICENSE file is GPL v3 but every src/ header carried the LGPL v3 notice and the README said "LGPL v3 or later". LGPL was also the wrong fit — this is an injected mod plus a bundled addon, not a library other code links against, so LGPL's linking exception buys nothing. It's also required: src/voicechat/Tts.cpp is ported from awesome_wotlk's VoiceChat.cpp, which is GPL v3, and a derivative of GPL code cannot be relicensed under more permissive terms. Dependencies stay compatible — MinHook (BSD-2) and the nampower-mirrored packet shapes (BSD) are GPL-compatible, and SAPI is covered by the system-library exception. Swept "GNU Lesser General Public License" -> "GNU General Public License" across all 257 src/ headers and changed the README license line to match the GPL v3 LICENSE file. Comment-only; no build impact. |
||
|
|
939b52ae69 |
Recover dropped auras in C_UnitAuras; evict on removal
The 1.12 engine drops a unit's UNIT_FIELD_AURA slots when it loses sync with the unit (rogue stealth, party range fluctuation) even though the auras are still active server-side, so C_UnitAuras.GetAuraDataByIndex / GetBuffDataByIndex returned nil for auras that are still up. Fall back to the Aura::Source cache (caster/timing captured from SMSG_SPELL_GO at cast time, which survives descriptor clears) when the descriptor has no slot: - Aura::Source: entries gain a helpful/harmful kind, recorded from the descriptor slot at application time (OnAuraAdded/OnAuraStacksChanged); SpellGo-only entries stay unknown and are excluded. New Enumerate() returns non-expired entries of a given kind for a unit. - Aura::Data: a shared BuildTable feeds both the descriptor Push and a new cache-fed path; PushNthCacheFallback / AppendCacheFallbacks append cache entries after the descriptor ones, deduped against populated slots. - Aura::Api: the index path and GetUnitAuras consult the fallback. To keep the fallback from resurrecting auras that are genuinely gone (replaced by a higher rank, dispelled, fell off early), co-hook OnAuraRemoved (FUN_00612320) and evict the cache entry. A rogue stealthing does NOT route through OnAuraRemoved (object-visibility drop, not per-aura removal), so eviction and stealth-recovery coexist: real removals evict, visibility drops don't. Add FUN_ON_AURA_REMOVED offset. Fixes #5 |
||
|
|
b8d55e8dea |
Back UnitCastingInfo / UnitChannelInfo for remote units
Vanilla stores no cast record for other units, so UnitCastingInfo(other) returned nil and remote channels had no timing. Co-hook the SMSG_SPELL_START handler (0x006E7640, gated on opcode 0x131) -- the only packet carrying another unit's cast with a server-authoritative cast time -- and cache it per caster GUID (cast vs. channel split by AttributesEx channel bits). - UnitCastingInfo(unit): full timing for any unit within its cast window; enemy/target/focus/nameplate cast bars now work, not just the player. - UnitChannelInfo(unit): remote channels get real start/end times when the channel's begin was observed, validated against the live +0x228 field so a stale entry never sticks; falls back to the old no-times path otherwise. - Player path unchanged (self-tracked); the cache skips caster==PlayerGuid. Factor the CDataStore packet reader out of Aura::Source into a shared Net::PacketReader header (vtable-correct) used by both packet hooks. Best-effort: only casts begun while the unit was in range are seen, and an interrupted remote cast lingers until its computed end (1.12 sends no per-unit interrupt packet to hook). |
||
|
|
5550cb02b7 |
Fill AuraData.expirationTime for proc / triggered auras
SpellGo only sees directly-cast auras, so proc-applied debuffs (Shadow Weaving etc.) had no expiration. Co-hook two more engine functions that fire for every aura application: - CGUnit_C::OnAuraAdded (0x006123F0) - any aura newly occupying a slot, procs included; stamps now + base duration (no caster). - CGUnit_C::OnAuraStacksChanged (0x00612450) - re-stamps on a stack-count change so a climbing stacking debuff (Shadow Weaving 1->5) refreshes. Both pass fromCast=false to Store, which skips entries SpellGo already owns, so directly-cast auras keep their talented timing + caster regardless of hook order. Consolidate the object-GUID read into Unit::Identity:: GuidForObject so the lookup and the new hooks key the cache identically. Known limitation (documented): a refresh at MAX stacks (5->5) changes no client-visible aura field, so the server sends no UpdateField and no callback fires - there's no packet to hook. The countdown runs out and expirationTime falls back to 0 (unknown) while the aura still shows. |
||
|
|
492c70d156 |
Use applied (caster-modified) duration for AuraData.duration
duration came from a base Spell.dbc/SpellDuration.dbc lookup while expirationTime came from the Aura::Source cache computed with the caster's duration modifiers. For a talented DoT (e.g. 2/2 Improved Shadow Word: Pain, 18s -> 24s) the two disagreed, so remaining (expirationTime - GetTime()) exceeded duration -- impossible for a single aura. Cache the applied durationMs alongside expirationMs in Aura::Source and have Push prefer it for the duration field, keeping the two consistent (remaining <= duration). Falls back to the base DBC value on a cache miss. |
||
|
|
b17aeda203 |
Add aura caster + non-player expiration to C_UnitAuras
Populate AuraData sourceUnit/sourceGUID and non-player expirationTime by co-hooking SMSG_SPELL_GO (FUN_SPELL_GO) and caching (targetGuid, spellId) -> caster + expiration. The vanilla unit aura array stores only spell IDs; the SpellGo packet is the only place the client sees an aura's caster and a server-authoritative duration. We parse the engine packet ourselves, so this is self-sufficient (no nampower dependency) -- when nampower is loaded we simply co-hook the same site. sourceGUID is a ClassicAPI extension (raw "0x..." string), set whenever a caster is known including when sourceUnit is nil; stable across the session, unlike the volatile nameplate token, and usable as a unit token under SuperWoW. Also consolidate the local-player-GUID read into Unit::Identity::PlayerGuid() (was duplicated inline in four files) and expose Unit::Identity GuidForToken / TokenFromGUID for reuse. |