mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-14 07:00:37 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Brues
|
7cb6cda101 | ||
|
Brues
|
5ab497f2c7 | ||
|
Brues
|
205d1fd43b | ||
|
Brues
|
950c9deb76 |
@@ -71,6 +71,7 @@ In the Frame rows, a name that starts with `:` is a method of the widget that th
|
||||
| [Creature](docs/API.md#creature) | `C_CreatureInfo.GetCreatureID`, `C_CreatureInfo.GetCreatureInfoByID`, `C_CreatureInfo.RequestLoadCreatureByID`, `C_CreatureInfo.GetRaceInfo`, `C_CreatureInfo.GetClassInfo`, `C_CreatureInfo.GetCreatureFamilyInfo`, `C_CreatureInfo.GetCreatureFamilyIDs`, `C_CreatureInfo.GetFactionInfo`, `C_CreatureInfo.GetCreatureTypeInfo`, `C_CreatureInfo.GetCreatureTypeIDs` |
|
||||
| [Currency](docs/API.md#currency) | `GetCoinText`, `C_CurrencyInfo.GetCoinText`, `GetCoinTextureString`, `C_CurrencyInfo.GetCoinTextureString` |
|
||||
| EncodingUtil | `C_EncodingUtil.CompressString`, `C_EncodingUtil.DecompressString`, `C_EncodingUtil.EncodeBase64`, `C_EncodingUtil.DecodeBase64`, `C_EncodingUtil.EncodeHex`, `C_EncodingUtil.DecodeHex`, `C_EncodingUtil.SerializeJSON`, `C_EncodingUtil.DeserializeJSON`, `C_EncodingUtil.SerializeCBOR`, `C_EncodingUtil.DeserializeCBOR` |
|
||||
| [DeathInfo](docs/API.md#deathinfo) | `C_DeathInfo.GetSelfResurrectOptions`, `C_DeathInfo.UseSelfResurrectOption` |
|
||||
| [EquipmentSet](docs/API.md#equipmentset) | `C_EquipmentSet.CanUseEquipmentSets`, `C_EquipmentSet.ClearIgnoredSlotsForSave`, `C_EquipmentSet.CreateEquipmentSet`, `C_EquipmentSet.DeleteEquipmentSet`, `C_EquipmentSet.EquipmentSetContainsLockedItems`, `C_EquipmentSet.GetEquipmentSetID`, `C_EquipmentSet.GetEquipmentSetIDs`, `C_EquipmentSet.GetEquipmentSetInfo`, `C_EquipmentSet.GetIgnoredSlots`, `C_EquipmentSet.GetItemIDs`, `C_EquipmentSet.GetItemLocations`, `C_EquipmentSet.GetNumEquipmentSets`, `C_EquipmentSet.IgnoreSlotForSave`, `C_EquipmentSet.IsSlotIgnoredForSave`, `C_EquipmentSet.ModifyEquipmentSet`, `C_EquipmentSet.PickupEquipmentSet`, `C_EquipmentSet.SaveEquipmentSet`, `C_EquipmentSet.UnignoreSlotForSave`, `C_EquipmentSet.UseEquipmentSet` |
|
||||
| [Events](docs/API.md#events) | `C_EventUtils.IsEventValid`, `GetFramesRegisteredForEvent` |
|
||||
| [Expansion](docs/API.md#expansion) | `ClassicExpansionAtLeast`, `ClassicExpansionAtMost`, `GetAccountExpansionLevel`, `GetClassicExpansionLevel`, `GetExpansionLevel`, `GetMaxPlayerLevel` |
|
||||
@@ -85,7 +86,7 @@ In the Frame rows, a name that starts with `:` is a method of the widget that th
|
||||
| [Frame: StatusBar](docs/API.md#statusbarsetreversefillisreversefill--statusbargetreversefill) | `:SetReverseFill` / `:GetReverseFill`, `:SetRotatesTexture` / `:GetRotatesTexture`, `:SetFillStyle` / `:GetFillStyle`, `:SetColorFill`, `:SetStatusBarDesaturated` / `:IsStatusBarDesaturated`, `:SetStatusBarDesaturation` / `:GetStatusBarDesaturation` |
|
||||
| [Frame: Slider](docs/API.md#sliderenable--sliderdisable--sliderisenabled) | `:Enable` / `:Disable` / `:IsEnabled` |
|
||||
| [Frame: Cooldown](docs/API.md#createframecooldown--name-parent-template) | `CreateFrame("Cooldown")`, `:SetCooldown`, `:SetCooldownDuration`, `:SetCooldownFromExpirationTime`, `:Clear`, `:GetCooldownTimes`, `:GetCooldownDuration`, `:GetCooldownDisplayDuration`, `:Pause` / `:Resume`, `:SetPaused` / `:IsPaused`, `:SetReverse` / `:GetReverse`, `:SetDrawEdge` / `:GetDrawEdge`, `:SetDrawSwipe` / `:GetDrawSwipe`, `:SetDrawBling` / `:GetDrawBling`, `:SetSwipeColor`, `:SetEdgeColor`, `:SetSwipeTexture`, `:SetEdgeTexture`, `:SetBlingTexture`, `:SetRotation` / `:GetRotation`, `:SetHideCountdownNumbers` / `:GetHideCountdownNumbers`, `:GetCountdownFontString`, `:SetCountdownAbbrevThreshold` / `:GetCountdownAbbrevThreshold`, `:SetCountdownMillisecondsThreshold` / `:GetCountdownMillisecondsThreshold`, `:SetMinimumCountdownDuration` / `:GetMinimumCountdownDuration`, `OnCooldownDone`, `CooldownFrame_Set`, `CooldownFrame_Clear`, `CooldownFrame_SetDisplayAsPercentage` |
|
||||
| [Frame: ScrollingMessageFrame](docs/API.md#smfsethyperlinksenabledenabled--smfgethyperlinksenabled) | `:SetHyperlinksEnabled` / `:GetHyperlinksEnabled` |
|
||||
| [Frame: ScrollingMessageFrame](docs/API.md#smfsethyperlinksenabledenabled--smfgethyperlinksenabled) | `:SetHyperlinksEnabled` / `:GetHyperlinksEnabled`, `:GetMessageInfo` (with the extra `:AddMessage` values), `:SetScrollOffset` / `:GetScrollOffset`, `:GetMaxScrollRange`, `:ScrollByAmount`, `:SetInsertMode` / `:GetInsertMode`, `:AddOnDisplayRefreshedCallback` |
|
||||
| [Frame: scripts](docs/API.md#onenable-and-ondisable-scripts) | `OnEnable`, `OnDisable`, `OnMinMaxChanged`, `OnAttributeChanged`, `OnCharComposition`, `OnTextChanged` (`userInput`), `PreClick`, `PostClick`, `SetModernScriptArgs` / `GetModernScriptArgs` |
|
||||
| [FriendList](docs/API.md#friendlist) | `AddOrRemoveFriend`, `C_FriendList.GetFriendInfo`, `C_FriendList.GetFriendInfoByIndex`, `C_FriendList.GetNumFriends`, `C_FriendList.GetNumOnlineFriends`, `C_FriendList.GetNumWhoResults`, `C_FriendList.GetWhoInfo`, `C_FriendList.IsFriend`, `C_FriendList.IsIgnored`, `C_FriendList.IsIgnoredByGuid`, `C_FriendList.IsWhoQueryPending`, `C_FriendList.SendWhoQueryByName`, `C_FriendList.SetFriendNotes`, `C_FriendList.SetFriendNotesByIndex` |
|
||||
| [GameObject](docs/API.md#gameobject) | `C_GameObjectInfo.GetGameObjectInfoByID`, `C_GameObjectInfo.RequestLoadGameObjectByID`, `ClosestGameObjectPosition` |
|
||||
@@ -313,6 +314,7 @@ when launching with `-console`), not as Lua functions. See the
|
||||
| `QUEST_QUERY_COMPLETE` | *(none)* (Turtle WoW only) |
|
||||
| `QUEST_REMOVED` | `questID` |
|
||||
| `QUEST_TURNED_IN` | `questID, xpReward, moneyReward` |
|
||||
| `SELF_RES_SPELL_CHANGED` | *(none)* |
|
||||
| `SOUNDKIT_FINISHED` | `soundHandle` (only for sounds played with `runFinishCallback`) |
|
||||
| `UNIT_AURA_DELTA` | `unitTarget, updateInfo` (the instance IDs of the auras added, updated, and removed) |
|
||||
| `UNIT_SPELLCAST_SENT` | `"player", target, castGUID, spellID, spellName, rank` |
|
||||
@@ -360,6 +362,7 @@ when launching with `-console`), not as Lua functions. See the
|
||||
| Spellbook bank | `Enum.SpellBookSpellBank.{Player,Pet}` (0–1) |
|
||||
| Spellbook item type | `Enum.SpellBookItemType.{None,Spell,FutureSpell,PetAction,Flyout}` (0–4; 1.12 only yields `Spell`/`PetAction`) |
|
||||
| Player swing type | `Enum.PlayerSwingType.{MainHand,OffHand,Ranged}` (0–2) |
|
||||
| Self-resurrect option type | `Enum.SelfResurrectOptionType.{Spell,Item}` (0–1) |
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
@@ -4081,9 +4081,14 @@ Each entry still needs the usual check of how the engine does it before building
|
||||
`GetRotatesTexture` (`CSimpleStatusBar.cpp:135`, the vertical texcoord path
|
||||
at `:285`). Retail adds `SetFillStyle` (STANDARD / CENTER / REVERSE),
|
||||
`SetColorFill`, `SetStatusBarDesaturated` / `Desaturation`.
|
||||
- **ScrollingMessageFrame** `SetInsertMode` / `GetInsertMode`,
|
||||
`GetMessageInfo`, `RemoveMessagesByAccessID`, `RemoveMessagesByExtraData`,
|
||||
`SetScrollOffset` — in C in 4.3.4 (retail moved the type to Lua).
|
||||
- **DONE** (`src/scrollingmessageframe/`, retail's shapes).
|
||||
**ScrollingMessageFrame** `GetMessageInfo`, `SetScrollOffset` (1.12's
|
||||
`SetScrollFromBottom`, 0x00793070, under its later name, clamped as
|
||||
retail), `GetScrollOffset`, `GetMaxScrollRange`, `ScrollByAmount`,
|
||||
`AddOnDisplayRefreshedCallback`, `SetInsertMode` / `GetInsertMode` (TOP
|
||||
through a redirect of the layout's one line-anchor call, 0x00788975).
|
||||
- **ScrollingMessageFrame** `RemoveMessagesByAccessID` / `RemoveMessagesByExtraData` (4.3.4 C; retail
|
||||
has `RemoveMessagesByPredicate`): 1.12 has no ring compaction.
|
||||
- **DONE** (`src/editbox/Focus.cpp`, `src/animation/Framerate.cpp`).
|
||||
**Globals** (`SimpleFrameScript_Scripts.cpp`): `GetCurrentKeyBoardFocus()`
|
||||
(the focused edit box's wrapper, or nil); `SetMaxAnimFramerate(fps)` /
|
||||
|
||||
+165
@@ -182,6 +182,10 @@ build instructions.
|
||||
- [`GetCursorInfo()`](#getcursorinfo)
|
||||
- [`CursorHasMacro()`](#cursorhasmacro)
|
||||
|
||||
- [DeathInfo](#deathinfo)
|
||||
- [`C_DeathInfo.GetSelfResurrectOptions()`](#c_deathinfogetselfresurrectoptions)
|
||||
- [`C_DeathInfo.UseSelfResurrectOption(optionType, id)`](#c_deathinfouseselfresurrectoptionoptiontype-id)
|
||||
|
||||
- [EquipmentSet](#equipmentset)
|
||||
- [Overview & file format](#overview--file-format)
|
||||
- [`C_EquipmentSet.CanUseEquipmentSets()`](#c_equipmentsetcanuseequipmentsets)
|
||||
@@ -241,6 +245,7 @@ build instructions.
|
||||
- [`QUEST_QUERY_COMPLETE` event](#quest_query_complete-event)
|
||||
- [`QUEST_REMOVED` event](#quest_removed-event)
|
||||
- [`QUEST_TURNED_IN` event](#quest_turned_in-event)
|
||||
- [`SELF_RES_SPELL_CHANGED` event](#self_res_spell_changed-event)
|
||||
- [`SOUNDKIT_FINISHED` event](#soundkit_finished-event)
|
||||
- [`UNIT_AURA_DELTA` event](#unit_aura_delta-event)
|
||||
- [`UNIT_FACTION` event (fire-coverage fix)](#unit_faction-event-fire-coverage-fix)
|
||||
@@ -380,6 +385,10 @@ build instructions.
|
||||
- [`frame:HookScript(scriptType, handler)`](#framehookscriptscripttype-handler)
|
||||
- [Script binding types](#script-binding-types)
|
||||
- [`smf:SetHyperlinksEnabled(enabled)` / `smf:GetHyperlinksEnabled()`](#smfsethyperlinksenabledenabled--smfgethyperlinksenabled)
|
||||
- [`smf:GetMessageInfo(index)`](#smfgetmessageinfoindex)
|
||||
- [`smf:SetScrollOffset(offset)` / `smf:GetScrollOffset()` / `smf:GetMaxScrollRange()` / `smf:ScrollByAmount(amount)`](#smfsetscrolloffsetoffset--smfgetscrolloffset--smfgetmaxscrollrange--smfscrollbyamountamount)
|
||||
- [`smf:SetInsertMode(mode)` / `smf:GetInsertMode()`](#smfsetinsertmodemode--smfgetinsertmode)
|
||||
- [`smf:AddOnDisplayRefreshedCallback(callback)`](#smfaddondisplayrefreshedcallbackcallback)
|
||||
- [`frame:IsEventRegistered(event)`](#frameiseventregisteredevent)
|
||||
- [`frame:RegisterUnitEvent(event, ...units)`](#frameregisteruniteventevent-units)
|
||||
- [`frame:GetEffectiveAlpha()`](#framegeteffectivealpha)
|
||||
@@ -4359,6 +4368,57 @@ Changes to what the cursor holds are reported by the
|
||||
|
||||
Returns `true` if the cursor holds a macro, and `false` if it does not.
|
||||
|
||||
## DeathInfo
|
||||
|
||||
### `C_DeathInfo.GetSelfResurrectOptions()`
|
||||
|
||||
```
|
||||
options = C_DeathInfo.GetSelfResurrectOptions()
|
||||
```
|
||||
|
||||
Returns an array of the ways that the dead player can resurrect themselves.
|
||||
Each entry is a `SelfResurrectOption` table:
|
||||
|
||||
| Field | Type | Description |
|
||||
|---|---|---|
|
||||
| `name` | string | The name of the spell or the item. |
|
||||
| `optionType` | number | `Enum.SelfResurrectOptionType.Spell` (0) or `Enum.SelfResurrectOptionType.Item` (1). |
|
||||
| `id` | number | The spell ID or the item ID. |
|
||||
| `canUse` | boolean | Always `true`. |
|
||||
| `isLimited` | boolean | Always `false`. |
|
||||
| `priority` | number | Always `0`. |
|
||||
|
||||
The array has one entry at most. A self-resurrection spell, such as
|
||||
Soulstone Resurrection or Reincarnation, comes before an item. The array is
|
||||
empty when the player is alive or a ghost, or has no option. The function
|
||||
returns nothing before the player enters the world.
|
||||
|
||||
```lua
|
||||
local options = C_DeathInfo.GetSelfResurrectOptions()
|
||||
if options and options[1] then
|
||||
print("You can resurrect with", options[1].name)
|
||||
end
|
||||
```
|
||||
|
||||
[`SELF_RES_SPELL_CHANGED`](#self_res_spell_changed-event) fires when the
|
||||
self-resurrection spell changes.
|
||||
|
||||
### `C_DeathInfo.UseSelfResurrectOption(optionType, id)`
|
||||
|
||||
Resurrects the dead player with an option from
|
||||
[`C_DeathInfo.GetSelfResurrectOptions`](#c_deathinfogetselfresurrectoptions).
|
||||
`optionType` and `id` must match an entry that it returns now. If they do
|
||||
not match, the call does nothing. An item option uses the item, and this
|
||||
stops a spell cast in progress.
|
||||
|
||||
```lua
|
||||
local options = C_DeathInfo.GetSelfResurrectOptions()
|
||||
local option = options and options[1]
|
||||
if option then
|
||||
C_DeathInfo.UseSelfResurrectOption(option.optionType, option.id)
|
||||
end
|
||||
```
|
||||
|
||||
## EquipmentSet
|
||||
|
||||
`C_EquipmentSet.*` — named sets of gear you can save and equip again
|
||||
@@ -5783,6 +5843,14 @@ quest invalidated, etc.). Only fires on a real successful turn-in.
|
||||
> done, quest removed from log). Hooking the packet handler gives
|
||||
> us a clean turn-in signal.
|
||||
|
||||
### `SELF_RES_SPELL_CHANGED` event
|
||||
|
||||
Fires with no payload when the self-resurrection spell of the player
|
||||
changes. For example, it fires when the player dies with a Soulstone, and
|
||||
again when the player comes back to life. When it fires, read
|
||||
[`C_DeathInfo.GetSelfResurrectOptions`](#c_deathinfogetselfresurrectoptions)
|
||||
again. A change to an item option does not fire this event.
|
||||
|
||||
### `SOUNDKIT_FINISHED` event
|
||||
|
||||
Fires when a sound finishes playing.
|
||||
@@ -8599,6 +8667,103 @@ ChatFrame1:SetHyperlinksEnabled(false) -- links in this chat window stop react
|
||||
ChatFrame1:GetHyperlinksEnabled() -- false
|
||||
```
|
||||
|
||||
### `smf:GetMessageInfo(index)`
|
||||
|
||||
On ScrollingMessageFrame. Returns one message of the frame: its text, its
|
||||
color, and the extra values that `AddMessage` got for the message. Index 1 is
|
||||
the oldest message, and `smf:GetNumMessages()` is the index of the newest
|
||||
message. If no message has the index, the function returns nothing. If
|
||||
`index` is not a number, the function gives an error.
|
||||
|
||||
- `text` is the text that the frame keeps, with its color codes.
|
||||
- `r`, `g` and `b` are the color that the frame shows for the message. After
|
||||
`UpdateColorByID` changes the color, these values also change. The frame
|
||||
keeps each color value in steps of 1/255, so `0.5` returns as `0.50196…`.
|
||||
- `smf:AddMessage(text, r, g, b, ...)` keeps all the values after `b`.
|
||||
`GetMessageInfo` returns these values in the same order, nil values
|
||||
included.
|
||||
|
||||
An addon that replaces `AddMessage` and gives only `text, r, g, b` to the
|
||||
original function removes the extra values.
|
||||
|
||||
```lua
|
||||
ChatFrame1:AddMessage("hello", 1, 0.5, 0, 7, "extra")
|
||||
ChatFrame1:GetMessageInfo(ChatFrame1:GetNumMessages())
|
||||
-- "hello", 1, 0.50196078431373, 0, 7, "extra"
|
||||
|
||||
for i = 1, ChatFrame1:GetNumMessages() do
|
||||
local text, r, g, b = ChatFrame1:GetMessageInfo(i) -- oldest message first
|
||||
end
|
||||
```
|
||||
|
||||
### `smf:SetScrollOffset(offset)` / `smf:GetScrollOffset()` / `smf:GetMaxScrollRange()` / `smf:ScrollByAmount(amount)`
|
||||
|
||||
On ScrollingMessageFrame. The scroll offset is the number of lines that the
|
||||
frame is scrolled away from the newest message. When the frame is not
|
||||
scrolled, the offset is 0. The largest offset is `GetMaxScrollRange()`, that
|
||||
is `GetNumMessages() - 1`, or 0 for an empty frame. At that offset, the oldest
|
||||
message is the bottom line, or the top line in TOP insert mode.
|
||||
|
||||
- `SetScrollOffset(offset)` scrolls to `offset`. An offset less than 0 or
|
||||
more than `GetMaxScrollRange()` changes to the nearest limit.
|
||||
- `ScrollByAmount(amount)` adds `amount` to the offset. A positive amount
|
||||
scrolls to older messages. The function also shows the faded lines
|
||||
again, also when the offset does not change.
|
||||
- If `offset` or `amount` is not a number, the function gives an error.
|
||||
|
||||
```lua
|
||||
ChatFrame1:ScrollByAmount(3) -- 3 lines up
|
||||
ChatFrame1:GetScrollOffset() -- 3
|
||||
ChatFrame1:SetScrollOffset(ChatFrame1:GetMaxScrollRange()) -- the oldest message
|
||||
ChatFrame1:SetScrollOffset(0) -- the newest message again
|
||||
```
|
||||
|
||||
### `smf:SetInsertMode(mode)` / `smf:GetInsertMode()`
|
||||
|
||||
On ScrollingMessageFrame. The insert mode tells where the newest message
|
||||
shows.
|
||||
|
||||
- `SCROLLING_MESSAGE_FRAME_INSERT_MODE_BOTTOM` (2) shows the newest message
|
||||
at the bottom, with older messages above it. This is the default.
|
||||
- `SCROLLING_MESSAGE_FRAME_INSERT_MODE_TOP` (1) shows the newest message at
|
||||
the top, with older messages below it.
|
||||
|
||||
In both modes, the scroll offset counts lines from the newest message. A
|
||||
change of mode moves the lines that show and runs the display-refreshed
|
||||
callbacks. If `mode` is the current mode, `SetInsertMode` does nothing. If
|
||||
`mode` is not one of the two values, the function gives an error.
|
||||
|
||||
```lua
|
||||
local f = CreateFrame("ScrollingMessageFrame", nil, UIParent)
|
||||
f:SetInsertMode(SCROLLING_MESSAGE_FRAME_INSERT_MODE_TOP)
|
||||
f:AddMessage("first")
|
||||
f:AddMessage("second") -- shows above "first"
|
||||
f:GetInsertMode() -- 1
|
||||
```
|
||||
|
||||
### `smf:AddOnDisplayRefreshedCallback(callback)`
|
||||
|
||||
On ScrollingMessageFrame. Adds a function that the frame calls as
|
||||
`callback(frame)` after it refreshes the messages that it shows. The frame
|
||||
refreshes after a new message, a scroll, a resize, a font change, or
|
||||
`Clear()`.
|
||||
|
||||
- The callbacks run one time, in the next update of the frame, in the order
|
||||
that you added them.
|
||||
- A hidden frame runs its callbacks when it shows again.
|
||||
- An error in one callback goes to the error handler, and the other callbacks
|
||||
still run.
|
||||
- A change that a callback makes to the frame does not run the callbacks
|
||||
again.
|
||||
- If `callback` is not a function, the method gives an error. You cannot
|
||||
remove a callback.
|
||||
|
||||
```lua
|
||||
ChatFrame1:AddOnDisplayRefreshedCallback(function(frame)
|
||||
MyScrollLabel:SetText(frame:GetScrollOffset() .. " / " .. frame:GetMaxScrollRange())
|
||||
end)
|
||||
```
|
||||
|
||||
### `frame:IsEventRegistered(event)`
|
||||
|
||||
Returns `true` if the frame is registered for `event`, else `false` (also
|
||||
|
||||
+84
-1
@@ -988,7 +988,8 @@ enum Offsets {
|
||||
// message. Every new message shifts the newest index, so EVERY visible slot
|
||||
// is re-SetText'd -> its inline icons must be recomputed; the engine builds
|
||||
// the line lazily at paint, so icons land one frame after the glyphs (the
|
||||
// one-frame lag). Text::InlineTexture co-hooks this and, post-refresh,
|
||||
// one-frame lag). ScrollingMessageFrame::Layout owns the hook and fans
|
||||
// out after it; Text::InlineTexture listens and, post-refresh,
|
||||
// forces each icon-bearing line to resolve+build and applies its icon
|
||||
// placement synchronously — pre-render (the refresh runs from the SMF's
|
||||
// Lua/event-driven methods, never mid-render), so icons draw with their
|
||||
@@ -2425,6 +2426,16 @@ enum Offsets {
|
||||
// right after that same unlock — Player::Equipment co-hooks it to do so.
|
||||
FUN_INV_SLOT_CHANGED_OBSERVER = 0x005DDCF0,
|
||||
|
||||
// CGPlayer_C::AddActiveWatchers / its removal — `void __thiscall
|
||||
// (CGPlayer_C *)`, plain `ret`. Register and remove the active player's
|
||||
// bank-PLAYER observers (inventory, quests, coinage, skills, the
|
||||
// 0x005DE4B0 event fields); 4.3.4's SetActiveMirrorHandlers (0x0056E430)
|
||||
// / UnsetActiveMirrorHandlers. Add runs on arrival (0x005DEA58) and
|
||||
// reactivation (0x005E9C00); remove only at 0x005E9B50, for the active
|
||||
// player.
|
||||
FUN_PLAYER_ADD_ACTIVE_WATCHERS = 0x005DD8A0,
|
||||
FUN_PLAYER_REMOVE_ACTIVE_WATCHERS = 0x005DE5B0,
|
||||
|
||||
// PLAYER_FIELD_INV_SLOT_HEAD — first of the 19 equipment-slot u64 GUID
|
||||
// fields in the player descriptor (0x4A8..0x538, stride 8; 0x540 is
|
||||
// the first equipped-bag slot). 0-based slot = (offset - 0x4A8) >> 3;
|
||||
@@ -4582,6 +4593,12 @@ enum Offsets {
|
||||
// (see OFF_UNIT_FIELD_CHANNEL_SPELL below); PLAYER_FLAGS only
|
||||
// exists on the +0xE68 sub-struct here.
|
||||
OFF_CGPLAYER_INFO = 0xE68,
|
||||
// PLAYER_SELF_RES_SPELL in that block (UpdateField table: player index
|
||||
// 0x40C, owner-only): the spell the server offers a dead player to raise
|
||||
// themselves (Soulstone Resurrection, Reincarnation), 0 for none. Also
|
||||
// its offset in observer bank DESC_OBSERVER_BANK_PLAYER. Read by
|
||||
// HasSoulstone (0x0048ACC6) and UseSoulstone (0x0048ADB6).
|
||||
OFF_CGPLAYER_INFO_SELF_RES_SPELL = 0x1030,
|
||||
// The engine's explored-area bit test (benilla `IsAreaExplored`):
|
||||
// __thiscall(this = player + OFF_CGPLAYER_INFO, int areaBit) → nonzero
|
||||
// when explored, ret 4. Reads `[this] + 0xE6C` (the 0x100-byte
|
||||
@@ -4993,6 +5010,16 @@ enum Offsets {
|
||||
// target is passed, so passing zero (no target) is fine for most
|
||||
// items. `flag` is 0 in every Script_UseContainerItem call site.
|
||||
FUN_ITEM_USE = 0x005D8D00,
|
||||
// The player's self-resurrect item — `CGItem_C *__thiscall(CGPlayer_C *)`,
|
||||
// plain `ret`: the first carried item (equipment, bags, backpack,
|
||||
// keyring) with an on-use spell of effect 94 (SELF_RESURRECT), or null.
|
||||
// HasSoulstone and UseSoulstone ask it when PLAYER_SELF_RES_SPELL is 0.
|
||||
FUN_PLAYER_SELF_RES_ITEM = 0x005ED630,
|
||||
// Script_UseSoulstone — the Lua C function itself, `int __fastcall(L)`;
|
||||
// reads no argument and pushes nothing. Sends CMSG_SELF_RES (0x2B3, no
|
||||
// body) when PLAYER_SELF_RES_SPELL is set, else cancels the cast
|
||||
// (0x006E4940(1, 1, 0x1C)) and uses FUN_PLAYER_SELF_RES_ITEM's item.
|
||||
FUN_SCRIPT_USE_SOULSTONE = 0x0048AD70,
|
||||
// `CGPlayer::AutoEquipCursorItem` — `__thiscall(CGPlayer *this, int flag)`.
|
||||
// The engine-internal helper that `Script_AutoEquipCursorItem`
|
||||
// (`0x0048A040`) is a thin wrapper around: that wrapper just
|
||||
@@ -12811,6 +12838,62 @@ enum Offsets {
|
||||
OFF_SIMPLEHTML_FONTS = 0x350,
|
||||
VAR_SIMPLEHTML_LUA_TYPE_ID = 0x00CF4F64,
|
||||
FUN_SIMPLEHTML_READ_TEXT_TYPE = 0x00795D80,
|
||||
// The ScrollingMessageFrame's message ring. GetNumMessages (0x007934D0)
|
||||
// pushes the count. The ring's one writer, 0x00788150 (`__thiscall(smf,
|
||||
// text, const CImVector *color, int id)`, `ret 0xC`), called only by the
|
||||
// AddMessage method (FUN_SCRIPT_..._ADD_MESSAGE, `int __fastcall(L)`),
|
||||
// raises the count up to the limit, advances the position (wrapping at
|
||||
// the limit) and fills the record there. So message i, 1 the oldest, is
|
||||
// record (position - count + i), plus the limit when negative. Records
|
||||
// are 0x18 bytes: the text (an SStrDupA copy), the colour (a CImVector,
|
||||
// the dword 0xAARRGGBB: AddMessage builds it R, G, B with alpha 0xFF at
|
||||
// 0x00792ADD..0x00792B11), shown +0x8, the visible and fade times +0xC and
|
||||
// +0x10, and the integer id +0x14 (benilla-re ui/messageframe).
|
||||
FUN_SCRIPT_SCROLLINGMESSAGEFRAME_ADD_MESSAGE = 0x00792900,
|
||||
OFF_SCROLLINGMESSAGEFRAME_MESSAGE_COUNT = 0x33C,
|
||||
OFF_SCROLLINGMESSAGEFRAME_MAX_MESSAGES = 0x340,
|
||||
OFF_SCROLLINGMESSAGEFRAME_MESSAGE_POS = 0x344, // the newest record; -1 when empty
|
||||
OFF_SCROLLINGMESSAGEFRAME_MESSAGES = 0x394, // the record array
|
||||
SCROLLINGMESSAGEFRAME_MESSAGE_STRIDE = 0x18,
|
||||
OFF_SCROLLINGMESSAGEFRAME_MESSAGE_TEXT = 0x0,
|
||||
OFF_SCROLLINGMESSAGEFRAME_MESSAGE_COLOR = 0x4,
|
||||
// The frame's scroll in retail's units, the lines it is scrolled up from
|
||||
// the newest message. ScrollToOffset (`void __thiscall(smf, int offset)`,
|
||||
// `ret 4`) is the body of SetScrollFromBottom (0x00793070), 4.3.4's
|
||||
// SetScrollOffset (0x0051E6F0) step for step: the record (position -
|
||||
// offset + count) % count, then it re-arms the shown lines (0x00788B80)
|
||||
// when that is the current scroll and lays the lines out from it
|
||||
// (FUN_SMF_DISPLAY_REFRESH) otherwise. ScrollOffset (`int
|
||||
// __thiscall(smf)`) is the inverse, (position - scroll + count) % count,
|
||||
// 0 when empty; the GetCurrentScroll method pushes it.
|
||||
FUN_SCROLLINGMESSAGEFRAME_SCROLL_TO_OFFSET = 0x00788700,
|
||||
FUN_SCROLLINGMESSAGEFRAME_SCROLL_OFFSET = 0x00788AC0,
|
||||
FUN_SCRIPT_SCROLLINGMESSAGEFRAME_GET_CURRENT_SCROLL = 0x00793650,
|
||||
// The frame's OnFrameUpdate override (vtable+0x38, see
|
||||
// FUN_FRAME_ON_UPDATE), `void __thiscall(smf, float elapsed)`, `ret 4`:
|
||||
// FUN_FRAME_ON_UPDATE (OnUpdate), then the fader.
|
||||
FUN_SCROLLINGMESSAGEFRAME_ON_UPDATE = 0x00788460,
|
||||
// The line layout (FUN_SMF_DISPLAY_REFRESH) anchors a line once, when it
|
||||
// creates the line's font string, through the one SetPoint call at
|
||||
// CALL_SMF_LAYOUT_ANCHOR_LINE (`E8 rel32` to FUN_REGION_SET_POINT; ESI the
|
||||
// frame, EDI the font string, its parent at OFF_REGION_PARENT already set
|
||||
// by SetRegionParent 0x0077FD10): the first line (BOTTOMLEFT, the frame,
|
||||
// BOTTOMLEFT, left inset, bottom inset), each next one (BOTTOMLEFT, the
|
||||
// line before, TOPLEFT, 0, FUN_PIXEL_ALIGN_Y(spacing)), then
|
||||
// FUN_LAYOUT_RESIZE(1). The layout is the only maker of lines (the array
|
||||
// grow 0x00789060 and the node constructor 0x00788D90 have no other
|
||||
// caller). OnRectChanged (0x00788310) destroys every line when the message
|
||||
// area changes size and lays them out again; Clear (0x007882B0) only hides
|
||||
// them. The insets are the four floats SetInsets (0x00787FB0) stores and
|
||||
// OnRectChanged subtracts from the rect: bottom, left, top, right.
|
||||
CALL_SMF_LAYOUT_ANCHOR_LINE = 0x00788975,
|
||||
OFF_SCROLLINGMESSAGEFRAME_INSET_BOTTOM = 0x37C,
|
||||
OFF_SCROLLINGMESSAGEFRAME_INSET_LEFT = 0x380,
|
||||
OFF_SCROLLINGMESSAGEFRAME_INSET_TOP = 0x384,
|
||||
OFF_FONTSTRING_SPACING = 0xF4, // float, the line spacing
|
||||
// PixelAlignY - `float __stdcall(float)`, `ret 4`: rounds a vertical
|
||||
// length up to whole device pixels (benilla-re ui/regions).
|
||||
FUN_PIXEL_ALIGN_Y = 0x00766750,
|
||||
|
||||
// Focused-editbox global — holds the CSimpleEditBox that currently has
|
||||
// keyboard focus (the one showing a cursor), or 0 when no input field is
|
||||
|
||||
@@ -0,0 +1,218 @@
|
||||
// This file is part of ClassicAPI.
|
||||
//
|
||||
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
||||
// of the GNU General Public License as published by the Free Software Foundation, either
|
||||
// version 3 of the License, or (at your option) any later version.
|
||||
//
|
||||
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
// PURPOSE. See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License along with
|
||||
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
// `C_DeathInfo.GetSelfResurrectOptions()`, `C_DeathInfo.UseSelfResurrectOption
|
||||
// (optionType, id)` and `SELF_RES_SPELL_CHANGED` — the self-resurrection that
|
||||
// 1.12 serves through HasSoulstone (0x0048AC80) and UseSoulstone (0x0048AD70).
|
||||
//
|
||||
// 1.12 offers at most one way for a dead player to raise themselves, and both
|
||||
// functions pick it the same way: PLAYER_SELF_RES_SPELL when the server set it
|
||||
// (Soulstone Resurrection, Reincarnation), else the first carried item whose
|
||||
// on-use spell is a self-resurrect. So the list holds that one option, under
|
||||
// HasSoulstone's gate (a living player has none), and using it calls
|
||||
// UseSoulstone itself. Nothing in 1.12 limits a self-resurrection, so every
|
||||
// option can be used and none is limited.
|
||||
//
|
||||
// SELF_RES_SPELL_CHANGED is 4.3.4's: CGPlayer_C::SetActiveMirrorHandlers
|
||||
// watches PLAYER_SELF_RES_SPELL with OnUpdatePlayerScriptEvent. 1.12 watches
|
||||
// no such field, so the same watcher joins 1.12's AddActiveWatchers and
|
||||
// leaves with its removal, the lifetime of the engine's own player watchers.
|
||||
|
||||
#include "Game.h"
|
||||
#include "Offsets.h"
|
||||
#include "event/Custom.h"
|
||||
#include "item/Link.h"
|
||||
#include "spell/Lookup.h"
|
||||
#include "unit/Identity.h"
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace Death::SelfResurrect {
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr int OPTION_TYPE_SPELL = 0;
|
||||
constexpr int OPTION_TYPE_ITEM = 1;
|
||||
|
||||
const Game::Doc::Event kChangedDoc{
|
||||
"DeathInfo",
|
||||
"The player's self-resurrection spell changed. Read C_DeathInfo.GetSelfResurrectOptions.",
|
||||
{}};
|
||||
const Event::Custom::AutoReserve kChanged{"SELF_RES_SPELL_CHANGED", &kChangedDoc};
|
||||
|
||||
struct Option {
|
||||
const char *name;
|
||||
int optionType;
|
||||
int id;
|
||||
};
|
||||
|
||||
// HasSoulstone's answer: the option, or false while the player lives or has
|
||||
// none. `itemName` holds an item option's name.
|
||||
bool CurrentOption(Option &out, char *itemName, size_t itemNameSize) {
|
||||
const uint8_t *player = Unit::Identity::PlayerObject();
|
||||
const uint8_t *desc = Unit::Identity::PlayerDescriptor();
|
||||
if (player == nullptr || desc == nullptr ||
|
||||
Game::Read<int32_t>(desc, Offsets::OFF_UNIT_FIELD_HEALTH) > 0)
|
||||
return false;
|
||||
const auto *info = Game::Read<const uint8_t *>(player, Offsets::OFF_CGPLAYER_INFO);
|
||||
const int spellID =
|
||||
info != nullptr ? Game::Read<int32_t>(info, Offsets::OFF_CGPLAYER_INFO_SELF_RES_SPELL) : 0;
|
||||
if (spellID != 0) {
|
||||
const uint8_t *rec = Spell::Lookup::RecordForID(spellID);
|
||||
out = {rec != nullptr
|
||||
? Game::Read<const char *>(rec, Offsets::OFF_SPELL_NAMES +
|
||||
Game::Read<int>(Offsets::VAR_LOCALE_INDEX) *
|
||||
4)
|
||||
: "UNKNOWN",
|
||||
OPTION_TYPE_SPELL, spellID};
|
||||
return true;
|
||||
}
|
||||
using SelfResItem_t = const uint8_t *(__fastcall *)(const void *player);
|
||||
const uint8_t *item =
|
||||
reinterpret_cast<SelfResItem_t>(Offsets::FUN_PLAYER_SELF_RES_ITEM)(player);
|
||||
if (item == nullptr)
|
||||
return false;
|
||||
Item::Link::NameFromCGItem(item, itemName, itemNameSize);
|
||||
const auto *fields = Game::Read<const uint8_t *>(item, Offsets::OFF_UNIT_GUID_PTR);
|
||||
out = {itemName, OPTION_TYPE_ITEM,
|
||||
fields != nullptr ? Game::Read<int32_t>(fields, Offsets::OFF_OBJECT_FIELD_ENTRY) : 0};
|
||||
return true;
|
||||
}
|
||||
|
||||
int __fastcall Script_GetSelfResurrectOptions(void *L) {
|
||||
if (Unit::Identity::PlayerObject() == nullptr)
|
||||
return 0;
|
||||
Game::Lua::NewTable(L);
|
||||
char itemName[0x400];
|
||||
Option option;
|
||||
if (CurrentOption(option, itemName, sizeof(itemName))) {
|
||||
Game::Lua::PushNumber(L, 1);
|
||||
Game::Lua::NewTable(L);
|
||||
Game::Lua::SetFieldString(L, "name", option.name);
|
||||
Game::Lua::SetFieldNumber(L, "optionType", option.optionType);
|
||||
Game::Lua::SetFieldNumber(L, "id", option.id);
|
||||
Game::Lua::SetFieldBool(L, "canUse", true);
|
||||
Game::Lua::SetFieldBool(L, "isLimited", false);
|
||||
Game::Lua::SetFieldNumber(L, "priority", 0);
|
||||
Game::Lua::SetTable(L, -3);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int __fastcall Script_UseSelfResurrectOption(void *L) {
|
||||
if (!Game::Lua::IsNumber(L, 1) || !Game::Lua::IsNumber(L, 2)) {
|
||||
Game::Lua::Error(L, "Usage: C_DeathInfo.UseSelfResurrectOption(optionType, id)");
|
||||
return 0;
|
||||
}
|
||||
char itemName[0x400];
|
||||
Option option;
|
||||
if (CurrentOption(option, itemName, sizeof(itemName)) &&
|
||||
option.optionType == static_cast<int>(Game::Lua::ToNumber(L, 1)) &&
|
||||
option.id == static_cast<int>(Game::Lua::ToNumber(L, 2)))
|
||||
reinterpret_cast<Game::Lua::CFunction>(Offsets::FUN_SCRIPT_USE_SOULSTONE)(L);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Observer callback ABI per the FUN_DESC_OBSERVER_REGISTER block in
|
||||
// Offsets.h: __fastcall(fieldOffset /*ecx*/, size /*edx*/, guidLo, guidHi,
|
||||
// oldValues*, userArg), returns 1, callee cleans 0x10. It runs only when the
|
||||
// field's bytes changed.
|
||||
int __fastcall SelfResSpellChanged(uint32_t /*fieldOffset*/, uint32_t /*size*/,
|
||||
uint32_t /*guidLo*/, uint32_t /*guidHi*/,
|
||||
const void * /*oldValues*/, void * /*userArg*/) {
|
||||
Event::Custom::Fire(kChanged.Slot(), "");
|
||||
return 1;
|
||||
}
|
||||
|
||||
using Register_t = void(__fastcall *)(int bank, uint32_t fieldOffset, uint32_t guidLo,
|
||||
uint32_t guidHi, int size, const void *callback,
|
||||
void *userArg1, void *userArg2);
|
||||
using Unregister_t = void(__fastcall *)(int bank, uint32_t fieldOffset, uint32_t guidLo,
|
||||
uint32_t guidHi, const void *callback, void *userArg1);
|
||||
using Watchers_t = void(__fastcall *)(void *player, void *edx);
|
||||
|
||||
Watchers_t g_origAddWatchers = nullptr;
|
||||
Watchers_t g_origRemoveWatchers = nullptr;
|
||||
|
||||
void __fastcall AddActiveWatchers_h(void *player, void *edx) {
|
||||
g_origAddWatchers(player, edx);
|
||||
const uint64_t guid = Unit::Identity::GuidForObject(player);
|
||||
reinterpret_cast<Register_t>(Offsets::FUN_DESC_OBSERVER_REGISTER)(
|
||||
Offsets::DESC_OBSERVER_BANK_PLAYER, Offsets::OFF_CGPLAYER_INFO_SELF_RES_SPELL,
|
||||
static_cast<uint32_t>(guid), static_cast<uint32_t>(guid >> 32), 4,
|
||||
reinterpret_cast<const void *>(&SelfResSpellChanged), nullptr, nullptr);
|
||||
}
|
||||
|
||||
// Removed before the original, while the registry is as the engine's own
|
||||
// removals find it.
|
||||
void __fastcall RemoveActiveWatchers_h(void *player, void *edx) {
|
||||
const uint64_t guid = Unit::Identity::GuidForObject(player);
|
||||
reinterpret_cast<Unregister_t>(Offsets::FUN_DESC_OBSERVER_UNREGISTER)(
|
||||
Offsets::DESC_OBSERVER_BANK_PLAYER, Offsets::OFF_CGPLAYER_INFO_SELF_RES_SPELL,
|
||||
static_cast<uint32_t>(guid), static_cast<uint32_t>(guid >> 32),
|
||||
reinterpret_cast<const void *>(&SelfResSpellChanged), nullptr);
|
||||
g_origRemoveWatchers(player, edx);
|
||||
}
|
||||
|
||||
const Game::HookAutoRegister _addHook{Offsets::FUN_PLAYER_ADD_ACTIVE_WATCHERS,
|
||||
reinterpret_cast<void *>(&AddActiveWatchers_h),
|
||||
reinterpret_cast<void **>(&g_origAddWatchers)};
|
||||
const Game::HookAutoRegister _removeHook{Offsets::FUN_PLAYER_REMOVE_ACTIVE_WATCHERS,
|
||||
reinterpret_cast<void *>(&RemoveActiveWatchers_h),
|
||||
reinterpret_cast<void **>(&g_origRemoveWatchers)};
|
||||
|
||||
const Game::Lua::EnumIntegerEntry kOptionTypeEntries[] = {
|
||||
{"Spell", OPTION_TYPE_SPELL},
|
||||
{"Item", OPTION_TYPE_ITEM},
|
||||
};
|
||||
|
||||
const Game::Doc::Field kOptionFields[] = {
|
||||
Game::Doc::Req("name", "string"),
|
||||
Game::Doc::Req("optionType", "SelfResurrectOptionType"),
|
||||
Game::Doc::Req("id", "number", "The spell ID or item ID."),
|
||||
Game::Doc::Req("canUse", "bool"),
|
||||
Game::Doc::Req("isLimited", "bool"),
|
||||
Game::Doc::Req("priority", "number", "Lower comes first."),
|
||||
};
|
||||
const Game::Doc::Structure kOption{"SelfResurrectOption", "DeathInfo", kOptionFields,
|
||||
"A way for the dead player to resurrect themselves."};
|
||||
|
||||
const Game::Doc::Field kGetRets[] = {
|
||||
Game::Doc::Req("options", "table", "Array of SelfResurrectOption; empty while alive."),
|
||||
};
|
||||
const Game::Doc::Function kGetSelfResurrectOptions{
|
||||
"The ways the dead player can resurrect themselves.", {}, kGetRets};
|
||||
|
||||
const Game::Doc::Field kUseArgs[] = {
|
||||
Game::Doc::Req("optionType", "SelfResurrectOptionType"),
|
||||
Game::Doc::Req("id", "number"),
|
||||
};
|
||||
const Game::Doc::Function kUseSelfResurrectOption{
|
||||
"Resurrects the dead player with one of the options from GetSelfResurrectOptions.",
|
||||
kUseArgs, {}};
|
||||
|
||||
void RegisterLuaFunctions() {
|
||||
Game::Lua::RegisterTableFunction("C_DeathInfo", "GetSelfResurrectOptions",
|
||||
&Script_GetSelfResurrectOptions, &kGetSelfResurrectOptions);
|
||||
Game::Lua::RegisterTableFunction("C_DeathInfo", "UseSelfResurrectOption",
|
||||
&Script_UseSelfResurrectOption, &kUseSelfResurrectOption);
|
||||
Game::Lua::RegisterIntegerEnum("Enum", "SelfResurrectOptionType", kOptionTypeEntries,
|
||||
sizeof(kOptionTypeEntries) / sizeof(kOptionTypeEntries[0]),
|
||||
"DeathInfo");
|
||||
}
|
||||
|
||||
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
||||
|
||||
} // namespace
|
||||
|
||||
} // namespace Death::SelfResurrect
|
||||
@@ -0,0 +1,182 @@
|
||||
// This file is part of ClassicAPI.
|
||||
//
|
||||
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
||||
// of the GNU General Public License as published by the Free Software Foundation, either
|
||||
// version 3 of the License, or (at your option) any later version.
|
||||
//
|
||||
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
// PURPOSE. See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License along with
|
||||
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
// `smf:AddOnDisplayRefreshedCallback(callback)`, retail's: callback(frame)
|
||||
// runs each time the frame refreshes what it shows.
|
||||
//
|
||||
// Retail's mixin (Blizzard_SharedXML/ScrollingMessageFrame.lua) marks its
|
||||
// display dirty on each change - a message, a scroll, a resize, a fade reset -
|
||||
// and refreshes in its OnPostUpdate. So the callbacks run once per update of
|
||||
// a shown frame that changed, in the order they were added, each under the
|
||||
// error handler (secureexecuterange). The mark is cleared after them, so a
|
||||
// change a callback makes (a scroll bar setting the offset) does not run them
|
||||
// again.
|
||||
//
|
||||
// 1.12 refreshes what the frame shows in its line layout
|
||||
// (ScrollingMessageFrame::Layout), which marks the frame. A message added
|
||||
// while the frame is scrolled up changes no line and runs no layout, but it
|
||||
// moves the scroll offset and range, so AddMessage marks the frame too, as
|
||||
// ScrollByAmount does for retail's fade reset. The callbacks run after the
|
||||
// frame's own update (FUN_SCROLLINGMESSAGEFRAME_ON_UPDATE: OnUpdate, then the
|
||||
// fader), which the engine's update pass calls once per frame for each shown
|
||||
// frame - where retail's OnPostUpdate runs.
|
||||
|
||||
#include "scrollingmessageframe/DisplayRefreshed.h"
|
||||
|
||||
#include "Game.h"
|
||||
#include "Offsets.h"
|
||||
#include "scrollingmessageframe/Layout.h"
|
||||
|
||||
#include <unordered_map>
|
||||
|
||||
namespace ScrollingMessageFrame::DisplayRefreshed {
|
||||
|
||||
namespace {
|
||||
|
||||
// Frames with callbacks, and whether each has a refresh pending. Every frame
|
||||
// is rebuilt on /reload, so the map is cleared then.
|
||||
std::unordered_map<void *, bool> g_frames;
|
||||
|
||||
// The frame-table → callback-list table, in the registry of the Lua state
|
||||
// that made it. LUA_NOREF until first use in each state.
|
||||
constexpr int kNoRef = -2;
|
||||
int g_callbacksRef = kNoRef;
|
||||
|
||||
// Runs the callbacks of the frame, each as callback(frame) under the
|
||||
// engine's script error handler.
|
||||
void RunCallbacks(void *smf) {
|
||||
using namespace Game::Lua;
|
||||
void *L = State();
|
||||
if (L == nullptr || g_callbacksRef == kNoRef)
|
||||
return;
|
||||
const int top = GetTop(L);
|
||||
PushObject(L, smf);
|
||||
const int frame = GetTop(L);
|
||||
RawGetI(L, REGISTRY_INDEX, g_callbacksRef);
|
||||
PushValue(L, frame);
|
||||
RawGet(L, -2);
|
||||
const int callbacks = GetTop(L);
|
||||
if (Type(L, callbacks) == TYPE_TABLE) {
|
||||
const int errRef = Game::Read<int>(static_cast<uintptr_t>(Offsets::VAR_FRAMESCRIPT_ERROR_HANDLER_REF));
|
||||
for (int i = 1;; ++i) {
|
||||
int errIdx = 0;
|
||||
if (errRef > 0) {
|
||||
RawGetI(L, REGISTRY_INDEX, errRef);
|
||||
errIdx = GetTop(L);
|
||||
}
|
||||
RawGetI(L, callbacks, i);
|
||||
if (Type(L, -1) == TYPE_NIL)
|
||||
break;
|
||||
PushValue(L, frame);
|
||||
PCall(L, 1, 0, errIdx);
|
||||
SetTop(L, callbacks);
|
||||
}
|
||||
}
|
||||
SetTop(L, top);
|
||||
}
|
||||
|
||||
using OnUpdate_t = void(__fastcall *)(void *smf, void *edx, float elapsed);
|
||||
OnUpdate_t g_origOnUpdate = nullptr;
|
||||
|
||||
void __fastcall OnUpdate_h(void *smf, void *edx, float elapsed) {
|
||||
g_origOnUpdate(smf, edx, elapsed);
|
||||
const auto it = g_frames.find(smf);
|
||||
if (it == g_frames.end() || !it->second)
|
||||
return;
|
||||
RunCallbacks(smf);
|
||||
const auto again = g_frames.find(smf); // a callback can add frames
|
||||
if (again != g_frames.end())
|
||||
again->second = false;
|
||||
}
|
||||
|
||||
const Game::HookAutoRegister _updateHook{Offsets::FUN_SCROLLINGMESSAGEFRAME_ON_UPDATE,
|
||||
reinterpret_cast<void *>(&OnUpdate_h),
|
||||
reinterpret_cast<void **>(&g_origOnUpdate)};
|
||||
|
||||
const ScrollingMessageFrame::Layout::AutoSubscribe _layoutSub{&MarkDirty};
|
||||
|
||||
int __fastcall Script_AddOnDisplayRefreshedCallback(void *L) {
|
||||
using namespace Game::Lua;
|
||||
void *frame = ResolveTypedObject(L, 1, Offsets::VAR_SCROLLINGMESSAGEFRAME_LUA_TYPE_ID);
|
||||
if (frame == nullptr)
|
||||
return 0;
|
||||
if (Type(L, 2) != TYPE_FUNCTION) {
|
||||
Error(L, "Usage: %s:AddOnDisplayRefreshedCallback(callback)", ObjectDisplayName(frame));
|
||||
return 0;
|
||||
}
|
||||
if (g_callbacksRef == kNoRef) {
|
||||
NewTable(L);
|
||||
g_callbacksRef = Ref(L, REGISTRY_INDEX);
|
||||
}
|
||||
RawGetI(L, REGISTRY_INDEX, g_callbacksRef);
|
||||
const int frames = GetTop(L);
|
||||
PushValue(L, 1);
|
||||
RawGet(L, frames);
|
||||
if (Type(L, -1) != TYPE_TABLE) {
|
||||
SetTop(L, frames);
|
||||
NewTable(L);
|
||||
PushValue(L, 1);
|
||||
PushValue(L, -2);
|
||||
RawSet(L, frames); // frames[self] = callbacks
|
||||
}
|
||||
const int callbacks = GetTop(L);
|
||||
int n = 1;
|
||||
for (;; ++n) {
|
||||
RawGetI(L, callbacks, n);
|
||||
const bool end = Type(L, -1) == TYPE_NIL;
|
||||
SetTop(L, -2);
|
||||
if (end)
|
||||
break;
|
||||
}
|
||||
PushNumber(L, n);
|
||||
PushValue(L, 2);
|
||||
RawSet(L, callbacks);
|
||||
g_frames.emplace(frame, false);
|
||||
return 0;
|
||||
}
|
||||
|
||||
const Game::Lua::FrameMethodEntry kMethods[] = {
|
||||
{"AddOnDisplayRefreshedCallback", &Script_AddOnDisplayRefreshedCallback},
|
||||
};
|
||||
|
||||
const Game::Doc::Field kArgs[] = {
|
||||
Game::Doc::Req("callback", "function", "Called as callback(frame)."),
|
||||
};
|
||||
const Game::Doc::Function kAddOnDisplayRefreshedCallback{
|
||||
"Adds a function that runs after the frame refreshes the messages it shows.", kArgs, {}};
|
||||
|
||||
const Game::Doc::Method kDocs[] = {
|
||||
{"AddOnDisplayRefreshedCallback", &kAddOnDisplayRefreshedCallback},
|
||||
};
|
||||
|
||||
void RegisterLuaFunctions() {
|
||||
// Each registration pass is a new Lua state; the old state's ref is gone.
|
||||
g_callbacksRef = kNoRef;
|
||||
Game::Lua::RegisterFrameMethods(reinterpret_cast<void *>(Offsets::VAR_SCROLLINGMESSAGEFRAME_METHOD_REGISTRY),
|
||||
kMethods, 1, kDocs, 1);
|
||||
}
|
||||
|
||||
void PrepareForReload() { g_frames.clear(); }
|
||||
|
||||
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
||||
const Game::ReloadAutoRegister _reload{&PrepareForReload};
|
||||
|
||||
} // namespace
|
||||
|
||||
void MarkDirty(void *smf) {
|
||||
const auto it = g_frames.find(smf);
|
||||
if (it != g_frames.end())
|
||||
it->second = true;
|
||||
}
|
||||
|
||||
} // namespace ScrollingMessageFrame::DisplayRefreshed
|
||||
@@ -0,0 +1,22 @@
|
||||
// This file is part of ClassicAPI.
|
||||
//
|
||||
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
||||
// of the GNU General Public License as published by the Free Software Foundation, either
|
||||
// version 3 of the License, or (at your option) any later version.
|
||||
//
|
||||
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
// PURPOSE. See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License along with
|
||||
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#pragma once
|
||||
|
||||
namespace ScrollingMessageFrame::DisplayRefreshed {
|
||||
|
||||
// Marks a change to what the frame shows that its line layout does not
|
||||
// report; the frame's display-refreshed callbacks run at its next update.
|
||||
void MarkDirty(void *smf);
|
||||
|
||||
} // namespace ScrollingMessageFrame::DisplayRefreshed
|
||||
@@ -0,0 +1,194 @@
|
||||
// This file is part of ClassicAPI.
|
||||
//
|
||||
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
||||
// of the GNU General Public License as published by the Free Software Foundation, either
|
||||
// version 3 of the License, or (at your option) any later version.
|
||||
//
|
||||
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
// PURPOSE. See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License along with
|
||||
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
// Retail's insert mode on ScrollingMessageFrame: `SetInsertMode(mode)`,
|
||||
// `GetInsertMode()` and the SCROLLING_MESSAGE_FRAME_INSERT_MODE_* globals.
|
||||
//
|
||||
// Retail's mixin (Blizzard_SharedXML/ScrollingMessageFrame.lua, RefreshLayout)
|
||||
// stacks the lines up from the bottom in BOTTOM mode, the newest message at
|
||||
// the bottom, and down from the top in TOP mode: the first line's TOPLEFT on
|
||||
// the frame's TOPLEFT, each next line's TOPLEFT on the BOTTOMLEFT of the line
|
||||
// before, the spacing below it. The scroll offset counts from the newest
|
||||
// message in both modes. Setting the mode the frame has does nothing; a change
|
||||
// lays every line out again and refreshes the display.
|
||||
//
|
||||
// 1.12's line layout is retail's BOTTOM mode. It anchors a line once, when it
|
||||
// makes the line, through one SetPoint call (Offsets.h,
|
||||
// CALL_SMF_LAYOUT_ANCHOR_LINE), so that call is redirected: a line of a frame
|
||||
// in TOP mode takes the TOP anchors, every other line the engine's own. The
|
||||
// layout makes the lines again when the frame changes size, which the
|
||||
// redirect covers too. When a frame's mode changes, its lines are anchored
|
||||
// again in order with the layout's own steps: clear the points, set the
|
||||
// point, lay the line out now. The hyperlink buttons and inline textures are
|
||||
// anchored to the lines, so they move with them. Retail's frame has no text
|
||||
// insets; the TOP mode's first line sits the top inset below the frame's top,
|
||||
// as the BOTTOM mode's sits the bottom inset above its bottom.
|
||||
|
||||
#include "Common.h"
|
||||
#include "Game.h"
|
||||
#include "Offsets.h"
|
||||
#include "frame/Destruction.h"
|
||||
#include "scrollingmessageframe/DisplayRefreshed.h"
|
||||
|
||||
#include <cstdint>
|
||||
#include <unordered_set>
|
||||
|
||||
namespace ScrollingMessageFrame::InsertMode {
|
||||
|
||||
namespace {
|
||||
|
||||
// SCROLLING_MESSAGE_FRAME_INSERT_MODE_TOP / _BOTTOM.
|
||||
constexpr int kInsertModeTop = 1;
|
||||
constexpr int kInsertModeBottom = 2;
|
||||
|
||||
using SetPoint_t = void(__thiscall *)(void *anchor, int point, void *relAnchor, int relPoint, float x, float y,
|
||||
int flag);
|
||||
using ClearAllPoints_t = void(__fastcall *)(void *anchor);
|
||||
using Resize_t = void(__fastcall *)(void *anchor, void *edx, int force);
|
||||
using PixelAlignY_t = float(__stdcall *)(float length);
|
||||
|
||||
// The frames in TOP mode. Every frame is rebuilt on /reload, so the set is
|
||||
// cleared then.
|
||||
std::unordered_set<void *> g_topFrames;
|
||||
|
||||
bool IsTop(void *smf) { return g_topFrames.count(smf) != 0; }
|
||||
|
||||
void *AnchorOf(void *region) { return static_cast<uint8_t *>(region) + Offsets::OFF_REGION_ANCHOR; }
|
||||
|
||||
// Sets a line's anchor as the layout gives it - (BOTTOMLEFT, the frame,
|
||||
// BOTTOMLEFT, x, y) for the first line, (BOTTOMLEFT, the line before, TOPLEFT,
|
||||
// x, y) for the others - or, for a frame in TOP mode, its mirror.
|
||||
void SetLinePoint(void *smf, void *anchor, int point, void *relative, int relativePoint, float x, float y,
|
||||
int flag) {
|
||||
if (IsTop(smf)) {
|
||||
point = Offsets::FRAMEPOINT_TOPLEFT;
|
||||
if (relativePoint == Offsets::FRAMEPOINT_BOTTOMLEFT) { // the first line, on the frame
|
||||
relativePoint = Offsets::FRAMEPOINT_TOPLEFT;
|
||||
y = -Game::Read<float>(smf, Offsets::OFF_SCROLLINGMESSAGEFRAME_INSET_TOP);
|
||||
} else {
|
||||
relativePoint = Offsets::FRAMEPOINT_BOTTOMLEFT;
|
||||
y = -y;
|
||||
}
|
||||
}
|
||||
reinterpret_cast<SetPoint_t>(Offsets::FUN_REGION_SET_POINT)(anchor, point, relative, relativePoint, x, y, flag);
|
||||
}
|
||||
|
||||
// The layout's SetPoint for a line it has just made; the line's parent is
|
||||
// the frame.
|
||||
void __fastcall AnchorNewLine(void *anchor, void *, int point, void *relative, int relativePoint, float x, float y,
|
||||
int flag) {
|
||||
void *line = static_cast<uint8_t *>(anchor) - Offsets::OFF_REGION_ANCHOR;
|
||||
SetLinePoint(Game::Read<void *>(line, Offsets::OFF_REGION_PARENT), anchor, point, relative, relativePoint, x, y,
|
||||
flag);
|
||||
}
|
||||
|
||||
// Anchors the frame's lines again, in order, with the layout's arguments and
|
||||
// steps.
|
||||
void AnchorLines(void *smf) {
|
||||
const int count = Game::Read<int>(smf, Offsets::OFF_SMF_LINE_COUNT);
|
||||
const auto *lines = Game::Read<const uint8_t *>(smf, Offsets::OFF_SMF_LINE_ARRAY);
|
||||
void *previous = nullptr;
|
||||
for (int i = 0; i < count; ++i) {
|
||||
void *line = Game::Read<void *>(lines + i * Offsets::SMF_LINE_STRIDE, Offsets::OFF_SMF_LINE_FONTSTRING);
|
||||
void *anchor = AnchorOf(line);
|
||||
reinterpret_cast<ClearAllPoints_t>(Offsets::FUN_LAYOUT_CLEAR_ALL_POINTS)(anchor);
|
||||
if (previous == nullptr)
|
||||
SetLinePoint(smf, anchor, Offsets::FRAMEPOINT_BOTTOMLEFT, AnchorOf(smf), Offsets::FRAMEPOINT_BOTTOMLEFT,
|
||||
Game::Read<float>(smf, Offsets::OFF_SCROLLINGMESSAGEFRAME_INSET_LEFT),
|
||||
Game::Read<float>(smf, Offsets::OFF_SCROLLINGMESSAGEFRAME_INSET_BOTTOM), 1);
|
||||
else
|
||||
SetLinePoint(smf, anchor, Offsets::FRAMEPOINT_BOTTOMLEFT, AnchorOf(previous), Offsets::FRAMEPOINT_TOPLEFT,
|
||||
0.0f,
|
||||
reinterpret_cast<PixelAlignY_t>(Offsets::FUN_PIXEL_ALIGN_Y)(
|
||||
Game::Read<float>(line, Offsets::OFF_FONTSTRING_SPACING)),
|
||||
1);
|
||||
reinterpret_cast<Resize_t>(Offsets::FUN_LAYOUT_RESIZE)(anchor, nullptr, 1);
|
||||
previous = line;
|
||||
}
|
||||
}
|
||||
|
||||
int __fastcall Script_SetInsertMode(void *L) {
|
||||
void *frame = Game::Lua::ResolveTypedObject(L, 1, Offsets::VAR_SCROLLINGMESSAGEFRAME_LUA_TYPE_ID);
|
||||
if (frame == nullptr)
|
||||
return 0;
|
||||
const double mode = Game::Lua::IsNumber(L, 2) ? Game::Lua::ToNumber(L, 2) : 0;
|
||||
if (mode != kInsertModeTop && mode != kInsertModeBottom) {
|
||||
Game::Lua::Error(L,
|
||||
"Usage: %s:SetInsertMode(SCROLLING_MESSAGE_FRAME_INSERT_MODE_TOP or "
|
||||
"SCROLLING_MESSAGE_FRAME_INSERT_MODE_BOTTOM)",
|
||||
Game::Lua::ObjectDisplayName(frame));
|
||||
return 0;
|
||||
}
|
||||
const bool top = mode == kInsertModeTop;
|
||||
if (top == IsTop(frame))
|
||||
return 0;
|
||||
if (top)
|
||||
g_topFrames.insert(frame);
|
||||
else
|
||||
g_topFrames.erase(frame);
|
||||
AnchorLines(frame);
|
||||
DisplayRefreshed::MarkDirty(frame);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __fastcall Script_GetInsertMode(void *L) {
|
||||
void *frame = Game::Lua::ResolveTypedObject(L, 1, Offsets::VAR_SCROLLINGMESSAGEFRAME_LUA_TYPE_ID);
|
||||
if (frame == nullptr)
|
||||
return 0;
|
||||
Game::Lua::PushNumber(L, IsTop(frame) ? kInsertModeTop : kInsertModeBottom);
|
||||
return 1;
|
||||
}
|
||||
|
||||
const Game::Lua::FrameMethodEntry kMethods[] = {
|
||||
{"SetInsertMode", &Script_SetInsertMode},
|
||||
{"GetInsertMode", &Script_GetInsertMode},
|
||||
};
|
||||
|
||||
const Game::Doc::Field kModeArgs[] = {
|
||||
Game::Doc::Req("mode", "number",
|
||||
"SCROLLING_MESSAGE_FRAME_INSERT_MODE_TOP or SCROLLING_MESSAGE_FRAME_INSERT_MODE_BOTTOM."),
|
||||
};
|
||||
const Game::Doc::Field kModeRets[] = {
|
||||
Game::Doc::Req("mode", "number", "BOTTOM until SetInsertMode changes it."),
|
||||
};
|
||||
const Game::Doc::Function kSetInsertMode{
|
||||
"Sets where the newest message shows: at the top, with older messages below it, or at the bottom.", kModeArgs,
|
||||
{}};
|
||||
const Game::Doc::Function kGetInsertMode{"Returns where the newest message shows.", {}, kModeRets};
|
||||
|
||||
const Game::Doc::Method kDocs[] = {
|
||||
{"SetInsertMode", &kSetInsertMode},
|
||||
{"GetInsertMode", &kGetInsertMode},
|
||||
};
|
||||
|
||||
void RegisterLuaFunctions() {
|
||||
void *L = Game::Lua::State();
|
||||
Game::Lua::SetGlobalNumber(L, "SCROLLING_MESSAGE_FRAME_INSERT_MODE_TOP", kInsertModeTop);
|
||||
Game::Lua::SetGlobalNumber(L, "SCROLLING_MESSAGE_FRAME_INSERT_MODE_BOTTOM", kInsertModeBottom);
|
||||
Game::Lua::RegisterFrameMethods(reinterpret_cast<void *>(Offsets::VAR_SCROLLINGMESSAGEFRAME_METHOD_REGISTRY),
|
||||
kMethods, 2, kDocs, 2);
|
||||
Common::RedirectCall(Offsets::CALL_SMF_LAYOUT_ANCHOR_LINE, Offsets::FUN_REGION_SET_POINT,
|
||||
reinterpret_cast<const void *>(&AnchorNewLine));
|
||||
}
|
||||
|
||||
void PrepareForReload() { g_topFrames.clear(); }
|
||||
|
||||
void OnFrameDestroyed(void *frame) { g_topFrames.erase(frame); }
|
||||
|
||||
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
||||
const Game::ReloadAutoRegister _reload{&PrepareForReload};
|
||||
const Frame::Destruction::AutoSubscribe _destructionSub{&OnFrameDestroyed};
|
||||
|
||||
} // namespace
|
||||
|
||||
} // namespace ScrollingMessageFrame::InsertMode
|
||||
@@ -0,0 +1,41 @@
|
||||
// This file is part of ClassicAPI.
|
||||
//
|
||||
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
||||
// of the GNU General Public License as published by the Free Software Foundation, either
|
||||
// version 3 of the License, or (at your option) any later version.
|
||||
//
|
||||
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
// PURPOSE. See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License along with
|
||||
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#include "scrollingmessageframe/Layout.h"
|
||||
|
||||
#include "Game.h"
|
||||
#include "Offsets.h"
|
||||
|
||||
namespace ScrollingMessageFrame::Layout {
|
||||
|
||||
namespace {
|
||||
|
||||
AutoSubscribe *g_head = nullptr;
|
||||
|
||||
using Layout_t = void(__fastcall *)(void *smf, void *edx, int newestRecord);
|
||||
Layout_t g_origLayout = nullptr;
|
||||
|
||||
void __fastcall Layout_h(void *smf, void *edx, int newestRecord) {
|
||||
g_origLayout(smf, edx, newestRecord);
|
||||
for (const AutoSubscribe *s = g_head; s != nullptr; s = s->next)
|
||||
s->fn(smf);
|
||||
}
|
||||
|
||||
const Game::HookAutoRegister _hook{Offsets::FUN_SMF_DISPLAY_REFRESH, reinterpret_cast<void *>(&Layout_h),
|
||||
reinterpret_cast<void **>(&g_origLayout)};
|
||||
|
||||
} // namespace
|
||||
|
||||
AutoSubscribe::AutoSubscribe(Listener fn) : fn(fn), next(g_head) { g_head = this; }
|
||||
|
||||
} // namespace ScrollingMessageFrame::Layout
|
||||
@@ -0,0 +1,35 @@
|
||||
// This file is part of ClassicAPI.
|
||||
//
|
||||
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
||||
// of the GNU General Public License as published by the Free Software Foundation, either
|
||||
// version 3 of the License, or (at your option) any later version.
|
||||
//
|
||||
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
// PURPOSE. See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License along with
|
||||
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
#pragma once
|
||||
|
||||
// Shared observer for the ScrollingMessageFrame line layout
|
||||
// FUN_SMF_DISPLAY_REFRESH (Offsets.h), which lays out the lines the frame
|
||||
// shows after every change to them: a message added at the bottom, a scroll,
|
||||
// a resize, a font change, Clear. A listener runs after it, with the frame.
|
||||
//
|
||||
// MinHook allows ONE hook per address and more than one feature follows the
|
||||
// layout (Text::InlineTexture's early icon apply, the display-refreshed
|
||||
// callbacks), so this module owns the hook and fans out. Declare a file-scope
|
||||
// static const ScrollingMessageFrame::Layout::AutoSubscribe _sub{&OnLayout};
|
||||
namespace ScrollingMessageFrame::Layout {
|
||||
|
||||
using Listener = void (*)(void *smf);
|
||||
|
||||
struct AutoSubscribe {
|
||||
explicit AutoSubscribe(Listener fn);
|
||||
Listener fn;
|
||||
AutoSubscribe *next;
|
||||
};
|
||||
|
||||
} // namespace ScrollingMessageFrame::Layout
|
||||
@@ -0,0 +1,229 @@
|
||||
// This file is part of ClassicAPI.
|
||||
//
|
||||
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
||||
// of the GNU General Public License as published by the Free Software Foundation, either
|
||||
// version 3 of the License, or (at your option) any later version.
|
||||
//
|
||||
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
// PURPOSE. See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License along with
|
||||
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
// `ScrollingMessageFrame:GetMessageInfo(index)`, retail's: the message's
|
||||
// text, its colour, then every argument AddMessage took after the colour.
|
||||
//
|
||||
// Retail's ScrollingMessageFrame is a Lua mixin whose AddMessage(message, r,
|
||||
// g, b, ...) packs the call into an entry and GetMessageInfo unpacks it
|
||||
// (Blizzard_SharedXML/ScrollingMessageFrame.lua). Index 1 is the oldest
|
||||
// message; the extra arguments come back as given, nils and count included;
|
||||
// an index outside 1..GetNumMessages() returns nothing. (4.3.4's C method
|
||||
// returns text, accessID, typeID, extraData instead.)
|
||||
//
|
||||
// The text and colour come from the engine's own record of the message
|
||||
// (Offsets.h, OFF_SCROLLINGMESSAGEFRAME_MESSAGES), so a colour
|
||||
// UpdateColorByID changed reads back changed, as retail's AdjustMessageColors
|
||||
// does. The record keeps the colour as bytes, so a component reads back as
|
||||
// byte/255. It keeps the first extra argument only as an integer (0 for
|
||||
// anything else), so the extra arguments are kept beside the ring instead.
|
||||
//
|
||||
// AddMessage is registered again on the ScrollingMessageFrame registry, over
|
||||
// the engine's. The registrar (0x00701D80) adds a node for the name whatever
|
||||
// is there; Storm's TSHashTable::InternalNew links a new node at the head of
|
||||
// its bucket (NewNode(1)), and the method lookup (0x00702000) returns the
|
||||
// first match, so this one answers. It runs the engine's AddMessage, then
|
||||
// records the extra arguments for the record the engine wrote. The engine
|
||||
// adds a message exactly when the text is a nonempty string
|
||||
// (0x0079299C..0x007929C7: lua_isstring, lua_tostring, first byte); a bad
|
||||
// `self` raises a Lua error instead. The ring's one writer has no other
|
||||
// caller, so every record was written through here.
|
||||
//
|
||||
// The extra arguments live in a registry table keyed by the frame's Lua table,
|
||||
// then by record. A record's table is refilled when the record is overwritten,
|
||||
// so a full ring makes no garbage.
|
||||
|
||||
#include "Game.h"
|
||||
#include "Offsets.h"
|
||||
#include "scrollingmessageframe/DisplayRefreshed.h"
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace ScrollingMessageFrame::MessageInfo {
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr int kFirstExtra = 6; // self, text, r, g, b, then the extra arguments
|
||||
|
||||
// The frame-table → record → extra-arguments table, in the registry of the Lua
|
||||
// state that made it. LUA_NOREF until first use in each state.
|
||||
constexpr int kNoRef = -2;
|
||||
int g_extrasRef = kNoRef;
|
||||
|
||||
// Pushes the extra-argument table of record `record` of the frame whose Lua
|
||||
// table is at stack slot 1, or nil when it has none and `create` is false.
|
||||
void PushExtras(void *L, int record, bool create) {
|
||||
using namespace Game::Lua;
|
||||
if (g_extrasRef == kNoRef) {
|
||||
if (!create) {
|
||||
PushNil(L);
|
||||
return;
|
||||
}
|
||||
NewTable(L);
|
||||
g_extrasRef = Ref(L, REGISTRY_INDEX);
|
||||
}
|
||||
RawGetI(L, REGISTRY_INDEX, g_extrasRef); // [frames]
|
||||
PushValue(L, 1);
|
||||
RawGet(L, -2); // [frames, records]
|
||||
if (Type(L, -1) != TYPE_TABLE && create) {
|
||||
SetTop(L, -2);
|
||||
NewTable(L);
|
||||
PushValue(L, 1);
|
||||
PushValue(L, -2);
|
||||
RawSet(L, -4); // frames[self] = records
|
||||
}
|
||||
Remove(L, -2); // [records]
|
||||
if (Type(L, -1) != TYPE_TABLE)
|
||||
return;
|
||||
RawGetI(L, -1, record); // [records, extras]
|
||||
if (Type(L, -1) != TYPE_TABLE && create) {
|
||||
SetTop(L, -2);
|
||||
NewTable(L);
|
||||
PushNumber(L, record);
|
||||
PushValue(L, -2);
|
||||
RawSet(L, -4); // records[record] = extras
|
||||
}
|
||||
Remove(L, -2); // [extras]
|
||||
}
|
||||
|
||||
// The `n` of the extra-argument table at absolute stack slot `extras`.
|
||||
int ExtraCount(void *L, int extras) {
|
||||
using namespace Game::Lua;
|
||||
PushString(L, "n");
|
||||
RawGet(L, extras);
|
||||
const int n = static_cast<int>(ToNumber(L, -1));
|
||||
SetTop(L, -2);
|
||||
return n;
|
||||
}
|
||||
|
||||
// Stores stack slots kFirstExtra..top as the extra arguments of `record`.
|
||||
void StoreExtras(void *L, int record, int top) {
|
||||
using namespace Game::Lua;
|
||||
const int count = top >= kFirstExtra ? top - kFirstExtra + 1 : 0;
|
||||
PushExtras(L, record, count > 0);
|
||||
const int extras = GetTop(L);
|
||||
if (Type(L, extras) == TYPE_TABLE) {
|
||||
const int was = ExtraCount(L, extras);
|
||||
for (int i = 1; i <= count; ++i) {
|
||||
PushNumber(L, i);
|
||||
PushValue(L, kFirstExtra - 1 + i);
|
||||
RawSet(L, extras);
|
||||
}
|
||||
for (int i = count + 1; i <= was; ++i) {
|
||||
PushNumber(L, i);
|
||||
PushNil(L);
|
||||
RawSet(L, extras);
|
||||
}
|
||||
PushString(L, "n");
|
||||
PushNumber(L, count);
|
||||
RawSet(L, extras);
|
||||
}
|
||||
SetTop(L, -2);
|
||||
}
|
||||
|
||||
int __fastcall Script_AddMessage(void *L) {
|
||||
const int top = Game::Lua::GetTop(L);
|
||||
reinterpret_cast<Game::Lua::CFunction>(Offsets::FUN_SCRIPT_SCROLLINGMESSAGEFRAME_ADD_MESSAGE)(L);
|
||||
const char *text = Game::Lua::IsString(L, 2) ? Game::Lua::ToString(L, 2) : nullptr;
|
||||
if (text == nullptr || *text == '\0')
|
||||
return 0;
|
||||
void *frame = Game::Lua::ResolveTypedObject(L, 1, Offsets::VAR_SCROLLINGMESSAGEFRAME_LUA_TYPE_ID);
|
||||
if (frame == nullptr)
|
||||
return 0;
|
||||
StoreExtras(L, Game::Read<int>(frame, Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_POS), top);
|
||||
// Scrolled up, the engine adds the message without a layout.
|
||||
DisplayRefreshed::MarkDirty(frame);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __fastcall Script_GetMessageInfo(void *L) {
|
||||
using namespace Game::Lua;
|
||||
void *frame = ResolveTypedObject(L, 1, Offsets::VAR_SCROLLINGMESSAGEFRAME_LUA_TYPE_ID);
|
||||
if (frame == nullptr)
|
||||
return 0;
|
||||
if (!IsNumber(L, 2)) {
|
||||
Error(L, "Usage: %s:GetMessageInfo(index)", ObjectDisplayName(frame));
|
||||
return 0;
|
||||
}
|
||||
const double index = ToNumber(L, 2);
|
||||
const int count = Game::Read<int>(frame, Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_COUNT);
|
||||
if (!(index >= 1 && index <= count) || index != static_cast<int>(index))
|
||||
return 0;
|
||||
int record = Game::Read<int>(frame, Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_POS) - count +
|
||||
static_cast<int>(index);
|
||||
if (record < 0)
|
||||
record += Game::Read<int>(frame, Offsets::OFF_SCROLLINGMESSAGEFRAME_MAX_MESSAGES);
|
||||
const auto *message = Game::Read<const uint8_t *>(frame, Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGES) +
|
||||
record * Offsets::SCROLLINGMESSAGEFRAME_MESSAGE_STRIDE;
|
||||
const uint32_t color = Game::Read<uint32_t>(message, Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_COLOR);
|
||||
|
||||
PushExtras(L, record, false);
|
||||
const int extras = GetTop(L);
|
||||
const int n = Type(L, extras) == TYPE_TABLE ? ExtraCount(L, extras) : 0;
|
||||
CheckStack(L, 4 + n);
|
||||
PushString(L, Game::Read<const char *>(message, Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_TEXT));
|
||||
PushNumber(L, ((color >> 16) & 0xFF) / 255.0);
|
||||
PushNumber(L, ((color >> 8) & 0xFF) / 255.0);
|
||||
PushNumber(L, (color & 0xFF) / 255.0);
|
||||
for (int i = 1; i <= n; ++i)
|
||||
RawGetI(L, extras, i);
|
||||
Remove(L, extras);
|
||||
return 4 + n;
|
||||
}
|
||||
|
||||
const Game::Lua::FrameMethodEntry kMethods[] = {
|
||||
{"AddMessage", &Script_AddMessage},
|
||||
{"GetMessageInfo", &Script_GetMessageInfo},
|
||||
};
|
||||
|
||||
const Game::Doc::Field kAddMessageArgs[] = {
|
||||
Game::Doc::Req("text", "string"),
|
||||
Game::Doc::Opt("r", "number", nullptr, "Without r, g and b the message takes the frame's font colour."),
|
||||
Game::Doc::Opt("g", "number"),
|
||||
Game::Doc::Opt("b", "number"),
|
||||
Game::Doc::Vararg("any", "Kept with the message; GetMessageInfo returns them after its colour."),
|
||||
};
|
||||
const Game::Doc::Function kAddMessage{"Adds a message to the frame.", kAddMessageArgs, {}};
|
||||
|
||||
const Game::Doc::Field kGetMessageInfoArgs[] = {
|
||||
Game::Doc::Req("index", "luaIndex", "1 is the oldest message."),
|
||||
};
|
||||
const Game::Doc::Field kGetMessageInfoRets[] = {
|
||||
Game::Doc::Req("text", "string"),
|
||||
Game::Doc::Req("r", "number"),
|
||||
Game::Doc::Req("g", "number"),
|
||||
Game::Doc::Req("b", "number"),
|
||||
Game::Doc::Vararg("any", "The arguments AddMessage took after the colour."),
|
||||
};
|
||||
const Game::Doc::Function kGetMessageInfo{
|
||||
"Returns a message's text, its colour, and the extra arguments it was added with, or nothing "
|
||||
"when there is no message at that index.",
|
||||
kGetMessageInfoArgs, kGetMessageInfoRets};
|
||||
|
||||
const Game::Doc::Method kDocs[] = {
|
||||
{"AddMessage", &kAddMessage},
|
||||
{"GetMessageInfo", &kGetMessageInfo},
|
||||
};
|
||||
|
||||
void RegisterLuaFunctions() {
|
||||
// Each registration pass is a new Lua state; the old state's ref is gone.
|
||||
g_extrasRef = kNoRef;
|
||||
Game::Lua::RegisterFrameMethods(reinterpret_cast<void *>(Offsets::VAR_SCROLLINGMESSAGEFRAME_METHOD_REGISTRY),
|
||||
kMethods, 2, kDocs, 2);
|
||||
}
|
||||
|
||||
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
||||
|
||||
} // namespace
|
||||
|
||||
} // namespace ScrollingMessageFrame::MessageInfo
|
||||
@@ -0,0 +1,142 @@
|
||||
// This file is part of ClassicAPI.
|
||||
//
|
||||
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
||||
// of the GNU General Public License as published by the Free Software Foundation, either
|
||||
// version 3 of the License, or (at your option) any later version.
|
||||
//
|
||||
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
// PURPOSE. See the GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License along with
|
||||
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
// Retail's scroll offset on ScrollingMessageFrame: `SetScrollOffset(offset)`,
|
||||
// `GetScrollOffset()`, `GetMaxScrollRange()` and `ScrollByAmount(amount)`.
|
||||
//
|
||||
// Retail's offset (Blizzard_SharedXML/ScrollingMessageFrame.lua) counts the
|
||||
// lines the frame is scrolled up from the newest message, 0 at the bottom, up
|
||||
// to GetMaxScrollRange() = max(GetNumMessages() - 1, 0), where the oldest
|
||||
// message is the bottom line - the place 1.12's own ScrollToTop goes. 1.12
|
||||
// keeps the same offset: ScrollToOffset and ScrollOffset (Offsets.h) are its
|
||||
// two directions, and GetScrollOffset is the engine's GetCurrentScroll under
|
||||
// retail's name. Retail clamps the offset to its range; the engine wraps one
|
||||
// outside it, so the setters clamp first. SetScrollOffset to the offset the
|
||||
// frame has does nothing, as on retail. ScrollByAmount always calls the
|
||||
// engine, which re-arms the shown lines' fade when the offset stays: retail's
|
||||
// ResetAllFadeTimes.
|
||||
|
||||
#include "Game.h"
|
||||
#include "Offsets.h"
|
||||
#include "scrollingmessageframe/DisplayRefreshed.h"
|
||||
|
||||
namespace ScrollingMessageFrame::Scroll {
|
||||
|
||||
namespace {
|
||||
|
||||
using ScrollToOffset_t = void(__fastcall *)(void *smf, void *edx, int offset);
|
||||
using ScrollOffset_t = int(__fastcall *)(void *smf);
|
||||
|
||||
int ScrollOffset(void *smf) {
|
||||
return reinterpret_cast<ScrollOffset_t>(Offsets::FUN_SCROLLINGMESSAGEFRAME_SCROLL_OFFSET)(smf);
|
||||
}
|
||||
|
||||
int MaxScrollRange(void *smf) {
|
||||
const int count = Game::Read<int>(smf, Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_COUNT);
|
||||
return count > 1 ? count - 1 : 0;
|
||||
}
|
||||
|
||||
// `offset` clamped to 0..MaxScrollRange (NaN to 0).
|
||||
int Clamped(void *smf, double offset) {
|
||||
const int max = MaxScrollRange(smf);
|
||||
return offset >= 0 ? (offset < max ? static_cast<int>(offset) : max) : 0;
|
||||
}
|
||||
|
||||
void ScrollTo(void *smf, int offset) {
|
||||
reinterpret_cast<ScrollToOffset_t>(Offsets::FUN_SCROLLINGMESSAGEFRAME_SCROLL_TO_OFFSET)(smf, nullptr, offset);
|
||||
}
|
||||
|
||||
void *ResolveSmf(void *L) {
|
||||
return Game::Lua::ResolveTypedObject(L, 1, Offsets::VAR_SCROLLINGMESSAGEFRAME_LUA_TYPE_ID);
|
||||
}
|
||||
|
||||
int __fastcall Script_SetScrollOffset(void *L) {
|
||||
void *frame = ResolveSmf(L);
|
||||
if (frame == nullptr)
|
||||
return 0;
|
||||
if (!Game::Lua::IsNumber(L, 2)) {
|
||||
Game::Lua::Error(L, "Usage: %s:SetScrollOffset(offset)", Game::Lua::ObjectDisplayName(frame));
|
||||
return 0;
|
||||
}
|
||||
const int offset = Clamped(frame, Game::Lua::ToNumber(L, 2));
|
||||
if (offset != ScrollOffset(frame))
|
||||
ScrollTo(frame, offset);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __fastcall Script_GetMaxScrollRange(void *L) {
|
||||
void *frame = ResolveSmf(L);
|
||||
if (frame == nullptr)
|
||||
return 0;
|
||||
Game::Lua::PushNumber(L, MaxScrollRange(frame));
|
||||
return 1;
|
||||
}
|
||||
|
||||
int __fastcall Script_ScrollByAmount(void *L) {
|
||||
void *frame = ResolveSmf(L);
|
||||
if (frame == nullptr)
|
||||
return 0;
|
||||
if (!Game::Lua::IsNumber(L, 2)) {
|
||||
Game::Lua::Error(L, "Usage: %s:ScrollByAmount(amount)", Game::Lua::ObjectDisplayName(frame));
|
||||
return 0;
|
||||
}
|
||||
ScrollTo(frame, Clamped(frame, ScrollOffset(frame) + Game::Lua::ToNumber(L, 2)));
|
||||
DisplayRefreshed::MarkDirty(frame);
|
||||
return 0;
|
||||
}
|
||||
|
||||
const Game::Lua::FrameMethodEntry kMethods[] = {
|
||||
{"SetScrollOffset", &Script_SetScrollOffset},
|
||||
{"GetScrollOffset",
|
||||
reinterpret_cast<Game::Lua::CFunction>(Offsets::FUN_SCRIPT_SCROLLINGMESSAGEFRAME_GET_CURRENT_SCROLL)},
|
||||
{"GetMaxScrollRange", &Script_GetMaxScrollRange},
|
||||
{"ScrollByAmount", &Script_ScrollByAmount},
|
||||
};
|
||||
|
||||
const Game::Doc::Field kOffsetArgs[] = {
|
||||
Game::Doc::Req("offset", "number", "Lines from the newest message; clamped to 0..GetMaxScrollRange()."),
|
||||
};
|
||||
const Game::Doc::Field kOffsetRets[] = {
|
||||
Game::Doc::Req("offset", "number", "Lines from the newest message; 0 when not scrolled."),
|
||||
};
|
||||
const Game::Doc::Field kRangeRets[] = {
|
||||
Game::Doc::Req("maxScrollRange", "number"),
|
||||
};
|
||||
const Game::Doc::Field kAmountArgs[] = {
|
||||
Game::Doc::Req("amount", "number", "Positive scrolls toward older messages."),
|
||||
};
|
||||
const Game::Doc::Function kSetScrollOffset{"Scrolls the frame to a number of lines from the newest message.",
|
||||
kOffsetArgs, {}};
|
||||
const Game::Doc::Function kGetScrollOffset{"Returns how many lines the frame is scrolled from the newest message.",
|
||||
{}, kOffsetRets};
|
||||
const Game::Doc::Function kGetMaxScrollRange{"Returns the largest scroll offset: one less than the message count.",
|
||||
{}, kRangeRets};
|
||||
const Game::Doc::Function kScrollByAmount{"Scrolls the frame by a number of lines and shows the faded lines again.",
|
||||
kAmountArgs, {}};
|
||||
const Game::Doc::Method kDocs[] = {
|
||||
{"SetScrollOffset", &kSetScrollOffset},
|
||||
{"GetScrollOffset", &kGetScrollOffset},
|
||||
{"GetMaxScrollRange", &kGetMaxScrollRange},
|
||||
{"ScrollByAmount", &kScrollByAmount},
|
||||
};
|
||||
|
||||
void RegisterLuaFunctions() {
|
||||
Game::Lua::RegisterFrameMethods(reinterpret_cast<void *>(Offsets::VAR_SCROLLINGMESSAGEFRAME_METHOD_REGISTRY),
|
||||
kMethods, 4, kDocs, 4);
|
||||
}
|
||||
|
||||
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
||||
|
||||
} // namespace
|
||||
|
||||
} // namespace ScrollingMessageFrame::Scroll
|
||||
@@ -79,6 +79,7 @@
|
||||
#include "Common.h"
|
||||
#include "Game.h"
|
||||
#include "Offsets.h"
|
||||
#include "scrollingmessageframe/Layout.h"
|
||||
#include "text/InlineTexturePool.h"
|
||||
#include "text/PtrProbe.h"
|
||||
#include "texture/Atlas.h"
|
||||
@@ -2085,7 +2086,8 @@ static const Game::HookAutoRegister _paintHook{Offsets::FUN_TEXT_PAINT,
|
||||
// So a line's icons are recorded — and its regions placed — one frame AFTER its
|
||||
// glyphs draw, because a frame's textures (our icon regions) draw before its
|
||||
// fontstring glyphs and the placement isn't computed until the glyph build runs
|
||||
// mid-paint. This co-hook closes it: after the refresh sets up the lines (still
|
||||
// mid-paint. This layout listener (ScrollingMessageFrame::Layout, which owns
|
||||
// the hook) closes it: after the refresh sets up the lines (still
|
||||
// PRE-RENDER — the refresh runs from the SMF's Lua/event-driven methods, never
|
||||
// mid-render), force each icon-bearing line to resolve+build and apply its icon
|
||||
// placement synchronously, so the icons draw with their glyphs the same frame.
|
||||
@@ -2096,9 +2098,6 @@ static const Game::HookAutoRegister _paintHook{Offsets::FUN_TEXT_PAINT,
|
||||
// disabled independently of the whole feature; the SEH latch trips it on a fault.
|
||||
bool g_earlyApply = true;
|
||||
|
||||
using SmfRefresh_t = void(__fastcall *)(void *smf, void *edx, int newestIdx);
|
||||
SmfRefresh_t g_smfRefreshOriginal = nullptr;
|
||||
|
||||
using EnsureBuilt_t = int(__fastcall *)(void *node);
|
||||
using RealizeAnchor_t = void(__thiscall *)(void *anchor, int flag);
|
||||
using RebuildStringFs_t = void(__fastcall *)(void *fs);
|
||||
@@ -2183,15 +2182,12 @@ void SafeSmfEarlyApply(void *smf) {
|
||||
}
|
||||
}
|
||||
|
||||
void __fastcall SmfRefresh_h(void *smf, void *edx, int newestIdx) {
|
||||
g_smfRefreshOriginal(smf, edx, newestIdx);
|
||||
void OnSmfLayout(void *smf) {
|
||||
if (g_inlineEnabled && g_earlyApply)
|
||||
SafeSmfEarlyApply(smf);
|
||||
}
|
||||
|
||||
static const Game::HookAutoRegister _smfRefreshHook{
|
||||
Offsets::FUN_SMF_DISPLAY_REFRESH, reinterpret_cast<void *>(&SmfRefresh_h),
|
||||
reinterpret_cast<void **>(&g_smfRefreshOriginal)};
|
||||
static const ScrollingMessageFrame::Layout::AutoSubscribe _smfLayoutSub{&OnSmfLayout};
|
||||
|
||||
// --- Lua control surface ---------------------------------------------------
|
||||
|
||||
|
||||
Reference in New Issue
Block a user