diff --git a/docs/API.md b/docs/API.md index c1a7228b..615cf4ae 100644 --- a/docs/API.md +++ b/docs/API.md @@ -2539,9 +2539,15 @@ it: vanilla renders durability UI for equipped gear only. ### `HEARTHSTONE_BOUND` event Fires (with no payload) every time the player binds their -hearthstone at an innkeeper. Polyfills modern WoW's event of the -same name — addons listen to `HEARTHSTONE_BOUND` and re-read -`GetBindLocation()` to refresh whatever bind-location UI they show. +hearthstone at an innkeeper — including a rebind at the same inn. +Polyfills modern WoW's event of the same name — addons listen to +`HEARTHSTONE_BOUND` and re-read `GetBindLocation()` to refresh +whatever bind-location UI they show. + +> Note: the server re-sends the bind packet on map/zone transitions +> (behind the loading screen). Those resyncs are suppressed by gating +> on the engine's in-world flag, so the event fires only for an actual +> innkeeper bind, never on a map change. ```lua local f = CreateFrame("Frame") diff --git a/src/Offsets.h b/src/Offsets.h index eb835f75..12b7f3d1 100644 --- a/src/Offsets.h +++ b/src/Offsets.h @@ -3825,6 +3825,20 @@ enum Offsets { // `Script_IsInInstance`). VAR_CURRENT_MAP_ID = 0x00B4E378, + // "World is live" flag — 1 while the player is fully in the world, 0 during + // any loading screen (initial login, zone/instance transition, logout to + // glue). Set to 1 by the enter-world init `FUN_004908C0` (guarded + // `if (==0){=1;...}`) and back to 0 by the world-teardown `FUN_00490A80` + // (`if(!=0){=0;...}`) that runs at the start of every transition. Byte flag. + // The clean pollable gate for "can this happen in the world right now" — + // e.g. suppressing server resync packets that arrive behind a loading + // screen. Verified via the enter/leave pair in Ghidra. + // + // (NOTE: 0x00B4E37C is NOT this flag — an earlier note wrongly claimed it + // was. That address is instance grace-period state, read only by the + // "recently left an instance" 90-second check in `FUN_00495c90`.) + VAR_IN_WORLD = 0x00B4B424, + // Local player's current AreaTable.dbc area ID (u32 storage; only // the low 16 bits are used — the value is broadcast over the wire // as a u16 in `SMSG_PARTY_MEMBER_STATS`). Written by the zone-change @@ -4874,18 +4888,19 @@ enum Offsets { // // Single caller (the packet dispatcher's jump table for opcode // 0x155) — quiet hook target, no contention with other DLLs. - // Hooked by `Player::HearthstoneBound` to fire `HEARTHSTONE_BOUND` - // every time the user re-binds at an innkeeper. Gating off the - // bind-valid flag's transition distinguishes "initial sync" (the - // one we suppress) from "user rebound at an inn" (the one we - // fire on — even when the area string stays the same, since the - // bind ACTION is what fires the event). + // Hooked by `Player::HearthstoneBound` to fire `HEARTHSTONE_BOUND`. + // Two packets must be suppressed so the event reflects only a real + // innkeeper bind: (1) the initial post-login/char-switch sync + // (gated on VAR_BIND_POINT_VALID being 0 before the handler runs), + // and (2) Turtle's per-map-transition resync, which re-sends the + // packet behind a loading screen — gated on VAR_IN_WORLD (the + // player can't bind mid-load). See `Player::HearthstoneBound`. FUN_BINDPOINT_UPDATE_HANDLER = 0x005ED3C0, // "Bind point is valid" flag. Set to 1 by the BINDPOINTUPDATE // handler after the packet has been fully parsed. Zeroed by // `FUN_005E2510` (the per-character-entry init routine). // Reading this BEFORE the handler runs distinguishes initial - // sync (`== 0`) from a real re-bind (`== 1`). + // sync (`== 0`) from a later packet (`== 1`). VAR_BIND_POINT_VALID = 0x00C4D4E0, // SMSG_QUESTGIVER_QUEST_COMPLETE handler (opcode 0x191). Server diff --git a/src/player/HearthstoneBound.cpp b/src/player/HearthstoneBound.cpp index 43708c50..ac2b68b1 100644 --- a/src/player/HearthstoneBound.cpp +++ b/src/player/HearthstoneBound.cpp @@ -10,19 +10,27 @@ // `HEARTHSTONE_BOUND` event — polyfills modern WoW's event of the // same name. Fires every time the player binds their hearthstone at -// an innkeeper, even when they re-bind at the SAME inn — matches +// an innkeeper, even when they re-bind at the SAME inn — matching // modern semantics where the bind ACTION fires the event regardless -// of whether the location string changes. +// of whether the location changes. // -// Hooks the BINDPOINTUPDATE packet handler at `FUN_005ED3C0` and -// gates on `VAR_BIND_POINT_VALID` to suppress only the initial -// post-login sync. The engine zeroes that flag during per-character -// entry init (`FUN_005E2510`); the handler sets it to 1 after -// parsing. If the flag is 0 before the original runs, this packet -// is the initial sync — don't fire. Any subsequent invocation is -// a real innkeeper rebind. Character switch is handled automatically -// because the entry init re-zeroes the flag, so each character's -// first update is also treated as sync. +// Hooks the BINDPOINTUPDATE packet handler at `FUN_005ED3C0`. Two +// non-bind packets must be suppressed: +// +// 1. Initial post-login / character-switch sync — gated on +// `VAR_BIND_POINT_VALID`. The engine zeroes that flag during +// per-character entry init (`FUN_005E2510`); the handler sets it +// to 1 after parsing. Flag 0 before the original runs ⇒ initial +// sync, don't fire. +// 2. Map/zone-transition resync — Turtle's server re-sends this +// packet on every map change with the (unchanged) bind location. +// The valid flag is already 1 by then, so (1) doesn't catch it. +// But those packets arrive behind a LOADING SCREEN, and the +// player can't bind mid-load — so gate on `VAR_IN_WORLD` (the +// engine's "world is live" flag, 0 during any loading screen). +// A genuine rebind always arrives with the world live (flag 1), +// so this suppresses the resync while still firing for a rebind +// at the same innkeeper. // // Event has no payload — addons call `GetBindLocation()` to read // the new location, matching modern semantics. @@ -51,7 +59,14 @@ void __fastcall BindPointUpdateHandler_h(void *packetBuffer) { BindPointUpdateHandler_o(packetBuffer); if (wasValid == 0) - return; // initial post-login sync — not a user rebind + return; // initial post-login / char-switch sync — not a user rebind + + // Resync packets ride the enter-world burst behind a loading screen; + // a real innkeeper bind only happens with the world live. The player + // can't bind mid-load, so a not-in-world packet is always a resync. + if (*reinterpret_cast( + static_cast(Offsets::VAR_IN_WORLD)) == 0) + return; const int slot = Event::Custom::Lookup(kEventName); Event::Custom::Fire(slot, "");