mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 08:00:42 +00:00
1ee80b74e9a590d2f70540ea5fa5242bf287c8aa
1407
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
1ee80b74e9 |
docs(readme): texture wrap modes, tiling and the element XML attributes
The Texture row lists the SetTexture wrap modes and the tile methods. The XML attributes row now names the element attributes that ClassicAPI reads, for frames, buttons, textures, font strings, status bars and edit boxes, and intrinsic frame types. |
||
|
|
932e6ed82f |
feat(texture): wrap modes and tiling
texture:SetTexture(file, wrapModeHorizontal, wrapModeVertical), the XML hWrapMode / vWrapMode attributes, texture:SetHorizTile / GetHorizTile / SetVertTile / GetVertTile and the XML horizTile / vertTile attributes. Wrap. 1.12 fixes a texture's wrap when its file loads. CSimpleTexture::SetTexture (0x00770200) builds the flags word with CGxTexFlags (0x0058A980) from one wrap argument for both axes, and TextureCreate (0x00449D90) caches the handle under the name and that word, so a repeating copy of a file is its own shared texture. The device reads one bit per axis (3 for U, 4 for V), repeat or clamp, so the mirror and border modes clamp. A texture with a mode or a tile flag loads through a co-hook on that SetTexture: the same body, with a repeat per axis. The engine's same-file early-out (0x0044AC70) ignores flags, so the co-hook also compares the held image's wrap (its device texture's flags at +0x3C, or a loading BLP handle's at +0x150), and for the same file it swaps in the other copy and keeps the pixel shader. Changing a mode or a tile flag reloads the held file the same way. The Lua method is registered again so it stores the wrap arguments before the engine handler (0x0079BB40) runs: true or "REPEAT" repeats, anything else clamps. Tiling. A tiled axis repeats, and each non-zero coordinate on it becomes the texture's length in script units over the image's size in texels. The script units are the engine's own coordinate push: DivideByScreenScaleX (0x0041AE40) of aspect (0x0041AD70) x 1024 x length, over the effective scale. The texels are the device texture's width and height (+0x24 / +0x28): the file's size, halved only past the GPU limit and untouched by BaseMip. The layer batch keeps a pointer to the eight coordinates (0x00772FD0), so the count is written whenever an input changes: after each corner store, after both native SetTexCoord forms (0x00770410, 0x007704C0), on a tile change, and after CSimpleTexture::Emit (0x007706E0), whose device lookup loads the image. A tile change counts against the held image before the repeating copy of the same file replaces it, since the copy has no size until it is drawn. A texture showing an atlas does not tile (the atlases are parts of their files), and neither does one with SetTexCoordModifiesRect on. SetAtlas clears modes and tiling. A tiled status bar texture takes StatusBar::Fill's anchored layout instead of 1.12's crop, which would size it by the count, and its fill sets no coordinates. An XML <TexCoords> that moves a tiled axis off 0..1 logs "Invalid TexCoords value (horizTile is on)" at error level (new Xml::Error) and falls back to the whole image. Also corrects the AtlasData.h note on the atlas tile flags: 4 is horizontal and 2 is vertical. |
||
|
|
b032dc09ac |
refactor(texture): shared hooks for the texture constructor and corner store
MinHook takes one hook per address. Texture::Mask hooked the CSimpleTexture constructor (0x0076FC40) to drop its state when pool memory is reused, and Texture::Transform hooked the corner store (0x007705B0) to turn the quad again after each layout. Texture wrap modes and tiling need both hooks too, so each hook now has an owner that fans out to listeners: - Texture::Construct runs its listeners before the constructor, on the memory it is about to build. Mask listens. - Texture::CornerStore runs its listeners after the store. Transform listens. The store writes only the corners. The layer batch reads them through a pointer on every draw, so nothing marks the layer changed. The XML number parse through SStrToFloat (0x0064AAA0) moves into Xml::FloatAttr, which NativeSetters and Transform's rotation attributes now share. |
||
|
|
eb0b70bc5e |
feat(xml): rotation, degrees, registerForDrag and group parentArray
Four more later-client XML attributes, each applied only when present and non-empty, after the engine has loaded the node. - Texture `rotation` (degrees) and FontString `degrees` / `radians` (`radians` wins when both are given), parsed with SStrToFloat (FUN_SSTR_TO_FLOAT): Texture::Transform's rotation about the default pivot. The bodies of texture:SetRotation and fontstring:SetRotation move into SetTextureRotation / SetFontStringRotation, which the Lua methods and the Xml::TypeLoad subscribers both call. - Frame `registerForDrag`: the names, split on spaces and commas with Storm's tokenizer (FUN_STORM_STR_TOKENIZE) as registerForClicks is, passed to Frame:RegisterForDrag itself (FUN_SCRIPT_FRAME_REGISTERFORDRAG 0x00776D60) as its own Lua call. That function ORs LeftButton 1, MiddleButton 2 and RightButton 4 and stores the mask at frame+0xFC; there is no setter to call instead. - AnimationGroup `parentArray`: the group is appended to region[key]. The append moves out of Xml::ParentKey into Xml::AppendToArray, which frames, regions and groups now share. Tested in game with an XML test addon: rotation="90" and degrees="90" read back as pi/2, two groups land in parentArray in load order, and a frame with registerForDrag="LeftButton" drags. |
||
|
|
238e35ae53 |
feat(animation): from/to alpha, setToFinalAlpha, target keys, scale from/to
Later clients' animation attributes and the methods behind them, on the animation port's own objects. Alpha fromAlpha / toAlpha (SetFromAlpha / SetToAlpha / GetFromAlpha / GetToAlpha): an absolute alpha. Each update the target's alpha becomes from + (to - from) x progress, through Region::SetAnimAlpha, which takes AddAnimAlpha's target rule but sets instead of adding: a frame's own alpha through its vtable setter, a texture's or font string's vertex alpha through FUN_REGION_GET_COLOR / FUN_FONTSTRING_SET_COLOR. Earlier orders apply at full progress before the current order updates, so the last write wins. Setting either end turns the mode on, an unset end is 0, and SetChange returns to the relative change. Absolute values and the 0 default follow Blizzard's own code: it starts fades with SetFromAlpha(region:GetAlpha()) and fades in with toAlpha="1" alone. AnimationGroup setToFinalAlpha (SetToFinalAlpha / IsSetToFinalAlpha): when the group finishes (Finish included), Region::KeepAnimAlpha makes the alpha each alpha animation's target ended on the stored alpha, so the end restores that. Stop restores the stored alpha as before. targetKey / childKey (SetTargetKey / SetChildKey), with SetTarget, SetTargetName, SetTargetParent and GetTarget: a key path from the animation, where $parent steps to the group, then its region, then that region's parent; childKey "X" is "$parent.$parent.X". The steps among the animation objects are taken by Region::FindRegionByKey, and the rest goes to the relativeKey resolver in Xml::Anchors, now public with a switch for its leading-global rule. A name or key is looked up again on Play, as 4.3.4 looks up `target`; the setters also look it up at once and return whether they found a region. GetTarget returns the group's region when there is no target. Scale fromScaleX / fromScaleY / toScaleX / toScaleY (SetScaleFrom / SetScaleTo / GetScaleFrom / GetScaleTo): the scale goes from `from` to `to`, passed to AddAnimScale as 1 - scale. SetScale sets the end, so 4.3.4's scale is the case from = 1 and its results do not change. Tested in game with an XML test addon: childKey and targetKey resolve, the absolute alpha and the last-write-wins rule give each order's end value, setToFinalAlpha keeps 0.5 after the group finishes, a group without it restores alpha 1, and the from/to scale values load. |
||
|
|
5b7fe94d4d |
feat(xml): alpha, scale, desaturated, indented and other XML attributes
Later clients read these attributes in their XML loaders; 1.12's do not. Each is now read after the engine has loaded the node (Xml::FrameLoad for frames, Xml::TypeLoad for the rest) and goes through the setter the matching Lua method uses. Each applies only when present and non-empty, so an element's own value overrides its template's. Frames: - scale: Frame:SetScale's path (0x00775140). A negative scale is refused, anything else goes to SetFrameScale (FUN_FRAME_SET_SCALE 0x0076AC10, __thiscall(frame, float, force), ret 8) without force. A Model keeps `scale` as its model scale, which its own loader reads. - dontSavePosition, propagateKeyboardInput: the existing frame flags, through FUN_FRAME_SET_FRAME_FLAG. Textures and font strings: - alpha: parsed as the frame loader parses its own `alpha` (SStrToFloat, clamped to 0..1, truncated to a byte), then set as Texture:SetAlpha and FontString:SetAlpha set it (0x0079B580, 0x0079CB70): the region color from FUN_REGION_GET_COLOR with its alpha byte replaced, through FUN_FONTSTRING_SET_COLOR. It applies after the node's <Color>. - desaturated (textures): Texture::Desaturation's full amount, the same as SetDesaturated. It applies whenever present; an empty value is false. - indented (font strings): the style bit SetIndentedWordWrap sets. Status bars: - reverseFill, rotatesTexture, fillStyle: StatusBar::Fill's modes, read after the status bar loader has set the BarTexture. An unknown fillStyle name changes nothing. Tested in game with an XML test addon: every attribute set its value, and parentKey, wordwrap and countInvisibleLetters still load. |
||
|
|
43594398f0 |
refactor(xml): one observer owns the per-type XML loader hooks
MinHook allows one hook per address, so the texture, font string and
button loader hooks lived in Xml::ParentKey, which then read every other
module's attribute for it (mask, atlas, wordwrap, registerForClicks), and
CountInvisibleLetters hooked the EditBox loader on its own.
Xml::TypeLoad now owns the hooks on the engine's per-type node loaders,
the way Xml::FrameLoad owns FUN_XML_FRAME_LOAD's, and fans out to
subscribers after the engine has loaded each node:
- texture FUN_XML_TEXTURE_LOAD 0x0076FE20
- font string FUN_XML_FONTSTRING_LOAD 0x00770F40
- button FUN_XML_BUTTON_LOAD 0x007788C0 (CheckButton's loader
calls it first)
- edit box FUN_XML_EDITBOX_LOAD 0x00779FB0
- status bar FUN_XML_STATUSBAR_LOAD 0x00782EF0 (new; calls
FUN_XML_FRAME_LOAD first at 0x00782F06, ret 8)
All five share the sub-object convention __thiscall(loader, node,
status), ret 8, object = loader - OFF_XML_LOADER_SUBOBJECT. An inherited
template goes through the same loader first, so a node's subscribers run
after its templates'. The texture and font string loads keep running in
the node's mixin scope (Xml::Mixin::Begin / End), as before.
Each attribute is now read in the module that owns its setter:
Texture::Mask (mask), Texture::Atlas (atlas, useAtlasSize),
FontString::WordWrap (wordwrap), Frame::ClickMask (registerForClicks) and
EditBox::CountInvisibleLetters (countInvisibleLetters). The XML-only
entry points Atlas::SetFromXml, WordWrap::Set and ClickMask::SetFromXml
become private, and ClickMask.h and WordWrap.h go. ParentKey keeps only
its own binding work. Same hook addresses, same order around the engine
call, no behavior change.
|
||
|
|
2eef939b5a |
feat(xml): registerForClicks and wordwrap attributes
1.12's loaders read neither attribute: the Button loader (0x007788C0) has no registerForClicks, and the font string loader (0x00770F40) reads nonspacewrap but not wordwrap. Both were silently ignored, so ported templates got the default click mask and wrapping text. Both are read in the loader hooks Xml::ParentKey already owns, after the engine's loader and before OnLoad, and only when present and non-empty, so a node's value beats its template's and an OnLoad call still overrides it. No new hooks. registerForClicks follows 3.3.5's CSimpleButton::LoadXML. Storm's tokenizer (0x0064AE50, the one 3.3.5 calls) splits the value on spaces and commas. Each name ORs in its bits through Frame::MouseRegistration::MaskForName, the RegisterForMouse name table (3.3.5's MouseButtonStringToBitmask, AnyUp / AnyDown included). The result replaces the mask through the engine's own setter 0x00779730 (__thiscall(button, mask), ret 4, writes only +0x330). wordwrap goes through FontString::WordWrap::Set, the body of fontstring:SetWordWrap: it clears the font's override of the no-wrap style bit and lays the string out again when the value changes. Tested in game: WowStyle1DropdownTemplate's Text (wordwrap="false") now reports CanWordWrap() = nil. |
||
|
|
36f3661b98 |
feat(lua): GetCallstackHeight, GetErrorCallstackHeight, SetErrorCallstackHeight
Adds the three call stack heights an error handler uses to start its
stack at the code that failed:
debugstack(GetCallstackHeight() - (GetErrorCallstackHeight() - 1))
A height counts levels as lua_getstack (0x006FBAA0) does, and so as
debugstack does: C functions and lost tail calls count, and level 1 is
the caller.
1.12.1 records no error height, but every error report runs one C
function, FrameScriptCallErrorHandler (0x00703B40, __fastcall(L)). It
pushes the seterrorhandler function (registry ref 0x008722CC), moves it
under the message and lua_calls it. Nothing calls it directly: state
open pushes it as a C closure and refs it (0x008722C8). Every script
pcall passes that closure as the errfunc, so Lua calls it at the point
of the error before the stack unwinds; a chunk that fails to compile is
reported by a pcall of it (0x00704AE0). ClassicAPI's securecall,
hooksecurefunc and script runners pass the same ref.
So while any handler runs, that closure's level sits directly above the
code that failed. GetErrorCallstackHeight walks the levels with
lua_getstack and lua_getinfo "f", finds the innermost one whose function
is 0x00703B40 (lua_tocfunction, 0x006F3720) and answers the height below
it, or nil when no error is being reported. There is no hook, and
nothing is recorded, so a handler that fails part way leaves nothing
behind.
SetErrorCallstackHeight sets the height for a handler called with no
error raised. It applies only while no 0x00703B40 level is on the stack,
so a value left set by a failed handler cannot move a later error's
stack. A new Lua state starts with no value set.
Users:
- The Lua error window takes its stack this way, so it starts at the
failing code even when another addon wraps the handler.
- CallErrorHandler and assertsafe set the height around their direct
handler call, so they report from their caller.
- Game::Lua gains GetStack, GetInfo and ToCFunction; SourceLocation uses
them in place of its own copies.
Docs: the xpcall and coroutine notes said error() returns without
raising. Stock error (0x00702970) ends in lua_error (0x006F4440) and
raises. pfUI replaces the global error with one that prints and
returns, which is what those notes described.
Tested in game: with seterrorhandler wrapping the old handler, a nil
index in a local function f showed a stack that starts at f.
|
||
|
|
4f3ee595e7 |
feat(ui): Lua error window replaces the stock error box
The Lua error window (/luaerrors) moves from the load-on-demand ClassicAPI_DebugTools into !!!ClassicAPI and becomes the client's error display. Each error opens it with the message, time, count and stack, and the arrows page through every error so far. 1.12.1's error handler is FrameXML's _ERRORMESSAGE (BasicControls.xml). It reports an error as ScriptErrors_Message:SetText(message) and then ScriptErrors:Show(), and only while the stock box is hidden. The window's OnLoad takes those two slots, the same two !BugGrabber 2.1.1 takes: SetText records the error and Show does nothing, so the stock box stays hidden and every error arrives. Errors still pass through the handler first, so: - !BugGrabber loads after !!!ClassicAPI and takes the slots back. BugSack gets the errors and the window does not open. - An addon that calls seterrorhandler (pfUI) replaces _ERRORMESSAGE, so neither shows. One that wraps the old handler still ends here. The engine's error function (0x00703B40) is C. It runs at the point of the error, before the stack unwinds, and calls the registered handler. From the SetText slot, level 1 is the slot, 2 is _ERRORMESSAGE, 3 is that C function and 4 is the code that failed, so the stack starts at debugstack(4), the level !BugGrabber's GrabError reads from the same slot. The text is ClassicAPI's ScrollingEditBoxTemplate with a MinimalScrollBar. The bottom row has Reload UI, arrows that wrap around the index label, and Close. /luaerrors opens or closes the window and /luaerrors clear empties it; the old on/off handler install is gone. Not tested in game yet. |
||
|
|
99f72aa631 |
feat(ui): UI_SCALE_CHANGED event
Fires (no payload) each time the game applies the interface scale to UIParent. In 1.12 every scale change goes through one function, SetUiParentScale (0x00494550, void __stdcall(float), ret 4). It raises the value to 0.64, calls SetScale with force (0x0076AC10) and drains the layout queue (0x00768ED0), and does nothing while UIParent (0x00B4B44C) is null. It has six callers: - the uiScale cvar callback (0x00490770, two sites) - the useUiScale cvar callback (0x004907F0, two sites) - OnDisplaySizeChanged (0x00492E90) when useUiScale is on - the automatic scale ApplyAutoUiScale (0x00492F70) One MinHook on it fires the custom event after the original returns, only while UIParent is set. The game UI's Initialize stores UIParent (0x00490077) and its Shutdown clears it (0x00490CA4), so the event never fires on the glue screen. Each path calls the setter once, so one change fires one event; a resize fires it before DISPLAY_SIZE_CHANGED. Tested in game: useUiScale on, uiScale 0.8 and useUiScale off each fired one event with the new scale (0.91, 0.8, the automatic 0.9). |
||
|
|
9e5c0c558a |
feat(autocomplete): C_AutoComplete name completion (API only)
Adds C_AutoComplete.GetAutoCompleteResults, C_AutoComplete.IsRecognizedName, Enum.AutoCompleteEntryFlag and Enum.AutoCompletePriority, and the cvars autoCompleteResortNamesOnRecency, autoCompleteWhenEditingFromCenter and autoCompleteUseContext. ClassicAPI only answers the queries; an addon draws the list of names. 1.12.1 keeps no autocomplete list, but it keeps every list the names come from, so each query reads them where the client keeps them: - party: the four GUIDs at VAR_PARTY_GUIDS (0x00BC6F48), names from the name cache, online from the member stats block - raid: the VAR_RAID_MEMBER_PTRS slots (0x00B712A8) and their online bit - guild: the GuildMemberInfo roster at 0x00B72704, GUID at +0x00 and the online word at +0x48 (stored at 0x004D0C22, tested by GetGuildRosterInfo at 0x004D13C5). Read only while the player's guild key is set, the test IsInGuild (0x00516DE0) makes, because the client keeps the old roster after a /gquit - friends: the 50 slots of the social singleton Whisper partners are the one list the client does not keep. The chat dispatch hook (FUN_0049A870) reports each whisper and whisper inform (types 6 and 7, not the addon language -1) with the sender GUID it already resolves. Logging out clears the list. Names match case-insensitively by UTF-8 code point; Text::Utf8::CompareI now takes a character limit. Results come most recent whisper first, then by name. A result's priority is its closest tie: friend, guild, group, whisper. GetAutoCompletePresenceID and GetAutoCompleteRealms are constant answers in Compat.lua. The three cvars are on a new Social page of the options panel. |
||
|
|
b3b950f2d8 |
feat(spell): spell alerts and proc glows (API only)
Adds C_SpellActivationOverlay.IsSpellOverlayed (and the global
IsSpellOverlayed), Enum.ScreenLocationType, and the four
SPELL_ACTIVATION_OVERLAY_* events. Nothing is drawn: an action-bar or
UI addon draws the alerts and the glows from these.
Glows come from the engine's own reactive-spell list. AddSpellToBook
puts every learned spell whose record has AttributesEx4 0x200 on the
list at 0x00B71150 (count 0x00B7114C), one 8-byte {spellID, usable}
entry per name. FireUsableEvents (0x004B31C0) retests the list with
the engine's usable check, stores each answer, then signals
SPELL_UPDATE_USABLE (0x107). The module subscribes to that signal
through Event::SignalHook and reads the stored answers, so the verdict
is the engine's (rage, target health, aura states, and the hidden
combo point behind Overpower) and no new hook is needed. A usable entry
glows every spellbook spell with the same name, which is the list's own
identity rule, so a bar slot with any rank glows. On stock 1.12.1 this
is Execute, Overpower, Revenge, Riposte, Counterattack, Mongoose Bite
and Hammer of Wrath; Turtle's Spell.dbc changes the set by itself.
Alerts come from two Blizzard rows whose aura exists unchanged in 1.12:
Shadow Trance (Nightfall art, glows Shadow Bolt through its class mask
via Spell::Lookup::IsFitToFamily) and druid Clearcasting
(Natures_Grace art). An Aura::Source observer reconciles on the
player's aura add/remove, rescanning the descriptor so counts can't
drift. The texture is a path; 1.12 has no file data IDs.
On world entry, HIDE fires with no spell ID and every active alert
fires SHOW again, so a /reload redraws them. Glows already lit before a
/reload do not re-fire; a button reads IsSpellOverlayed when it draws.
Logging out clears the state without events.
Event::EnteringWorld gains an observer list, because it claims
PLAYER_ENTERING_WORLD in the signal chain and later subscribers never
see it. Event::Custom's reservation cap goes from 96 to 128: the four
new events filled the old cap exactly, and a name past the cap is
dropped silently.
|
||
|
|
5dcf10a9fd |
fix(player): name cache keeps one copy of each player and honors renames
The persistent name cache copied every name reply into its own map, so each player the engine named this session was held twice. The copy also went stale. On a rename the server sends SMSG_INVALIDATE_PLAYER (0x31C) and HandleNameInvalidate 0x00555600 frees the engine's record, but our copy kept the old name, and GetPlayerInfoByGUID / UnitNameFromGUID fell through to it. The store now holds only the players the engine's name cache (0x00C0E228) does not: - A Net::PacketDispatch subscriber reads SMSG_NAME_QUERY_RESPONSE (0x51) in the same order as HandleNameQueryResponse 0x005551A0 and drops our entry just before the engine stores its record. This replaces the hook on NameCacheStore 0x0055F310. The backstop save runs before the drop, so no save misses the player. - The same subscriber drops our entry on SMSG_INVALIDATE_PLAYER. - The engine empties its cache only at world entry: NameCacheClear 0x00560400, called from CGGameUI::InitializeGame through 0x00555740. A hook there copies the engine's records into the store first, while the store still holds the realm they came from. - At exit the engine frees the cache from its atexit handler (NameCacheSave 0x0055EC70). Storm's exit handler 0x0064CC30 runs every atexit handler before ExitProcess, so DLL_PROCESS_DETACH was too late to read it. At the first world entry the clear hook registers our save with the exe's own _atexit (0x00409AEF). Handlers run newest first, so ours runs before the engine's. Detach now calls Shutdown, which never reads the engine's cache. - A save writes our store, then the engine's records, so a load applies the engine's data over ours. - C_PlayerCache.RememberPlayer leaves alone a player the engine holds. One hook removed (0x0055F310), one added (0x00560400). |
||
|
|
3ef6c4ffed |
fix(player): name cache keeps each player's realm and whole UTF-8 names
The persistent name cache cut names at 16 bytes. A Chinese character is 3 bytes in UTF-8, so a 6-character name lost part of its last character. The limit is now the engine's own: the name cache store (0x0055F310) copies the name with SStrCopy(dst, src, 0x30) and the realm with SStrCopy(dst, src, 0x100), now PLAYER_INFO_NAME_SIZE and PLAYER_INFO_REALM_SIZE in Offsets.h. A longer name from Lua is cut on a UTF-8 lead byte, never inside a character. Entries are now keyed by GUID, the engine name cache's own key, and keep the record's server name (+0x30, empty for a player on this realm). The by-name index uses the form the engine itself shows for a player from another realm: ClientChatHandler (0x0049D560) builds the sender as name, "-", and the realm with spaces and tabs removed. A bare name stands for this realm. Player::FullName builds and parses that form. Two players with one name from two realms no longer replace each other, C_PlayerCache.GetPlayerInfoByName takes "Name-Realm" (a chat sender name as it comes), and the persistent fallbacks of GetPlayerInfoByGUID and UnitNameFromGUID return the stored realm. A "Name-Realm" skips the by-name search and the friends list, which keep no realm. The engine name cache walk moved from Unit::Identity into Player::Info, its one caller. The cache is one flat file per realm, WTF\ClassicAPI\NameCache-<realm>@<realmList>.txt, in a v5 format split on tabs (a realm can hold spaces): guid, name, realm, class, race, sex. The v4 file under WTF\ClassicAPI\<realmList>\<realm>\ is migrated on first load and deleted, with its emptied folders, once v5 is saved. The old import from the per-account path is gone. The store loaded once per process and saved to whatever realm was current, so logging out into another realm wrote the first realm's players into the second realm's file. It now records the file it holds: every access compares that with the current realm's file, and on a change saves the old realm's entries to their own file before loading the new one. A failed rename leaves the cache dirty for the next flush. Verified on Octo: all 63,178 N'Zoth v4 entries migrated unchanged, 13 of 13 C'Thun entries migrated, the v4 folders were removed, and a N'Zoth to C'Thun switch in one session kept the two files apart. Fixes #119 |
||
|
|
1ef8c5597a |
fix(player): UnitNameFromGUID returns the name cache's realm
CGUnit_C::GetUnitName (0x00609210) takes a realm out-pointer as its stack argument, not the flags word Offsets.h called it. For a player whose name-cache record has a non-empty server name (record +0x30) it stores a pointer to that string, and otherwise leaves the pointer alone (0x0060926B-0x00609283). Vanilla's Script_UnitName (0x00517020) passes &realm there and returns it as UnitName's second value. The record's server name is the realm string SMSG_NAME_QUERY_RESPONSE carries: Tortoise sends it empty, a cross-realm server fills it. UnitNameFromGUID pushed a hard-coded "" instead. NameFromGuid now passes the out-pointer through, as Script_UnitName does, and gains a step between the friends list and the persistent cache: the engine name cache record itself (FUN_PLAYER_INFO_LOOKUP with no callback, a passive peek), which also gives the realm for players out of range. Before, a player who whispered from far away resolved only with the persistent cache on. UnitSpellTargetName shares NameFromGuid and finds those players too. The realm is "" when the record has none, or when the name came from the friends list or the persistent cache, which stores no realm. Retail documents both returns as non-nil strings. GetNameAndServerNameFromGUID in the addon's PlayerUtil returned GetRealmName(), the local realm, for every GUID. It now returns GetPlayerInfoByGUID's realm, as retail's UnitUtil does, so a player on the local realm gets "" and code that appends "-" .. realm only when it is non-empty works. Seven files declared their own function-pointer type for 0x00609210, all with the wrong int *outFlags argument. Unit::Identity::NameForUnit is now the one wrapper. The other six callers pass no realm and behave as before. Offsets.h gives the getter's real signature (RET 4) and what it stores. API.md's GetPlayerInfoByGUID and UnitNameFromGUID entries describe the realm and the four sources. |
||
|
|
9b0aa46ff0 |
fix(tts): a stopped utterance no longer finishes the next one
StopSpeakingText purges SAPI's queue, but the purge still queues START/END events for the streams it cut off, and SAPI numbers streams from 1 again afterwards. The next SpeakText then reused stream 1, so the stale events were read as the new utterance's: VOICE_CHAT_TTS_PLAYBACK_STARTED and _FINISHED fired for it before it played, and its real end fired a FINISHED with utteranceID 0. The purge is synchronous and has queued all of those events by the time it returns, so StopAll now drains and discards them right after it. That covers stop and speak in the same Lua call too, where the stale START is still queued and a "require START first" check on the END handler would not have been enough. An END for a stream we do not track no longer fires FINISHED with utteranceID 0. Purged utterances now signal nothing, which is retail's contract. Verified with a standalone SAPI probe: speak/stop/speak, with and without a message pump between the calls.v1.18.14 |
||
|
|
84171bef2d |
fix(unit): mirror timers clear on leaving the world, empty slots say UNKNOWN
The engine's handler for the three mirror-timer SMSGs (0x005E7990) only reads each packet and signals MIRROR_TIMER_START / _PAUSE / _STOP, so GetMirrorTimerInfo and GetMirrorTimerProgress read a table of our own. A MinHook on that handler fed it by reading the packet and putting the cursor back. The table now reads START (0x1D9) and STOP (0x1DB) as a Net::PacketDispatch subscriber, and the hook is gone. CGPlayer_C::Release (0x005E9AA0) runs StopMirrorTimers (0x005E9B90) for the active player: MIRROR_TIMER_STOP for all three types, with no packet. The table never saw it, so a breath timer stayed after a logout or a loading screen. Release then calls LeaveWorldUI (0x00490A80), which fires PLAYER_LEAVING_WORLD through the no-arg dispatcher. An Event::SignalHook subscriber clears the table on that event. What the functions return: - GetMirrorTimerInfo returns an empty slot as "UNKNOWN" with zeros, the name helper 0x005E7AE0 gives for no type, instead of nothing. Code that tests for "UNKNOWN" on PLAYER_ENTERING_WORLD called its setup with nil before. paused is a number, as the event's %d is, and spellID is a seventh value. - A PAUSE packet no longer changes the table. Tortoise never sends one: it resends START with the paused byte, which the table keeps. - GetMirrorTimerProgress is value + scale * elapsed with no clamp. A timer started paused holds its value. Names match through SStrCmpI, and a name that is not a timer type returns nil. - The time comes from Time::Clock. 0x0042B790 truncates the tick itself and returns it in EAX, so the GetTickCount workaround for an FPU return had no cause. Offsets.h drops the CDataStore readers, the handler and the PAUSE opcode, which nothing reads now, and its comment gives the verified signatures and packet layout. Both functions get API descriptors under the MirrorTimer system. API.md's section is rewritten to match. |
||
|
|
f19f13d44c |
feat(debugtools): fold pfDebug in as /profiler
pfDebug was a separate addon that profiled through ClassicAPI's own APIs: GetAddOnMemoryUsage and GetAddOnCPUUsage, GetFrameCPUUsage, GetFunctionCPUUsage, GetEventCPUUsage, and the intrinsic precall and postcall script hooks. Its code now lives in ClassicAPI_DebugTools under Profiler/, with its MIT notice (Copyright (c) 2018 Shagu). The analyzer tabs (Addons, Frames, Events, Globals) and the widget are pfDebug's, with the frame and template names renamed to ClassicAPIProfiler*. /profiler and /prof load DebugTools on demand through the same stub as /dump, then toggle the analyzer. The subcommands widget, reset and profile on|off are pfDebug's. What changed in the move: - The sampler starts only when the widget or the analyzer first opens, so a load for /dump costs nothing. It first takes every counter as it is, so the first CPU/s and KB/s cover one second, not the session. - Whether profiling runs is probed, not read from the cvar: a function is called once and GetFunctionCPUUsage must count that call. The scriptProfile cvar can already hold the next session's value. - A frame record starts at the frame's current CPU time and call count, and opening the analyzer takes every frame and event counter again, because the frame totals and the deep hooks keep counting while it is closed. pfDebug started records at 0, so the first scan and each reopen showed a frame's whole session as one second. - The /fstack lines (owner, OnUpdate and OnEvent owner and CPU, all scripts, deep allocations) are added at the end of FrameStackTooltip_OnTooltipSetFrameStack, not by hooking OnTooltipSetFrameStack. - No pfUI skin and no SavedVariables. The plain backdrop is pfDebug's own fallback. The widget no longer opens at login, because that would load DebugTools at login. README's Debug tools table gains /profiler and the new /fstack lines. |
||
|
|
4509da0966 |
build: pack each embedded addon into one gzip stream
Each embedded file was its own gzipped RCDATA resource, 175 in all.
Every stream started with an empty deflate window, so no file could
match text it shares with its neighbours, and 97 of the files are under
4 KB, where that costs the most. Each resource also cost about 50 bytes
of resource directory and padding.
cmake/pack_files.cmake, which replaces gzip_file.cmake, now joins each
addon's files at build time into one gzip stream. It holds an index,
each file's size as a decimal line and then an empty line, followed by
the files' bytes in path order. `cmake -E cat` joins them byte for
byte, in batches of 100 so the Windows command-line limit cannot fail
the build. The index goes through file(CONFIGURE NEWLINE_STYLE UNIX)
because file(WRITE) writes \r\n on Windows. The resources are now three:
Bindings.xml as a pack of one, !!!ClassicAPI, and ClassicAPI_DebugTools.
The manifest entries become {path, resourceId, index}, and
Embed::Resource(id) becomes Embed::File(id, index). On first use it
inflates the whole pack with the engine's zlib, splits it into views,
and keeps it for the life of the DLL, as before. A pack whose sizes do
not cover its bytes exactly is rejected. The load-on-demand DebugTools
pack is still inflated only when it loads.
Embedded data 323,947 -> 272,825 bytes; .rsrc 334,336 -> 274,432;
DLL 1,632,768 -> 1,573,888 bytes.
|
||
|
|
38d5c6c7b6 |
fix(unit): ClassicAPI's unit events reach markN and the soft tokens
ClassicAPI fires its own unit events (UNIT_AURA_DELTA, the remote UNIT_SPELLCAST_*, the power, group-member, distance, incoming-resurrection and targetable events) once per token through Unit::Identity::TokensForGUID. That took the engine's tokens from its reverse map FUN_UNIT_TOKENS_FROM_GUID (0x00515C50) and then added its own short list: focus and nameplateN. The engine's unit events get their ClassicAPI tokens from a second list in Unit::TokenEvents, which also has markN, softenemy and softfriend. So a soft enemy got UNIT_HEALTH but never UNIT_SPELLCAST_START. That list is now the public Unit::TokenEvents::TokensOf, capped at the caller's room and empty before the player object exists, as before. TokensForGUID appends it to the engine's tokens, so both kinds of event reach the same tokens, and a new token goes in one place. nameplateN now comes before focus, the order TokensOf already used. API.md's soft enemy and soft friend section now says that their tokens fire unit events, as the focus, nameplateN and markN sections do. |
||
|
|
be5ebd4017 |
docs(unit): name softenemy and softfriend in the token comments
|
||
|
|
44f9bcd9af |
feat(unit): softenemy and softfriend fire unit events
Unit::TokenEvents already redirects the 38 broadcast and 4 combat feedback call sites so a unit holding focus / nameplateN / markN gets every engine unit event under that token. softenemy and softfriend join that token list, read through SoftUnit::Current (the last pick, no scan) because TokensOf runs on every unit event. The registration bit (UNIT_SCRIPT_REG_TOKENS) is what makes the engine watch a unit, so SoftUnit::Refresh re-runs FUN_UNIT_SCRIPT_RECOMPUTE through TokenEvents::Refresh for the old and new guid before the PLAYER_SOFT_*_CHANGED event fires. The frame tick now picks every frame rather than only while that event has a listener: a UNIT_HEALTH listener never registers for it, and the pick is cached per scene drain anyway. |
||
|
|
f9ec92014c |
feat(target): show softenemy and softfriend names as the target's
Retail shows a soft unit's overhead name the way it shows the target's: a soft enemy past nameplate range keeps its name, whatever the UnitName cvars say. 1.12 decides an overhead name in CGUnit_C::ShouldShowName (0x6070A0), which its only caller, the name draw PLAYERNAMEDESC::UpdatePlate (0x6C6EE2), asks every frame. In order: no name when CanSelect (vtable +0x58) refuses the unit, or when it has a nameplate (+0xE60) or a chat bubble (+0xE64); the active player by UnitNameOwn; the target always; then the UnitName mask. A hook gives a soft unit the target's branch: the first three tests, then 1. The player is never a soft unit, so the own-unit test does not apply. In nameplate range the plate shows and the name does not, as for the target. The name draw runs inside the scene (the model draw callback 0x6C7780), so the hook reads the soft GUIDs cached on the UI frame tick, as the selection circle does, and never picks there. Nothing invalidates: the verdict is asked fresh each draw. |
||
|
|
264af04ee3 |
feat(cooldown): countdown formatter and C_StringUtil.CreateNumericRuleFormatter
Addons can now choose the countdown text and its color for each range of time left. Cooldown:SetCountdownFormatter(formatter) and GetCountdownFormatter() take a NumericRuleFormatter from C_StringUtil.CreateNumericRuleFormatter(). Its breakpoints each give a threshold, an optional step, rounding (Enum.NumericRuleFormatRounding), min and max, a format string, and optional div/mod/step components, one for each format argument. Color codes in the format string pass through. The formatter is a full Lua userdata, the first in the DLL. Its block holds a pointer to a reference-counted native object. Every Lua object and every frame that uses it hold one reference, so the GC finalizer (__gc) and the frame's deleting destructor can run in any order. lua_newuserdata (0x6F4560, __fastcall, block at Udata + 0x10, read from the disassembly) is new in Offsets.h. lua_touserdata reuses FUN_FRAMESCRIPT_GET_OBJECT, which is that function. One metatable per Lua state lives in the registry. Its __metatable is false, and the identity check compares a value's metatable with it. 1.12 has no newproxy, so the only finalizer an allocation can run is ours. Thus no addon code can change a formatter while it formats. The text goes through 1.12's own str_format (0x7FD3D0). Its closure is made once per state and kept in the registry, because FormatNumber runs from addon timers and lua_pushcclosure allocates on each push. The rounding is x - fmod(x, step), plus a step away from zero when the rounding needs it. Only that arithmetic matches retail to the last bit: Up of 0.7 by 0.1 gives 0.7000000000000001 and of 0.6 gives 0.6, but ceil(x / step) * step gives 0.6000000000000001. The cooldown shares the formatter and gives it the unrounded seconds left. The formatter replaces the built-in text and both thresholds, and every gate stays. The cached countdown text is now a heap std::string, because a formatter's text has no length limit. The frame frees it, and its reference, in DeletingDestructor. A probe addon recorded 229 results in retail 12.1.5. The same probe on 1.18.1 matched 197 of them. The other results come from 1.12's own str_format (%e exponent digits, %q, %d past the int range, its error wording), from field storage on the object (not ported), and from addresses and times.v1.18.13 |
||
|
|
2063507fb4 |
fix(lua): ported files read wipe from the ClassicAPI mirror
The global wipe is ours only until an addon declares its own: whoever writes _G.wipe last wins, with no error. RegisterGlobalFunction mirrors every global it binds into _G.ClassicAPI at registration, before FrameXML and every addon load, so ClassicAPI.wipe is always our table.wipe C function. The nine embedded files that call the bare global now take `local wipe = ClassicAPI.wipe;` and list it as their difference from retail: ScrollBoxListView, ScrollUtil, Menu, CallbackRegistry, MixinUtil, SecureTypes and the three DebugTools table inspector files. Files that read table.wipe, as their retail sources do, are unchanged. The global stays for third-party code.v1.18.12 |
||
|
|
090cfc3bfd |
feat(lua): global wipe, the table.wipe alias
On a stock 1.12.1 client, ScrollBoxListView, ScrollUtil, Menu and the DebugTools table inspector failed with "attempt to call global `wipe'": those ports call bare wipe(), and only Turtle's client defines that global. Stock 1.12.1 has only the table.wipe that ClassicAPI registers. 3.3.5 makes the alias in FrameScript's compat preamble, next to tinsert and tremove (wipe = tab.wipe). 1.12's preamble is older than table.wipe, so Wipe.cpp now registers the same C function as the global wipe as well as table.wipe, with a LuaGlobals descriptor. CallbackRegistry, MixinUtil and SecureTypes lose their "1.12 has no global wipe" notes and their table.wipe locals, and now match retail. |
||
|
|
d1cdb47c3e |
feat(unit): restore UnitFacing
UnitFacing(unit) returns the unit's facing in radians (0 = north, counter-clockwise, 0..2pi), or nothing when the token has no unit. The facing comes from the object's GetFacing virtual, vtable slot 6. The unit and player vtables (0x80C4F8 / 0x80AF78) both hold CGUnit_C::GetFacing (0x5F1F30) there, read from the binary: it loads the mover at +0x118, pushes its facing +0x1C and returns CMovement::TransportFacingToWorld (0x7C4AE0), which adds the transport's facing and wraps once into [0, 2pi]. Unit::Position::Facing wraps the call next to the shared position read. GetPlayerFacing moves to the same read. It used to load the float at +0x9C4 (the mover's +0x1C) directly, which is the facing relative to the transport, so on a boat or zeppelin it returned the wrong angle. The OFF_UNIT_FACING offset goes with it. |
||
|
|
237e5a7500 |
fix(container): sort gear by equip slot before item class
The bag sort compared item class before the equip slot rank. Shields, held-in-off-hand items and relics are armor class (4), so they left the weapon group and sorted first in the armor block, before head pieces. For gear, the slot rank (Item m_inventoryType through kSlotOrder) now comes first and item class is the next tiebreak. Those items now sort with the weapons, where the slot order puts them. Non-gear items sort the same as before. |
||
|
|
d339f4486d |
refactor(swing): reset on weapon swap from the inventory-slot observer
A weapon equipped in combat resets that hand's swing timer on the server, with no packet for it. PLAYER_SWING used to catch this by reading the main-hand, off-hand and ranged GUIDs from the player's inventory manager (player+0x1D38) on every WorldTick and comparing them with the previous frame. The engine already reports these changes. CGPlayer_C::AddActiveWatchers (0x005DD8A0) registers OnInventorySlotChanged (0x005DDCF0) on every equipment slot, and the descriptor dispatcher calls it only when a slot's GUID really changes. Player::Equipment already hooks that handler for PLAYER_EQUIPMENT_CHANGED. It now also calls Combat::Swing::OnWeaponSlotChanged, which resets the hand for slots 15/16/17 when the player is in combat. The call runs inside SMSG_UPDATE_OBJECT, after the values block is written, so the attack-time descriptor field already holds the new weapon's speed. The lookups it makes (player by GUID, descriptor reads) do not throw. The per-frame poll and its snapshot state are removed. The WorldTick subscriber stays: it still merges several resets in one frame into one PLAYER_SWING per swing type.v1.18.11 |
||
|
|
92025896b5 |
feat(options): a control for every cvar, one cvar per control
The AddOn Options panel now has a control for each of the 38 cvars that ClassicAPI registers, plus the player cache, on pages grouped by feature: Interact Key, Action Targeting, Combat, Bags and Items, Interface, Text To Speech and Advanced. Each control reads and writes exactly one cvar, and writes it only when the player uses that control. The "Interact Key Icons" preset dropdown is gone: it wrote four icon cvars at once, and Cancel restored it from a snapshot that read any mixed state as "NPCs Only", which turned SoftTargetIconInteract back on. Okay, Cancel and Defaults no longer write anything on these pages. - On/off cvars are checkboxes. The soft-target enable cvars read as on for 2 or 3 and write 3 or 0; 1 is gamepad, which does nothing here. - Fixed choices (the three arc cvars, SoftTargetForce) are dropdowns. A value outside the choices shows as its number. - Open-ended numbers (ranges, icon size, shake strength, combat log retention) are number boxes, so the panel sets no maximum. Sliders are kept for documented ranges only. - Each page's controls sit in a WowScrollBox with a MinimalScrollBar. The box clips its children, and the clip also keeps the mouse off controls that are scrolled out of view. The panel's strings are globals in locales\enUS.lua, which every client loads: CLASSICAPI_* for ClassicAPI's own, and retail's GlobalStrings keys where retail has the string (COUNTDOWN_FOR_COOLDOWNS_TEXT and its tooltip, with retail's translations in the other locale files). The README cvar table gains the five cvars it was missing. |
||
|
|
4eb214f7f1 |
fix(tick): run world-tick subscribers after the UI draw
CWorld::BeginFrame (0x0066FD50), the world tick, runs inside the UI strata walk. Its only caller is CGWorldFrame::OnRender (0x00482EA0), which WorldFrame's layer-0 draw callback (0x00482D70) runs. By then 0x007657D0 has already rebuilt the WORLD stratum's level batches. The levels above 0 are not drawn yet. Nameplates sit at level 1, with their name and level text on OVERLAY. A batch's text run keeps a raw pointer to its font. The run's draw (0x005C8FE0) uploads all eight of that font's atlas pages, even when no strings are left in the run. Every subscriber ran at the hook, and several of them run Lua (NAME_PLATE_CREATED, the C_Timer callbacks). An addon that restyled a plate there made the plate leave level 1 and gave its font strings a new font. The old font was destroyed while the built batch still pointed at it. The upload then read a freed texture's format and faulted at 0x005A09B8. The crash dump shows this state: - Level 1 has no frames. - Its dirty mask is 0xFFFFFFFF, and the stratum's flags are set again. Both were written after the rebuild. - Its one OVERLAY run is empty, and its font's memory holds Lua table nodes. The hook now only marks that the world ran. The subscribers run from the UI render root's tail (Tick::FrameTick), after the strata walk, so the engine rebuilds anything they change before it is drawn. OnUpdate and packet events still run in the same order relative to them. GetTickTime() also reads the same pass delta as before. Fixes #116v1.18.10 |
||
|
|
706fb1c540 |
docs(readme): refresh the function, namespace and event counts
The intro and the Lua-calls summary still said 550+ functions across ~60
namespaces and 50+ events, the counts from
|
||
|
|
e37052c67d |
feat(lua): SharedColorConstants
Port of retail's Blizzard_SharedXML/SharedColorConstants.lua, in
Blizzard's own text. It loads after ColorUtil.lua, when Color.lua has
already made the GlobalColor globals it reads, and adds
PLAYER_FACTION_COLORS_HEX, PLAYER_FACTION_BRIGHT_COLORS (the PvP
scoreboard colors) and COVENANT_COLORS.
FACTION_BAR_COLORS now holds retail's color objects in place of 1.12's
plain {r, g, b} tables. The stock code that reads it (the unit tooltip
and the reputation bars) reads only .r, .g and .b, which the objects
have; the values differ by less than 1/255.
PLAYER_FACTION_COLORS moves out of Constants.lua, because retail
defines it only here, and GetFactionColor goes back to retail's
one-line body without our nil guard.
Verified in game: FACTION_BAR_COLORS[1] is ffcc4d38 and [5] is
FACTION_GREEN_COLOR, PLAYER_FACTION_COLORS_HEX[0] is ffff2934,
PLAYER_FACTION_BRIGHT_COLORS[1] is ff00adf0, GetFactionColor("Alliance")
is ff00adf0, and COVENANT_COLORS.Kyrian is ff2aa2ff.
|
||
|
|
f8f6dc28b8 |
feat(ui): GlobalColor table from build 1.60.1.70707
C_UIColor.GetColors now returns the GlobalColor.dbc rows of build
1.60.1.70707 instead of the BC Classic 2.5.5 snapshot: 331 rows where
there were 187, in the table's own row order.
- 148 new colors, among them PVP_SCOREBOARD_*_CELL_COLOR, the
EXPANSION_COLOR_* set, and the profession, threat and power-prediction
colors.
- 10 changed values, as the newer client has them: NORMAL_FONT_COLOR
ffd200, RED_FONT_COLOR ff2020, PLAYER_FACTION_COLOR_HORDE ff2934,
PLAYER_FACTION_COLOR_ALLIANCE 00adf0, TALENT_LINK_COLOR 71d5ff, and
more. The C++ tooltips that read the table (item comparison,
equipment sets, links) take the new values. Lua globals that 1.12
FrameXML already defines keep their own values, because Color.lua
only creates the globals that do not exist.
- The four HEALTHBAR_*_HEAL_PREDICTION_GRADIENT_COLOR* rows are gone;
the newer table does not have them and nothing read them.
- A name that the DBC lists twice keeps only its last row, which is
the value the client's own Color.lua loop ends on.
COMPACT_UNIT_FRAME_FRIENDLY_HEALTH_COLOR and
CHARACTER_FRAME_SIDE_PANEL_SKILL_COLOR join the earlier duplicates.
- DEBUFF_TYPE_ENRAGE_COLOR stays as our own row, for
C_UnitAuras.GetAuraDispelTypeColor("Enrage").
Verified in game: GetColors returns 331 rows,
PVP_SCOREBOARD_HORDE_CELL_COLOR is ffff2934 and the alliance one
ff00adf0, GetAuraDispelTypeColor("Enrage") is ffff8c00, and
HEALTHBAR_MY_HEAL_PREDICTION_GRADIENT_COLOR1 is nil.
|
||
|
|
4472c81137 |
feat(lua): retail SharedXML helpers, Spline, ExportUtil and MixinUtil
Ports from retail's Blizzard_ObjectAPI, SharedXML, SharedXMLBase and
FrameXMLUtil, in Blizzard's own text, from the _forever_ build:
- ObjectCache.lua and SpellBookItemLocation.lua (ObjectAPI).
- TypeUtil.lua: ValueToBoolean and StringToBoolean.
- SortUtil.lua: SortUtil.CreateSortManager and the comparators.
- Sequencer.lua, Spline.lua (Catmull-Rom splines), TaggableObject.lua,
ObjectUpdater.lua and ExportUtil.lua (base64 export/import streams).
- AnimationSystem.lua: SetUpAnimation and CancelAnimations.
- SmoothStatusBar.lua: SmoothStatusBarMixin.
- MixinUtil.lua: DrawLine, LineMixin, SparseGridMixin,
DoublyLinkedListMixin, DirtiableMixin, DirtyPhaseMixin and more. 1.12
has no global wipe, so the file reads table.wipe, as the other ports do.
FrameDeltaLerp now takes retail's three arguments and reads the frame
time from GetTickTime(). The old form needed a fourth elapsed argument,
so SmoothStatusBar's per-frame ticker would have errored. Nothing else
called it.
DebugTools drops its private StringToBoolean copy and calls the global
one from TypeUtil for the /framestack arguments.
FadingFrame.lua is not ported: 1.12's own FrameXML defines the same
FadingFrame_* names with no-argument `this` signatures, and ZoneText
calls FadingFrame_OnUpdate() every frame.
Verified in game: StringToBoolean, ValueToBoolean and
SpellBookItemLocation return the expected values, a 2D spline's midpoint
is (5, 10), an export stream round-trips 200 and 9, the sort manager
orders {3,1,2}, the linked list enumerates 0 1 2, ObjectUpdater,
Sequencer and SetUpAnimation finish, a smoothed status bar reaches 100,
and /framestack still opens.
|
||
|
|
1e1463cf9a |
feat(unit): UNIT_IN_RANGE_UPDATE and UNIT_DISTANCE_CHECK_UPDATE
UNIT_IN_RANGE_UPDATE (unitTarget, isInRange). Nothing in the client reacts to a distance: the player moves every frame while it moves, and other units in view are moved a little each frame between their movement packets. So a world-tick pass checks the units, only while a frame is registered for the event. The pass walks the event's subscriber chain (Event::Custom::ForEachListener, which FireValues now uses too): a frame registered with RegisterUnitEvent adds its units (Frame::UnitEvent::Units), and a plain registration adds pet and each party and raid member and their pets. A token fires when Unit::Range::InRange changes for it. UnitInRange now calls the same function. A filter unit that is not a unit token is dropped after one protected IsUnitToken check, since the engine's resolver raises a Lua error for it. UNIT_DISTANCE_CHECK_UPDATE (unitTarget, isInDistance) is true while the client holds a group member's object. UpdateRaidMemberRecord (0x004BADC0) has four E8 callers, which are exactly a player object entering the object table (CGPlayer_C::PostInit 0x005DEC43, PostUpdate on reactivation 0x005DECAF) and leaving it (the release slot 0x005E9ACF, ~CGPlayer_C 0x005DD6AB for an object never released). The calls point at a site that notes a party or raid member's GUID (IsRaidMemberOrPet, not the active player), and the next world tick fires for each of its tokens with whether the object table holds it then. The release slot runs before the manager moves the object to the released table, so a fire in place would still show the member to UnitIsVisible. No loaded DLL references the function or the sites. |
||
|
|
c21e44e086 |
feat(unit): UNIT_AREA_CHANGED fires when a group member changes zone
DiffPartyRecords (0x005E5510) already sets bit 0x80 when the zone in a party record (+0x14) differs, but SignalPartyRecordChanges (0x005E5720) raises nothing for it. The existing SignalSite redirects (the calls in ReadPartyMemberStats and ComparePartyRecord, and the AddPartyMember tail) now fire UNIT_AREA_CHANGED (unitTarget) on that bit, after the engine's own events, once per token of the member. The server sends the zone only to members that cannot see the player. A member in view is built with the player's own zone (BuildPartyRecord stores s_zoneId), the same zone GetRaidRosterInfo gives for a held object, so ComparePartyRecord sets the bit when a member comes into view from another zone. CGPlayer_C::PostInit skips ComparePartyRecord for the active player, so "player" gets no event. |
||
|
|
e76616de83 |
feat(player): PLAYER_MOUNT_DISPLAY_CHANGED fires when the player's mount changes
1.12.1 reacts to a unit's new UNIT_FIELD_MOUNTDISPLAYID in CGUnit_C::OnMountDisplayChanged (0x005FFA50): dismount from the old display, mount the new one with the mount-up effect, refresh the loop sound, quest marker and name. The field's type watcher OnMountDisplayFieldChanged (0x00604570) resolves the unit and calls it with the old value from one E8 call (0x0060459B), only on a real change. That call now reaches a function that runs the handler, then fires PLAYER_MOUNT_DISPLAY_CHANGED (no payload) when the unit is the player. VanillaHelpers calls the handler directly after a local mount morph and patches neither address, so a cosmetic morph fires nothing. |
||
|
|
92794a1822 |
feat(unit): UNIT_TARGETABLE_CHANGED fires when a unit's selectability flips
1.12.1 reacts to a changed UNIT_FIELD_FLAGS in CGUnit_C::OnUnitFlagsChanged (0x005FF580), which the flags field's type watcher OnFlagsFieldChanged (0x006044B0) calls with the old flags from one E8 call (0x006044DB). It handles looting, disarm, reaction, PvP and the aura bit, but nothing reads UNIT_FLAG_NOT_SELECTABLE (0x02000000). Unit::FlagsChanged now owns that call: it runs the handler, then each subscriber with the unit and the flags before and after, since a call site can be redirected only once. Unit::Targetable subscribes and fires UNIT_TARGETABLE_CHANGED (unitTarget) once per token of the unit when the not-selectable bit flips. |
||
|
|
ab0991f054 |
feat(unit): UNIT_CONNECTION fires when a group member goes on or offline
A party record's status byte (+0x08) carries the online bit UnitIsConnected reads. 1.12.1 changes it in three places, and none signals the flip: - The party member stats packet: ReadPartyMemberStats (0x005E5110) ends in SignalPartyRecordChanges (0x005E5720) with the status change bit. The redirected call that already adds the generic power events now also fires UNIT_CONNECTION (unitTarget, isConnected) when the old and new records differ in the online bit. - The group list (0x7D): the server reports a logoff only there. AddPartyMember (0x004E82D0) copies a kept member's previous record and sets the online bit, then stops. Its call now diffs the previous record against the stored one (DiffPartyRecords, 0x005E5510) and runs the same SignalPartyRecordChanges path, so the engine's status events and UNIT_CONNECTION follow. - A raid member outside the player's party has only a raid slot, whose status byte RebuildRaidRoster (0x004BA5F0) sets from the same list. Its call now compares each returning member's online bit before and after and fires UNIT_CONNECTION on a flip; party members are skipped, since AddPartyMember ran first. isConnected is a real boolean, pushed through FireValues. |
||
|
|
26c201b95b |
fix(event): a named unit field gets a watch-copy slot first
Every unit-field watcher keeps a mirror of its bytes in the object's watch copy, at the slot UnitWatchedIndex (0x0047DB20) finds for the field in the table at 0x00839E48. A field not in the table gets 0xB6, past the unit's 170-slot copy. UNIT_MOD_CAST_SPEED (139), named for UNIT_SPELL_HASTE, is such a field, so every watcher on it wrote the field over memory past the copy: a pet's cast-speed update on its owner's logoff put a 1.0f over a list link, and ClntObjMgrRelease crashed on the next SMSG_DESTROY_OBJECT (ERROR #132 at 0x00464A02). The table holds 166 fields and one spare entry (0xB6, the copy's last slot, which no field asks for); UnitWatchedIndex is its only reader and nothing writes it. EngineName now writes a field without a slot into that spare before naming its slot, and refuses the name once the spare is taken. Field 139 takes it, so UNIT_SPELL_HASTE keeps the engine's watcher for every unit. |
||
|
|
09693af5b9 |
feat(unit): UNIT_POWER_UPDATE, UNIT_POWER_FREQUENT and UNIT_MAXPOWER
1.12.1 calls type-wide field observers for every unit whose watched bytes change: ClntObjMgrSetTypeMirrorHandler (0x00468070) puts a record on the global list of a (bank, field), and CGUnit_C::RegisterFieldWatchers (0x006041F0) uses it for the engine's own unit handlers, among them OnPowerFieldChanged on the power block, which only refreshes usability. Two handlers join those lists, one record per POWER1..5 and MAXPOWER1..5 slot, so the callback's field offset is the power type. They fire UNIT_POWER_UPDATE and UNIT_POWER_FREQUENT, or UNIT_MAXPOWER, with (unitTarget, powerType) once per token of the unit. Every client power change is a server update, so FREQUENT fires with UPDATE. Each in-world registration pass removes and re-adds the records through 0x00468240: the first pass of a session runs in CGGameUI::InitializeGame, after MirrorInitialize (0x0047F840) has rebuilt the tables a record's copy offset comes from, and the removal keeps /reload from stacking a second record. The list array has no other writer, so nothing frees a record behind us. A group member the client cannot see has no unit to watch; its power comes in the party member stats packet. ReadPartyMemberStats (0x005E5110) and ComparePartyRecord (0x005F0B80) end in SignalPartyRecordChanges (0x005E5720), which fires the per-type power events for the changed record bits. Both E8 calls now reach a function that calls it and then fires the generic events for the same bits, the member's and its pet's. |
||
|
|
f24b7e594b |
feat(unit): UNIT_SPELL_HASTE fires when a unit's spell haste changes
1.12.1 turns unit-field changes into events by index: FUN_0051bbb0 watches unit field i when slot i of the static event-name array at 0x00BE1198 is named, and FUN_0051bd50 signals event i once per token of the unit. UNIT_MOD_CAST_SPEED, the field UnitSpellHaste reads, is index 139 (OFF_UNIT_MOD_CAST_SPEED / 4), and slot 139 has no name, so the engine never watched it. Event::Custom::EngineName names slot 139, and the engine's own watchers fire the event for every token. Nothing else signals 139 by number: it is above the glue band and not in the chat-type event table. |
||
|
|
35c8ba5688 | docs(readme): list UNIT_TARGET | ||
|
|
e2a34bd18a |
feat(unit): UNIT_TARGET fires when a unit's target changes
1.12.1 already turns unit-field changes into events. FUN_0051bbb0 registers a watcher on unit field i for each named slot i of the static event-name array at 0x00BE1198, and the watcher (FUN_0051bd50) signals event i once per token of the unit through the broadcast FUN_00515e50. The field index is the event id. UNIT_FIELD_TARGET is index 10, and the watcher's size selector still gives it the 8 bytes of a GUID, but slot 10 has no name, so the engine never watches the field. Event::Custom::EngineName names such a slot. It writes the name into the static array at load, before any world init or unit watch. World init copies the array into the live event table (0x0048FEA1), and the engine's own watchers then fire the event for every token, with focus, nameplateN, markN and focustarget included. The entry joins the reservation list with a fixed slot, so it is documented, kept across /reload, and not counted by Grow. Slot 10 is in the glue band. Its one by-number signal is the glue realm-list rebuild (0x0046E73D), which only CGlueMgr::Idle reaches. |
||
|
|
2f787889f7 |
fix(animation): a frame's alpha group keeps its textures' gradients
When an alpha group starts on a frame, every region below it stores its vertex alpha, and every update writes that alpha back. The colour getter (0x77F8C0) reads a gradient back as white, and the setter (0x77F750) shrinks a gradient's four entries to that one white entry. So a gradient under a fading frame went flat at the first update and stayed flat after the group ended. pfUI's easteregg night lost its fade to the bottom. SetVertexAlpha now writes nothing when the alpha is unchanged. For one colour entry the setter already does nothing then, so only the gradient case changes. The frame's fade still reaches the gradient: a change of the frame's alpha refolds each region's entries (0x77FAC0). 3.3.5's and 4.3.4's PreOnAnimUpdate drop the gradient the same way. A texture that an alpha animation itself fades still loses its gradient. Verified in game: a black gradient on a frame fading by -0.5 over 3 s keeps its gradient during and after the fade. |
||
|
|
9967cc0839 |
feat(lua): Spell objects, ContinuableContainer and TableBuilder
Ports from retail's Blizzard_ObjectAPI and SharedXML, in Blizzard's own text, from the _forever_ build (the newest interface code on disk): - Util/Spell.lua: Spell:CreateFromSpellID and SpellMixin. - Util/ContinuableContainer.lua: one callback for a group of item and spell objects. - Util/IndexRangeDataProvider.lua: CreateIndexRangeDataProvider, which ScrollBoxListView already expected. - Util/TableBuilder.lua: CreateTableBuilder, for the existing ScrollUtil.RegisterTableBuilder. - FrameXML/CallbackRegistrant: CallbackRegistrantMixin and CallbackRegistrantTemplate. AsyncCallbackSystem.lua gets its ASYNC_SPELL type and SpellEventListener back, so it is the _forever_ text again. New in the DLL for SpellMixin: - C_Spell.IsSpellDataCached, C_Spell.RequestLoadSpellData and SPELL_DATA_LOAD_RESULT. Every spell is client data, so a spell that exists is cached, and a request fires the event before it returns: (spellID, 1), or (spellID, nil) for an ID with no spell. Retail marks the event synchronous, and AsyncCallbackSystem relies on that. - C_Spell.GetSpellDescriptionForItemLocation. The item tooltip expands a spell's text with the same arguments GetSpellDescription passes, so it returns that text. The item location is still required. Verified in game: IsSpellDataCached(133) and (999999) are true and false, Spell:CreateFromSpellID(133) calls back with (133, 1), a container with item 19019 and spell 133 calls back, CreateIndexRangeDataProvider(5) has size 5, and GetSpellDescriptionForItemLocation(133, slot 1) equals GetSpellDescription(133). |
||
|
|
e47e881ae1 |
fix(event): FireValues applies RegisterUnitEvent filters
FireValues walks the subscriber chain itself and runs each OnEvent
through RunSlotWithValues, so it never reached the runner where
Frame::UnitEvent's gate sits. RegisterUnitEvent("UNIT_AURA_DELTA", unit)
fired for every unit's deltas.
Frame::UnitEvent::Accepts shares the gate's match. FireValues asks it
for each frame when the first value is a string, the same rule the
engine path uses for a %s arg1.
v1.18.9
|
||
|
|
d9da100110 |
feat(tradeskill): linked windows show the crafter's name
3.3.5's interface never shows whose profession a linked window holds. Port 4.3.4's TradeSkillLinkNameButton and TradeSkillFrame_SetLinkName to TradeSkillFrame and CraftFrame: "[name]" after the title, and a click on it starts a whisper. The title moves left by half the name, from its own anchor, so Turtle's -30 offset stays.v1.18.8 |