mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-15 23:50:38 +00:00
Backports the modern OnTooltipSetItem tooltip script to 1.12 as a real
frame script, settable via the standard SetScript / GetScript / HookScript
and firing whenever a tooltip's item is set (with the tooltip as self). Lets
addons annotate item tooltips by hooking one script instead of wrapping every
Set* method -- the destructive wrap-and-rebuild pattern (AtlasLoot's
AddSourceLine) that clobbers the tooltip's item linkage.
Fully native, two Game::HookAutoRegister co-hooks in Tooltip::SetItemEvent:
- Resolver (FUN_005295d0, the CGGameTooltip vtable script-name -> slot
vmethod): for "OnTooltipSetItem" (a name the engine doesn't know) return a
pointer to a C-side per-tooltip 8-byte {handler, context} cell. The tooltip
object (alloc size 0x460) has no free slot, and the resolver's only contract
is "return where the handler lives", so external storage behaves exactly
like the engine's own slots -- proven by OnTooltipCleared (+0x44c).
- Item builder (FUN_0052B650, the shared funnel for SetBagItem /
SetInventoryItem / SetHyperlink / SetMerchantItem / SetAuctionItem / ...):
after the build, fire the handler via FUN_00702690 (the no-arg runner the
clear uses for OnTooltipCleared). Recursion-guarded, and suppressed via
Tooltip::SetItemEvent::Suppressor during Tooltip::Compare's internal
equipped-item build so a handler doesn't run mid line-shift.
Item only for now; OnTooltipSetSpell / OnTooltipSetUnit follow the same
pattern with their own builders.
553 lines
24 KiB
C++
553 lines
24 KiB
C++
// 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/>.
|
||
|
||
// `GameTooltip:SetHyperlinkCompareItem("itemLink" [, offset, shiftButton, comparisonTooltip])`
|
||
// — a backport of the 3.3.5+ tooltip method that powers item-comparison
|
||
// ("shopping") tooltips. The compared item comes from `itemLink` when
|
||
// given; otherwise it's taken from the item the `comparisonTooltip` (4th
|
||
// positional arg — the tooltip FrameXML's GameTooltip_ShowCompareItem
|
||
// passes) is displaying, so the method works purely tooltip-to-tooltip
|
||
// with no link, matching the retail call. Called on a tooltip frame (typically
|
||
// ShoppingTooltip1/2, but works on any GameTooltip-type frame), it:
|
||
//
|
||
// 1. Parses the hovered item link and finds which equipment slot(s)
|
||
// that item would occupy (via its inventoryType).
|
||
// 2. Picks the slot indicated by `offset` (1-based; two-slot items —
|
||
// rings, trinkets, one-hand weapons — expose slots at offset 1 and
|
||
// 2, so a caller iterates offset = 1 .. returnValue).
|
||
// 3. Fills the tooltip with the item currently EQUIPPED in that slot,
|
||
// led by a grey "Currently Equipped" header — done by calling the
|
||
// engine's own item-tooltip builder (FUN_GAMETOOLTIP_BUILD_ITEM) in
|
||
// its header mode. No Lua roundtrip.
|
||
// 4. Appends colored per-stat delta lines — yellow ITEM_DELTA_DESCRIPTION
|
||
// header, then green for a gain / red for a loss — showing how the
|
||
// hovered item compares to the equipped one. The delta is
|
||
// `hovered − equipped`, computed by the shared `Item::StatAccum`
|
||
// engine (the same one behind `C_Item.GetItemStatDelta`); the lines
|
||
// are added with the engine's raw add-line (FUN_GAMETOOLTIP_ADD_LINE).
|
||
//
|
||
// Returns the number of comparison slots for the hovered item (0 if it
|
||
// isn't equippable, isn't cached yet, the tooltip object can't be
|
||
// resolved, or nothing is equipped in the chosen slot) — a ClassicAPI
|
||
// extension over the retail signature, so a caller knows whether a second
|
||
// offset is worth querying.
|
||
//
|
||
// Everything is done with direct engine calls (the builder, clear, and
|
||
// add-line functions the engine uses itself) — no `lua_pcall` into
|
||
// registered Lua methods. The tooltip's final size/show is left to the
|
||
// caller (matching retail `SetHyperlinkCompareItem`, which populates but
|
||
// doesn't show). The 60-line pool from Tooltip::LinePool keeps the
|
||
// appended deltas under the AddLine cap.
|
||
//
|
||
// `shiftButton`: gates the stat-change breakdown. Deltas show by default
|
||
// (`true`, `1`, `nil`, or omitted) and are hidden only for an explicit
|
||
// `false` or `0` — just the grey header + the equipped item's tooltip.
|
||
// Both the boolean and the vanilla 1/nil convention are accepted —
|
||
// mirroring FrameXML's GameTooltip_ShowCompareItem.
|
||
|
||
#include "Game.h"
|
||
#include "Offsets.h"
|
||
#include "item/Arg.h"
|
||
#include "item/ID.h"
|
||
#include "item/Location.h"
|
||
#include "item/StatAccum.h"
|
||
#include "item/TooltipItem.h"
|
||
#include "tooltip/SetItemEvent.h"
|
||
#include "ui/ColorData.h"
|
||
|
||
#include <cstdint>
|
||
#include <cstdio>
|
||
#include <cstring>
|
||
|
||
namespace Tooltip::Compare {
|
||
|
||
namespace {
|
||
|
||
using Item::StatAccum::Accum;
|
||
|
||
// The engine's item-tooltip builder. __thiscall(self = tooltip object).
|
||
// With headerFlag != 0 it skips its leading clear and emits the grey
|
||
// "Currently Equipped" header; the item itself is looked up from itemID +
|
||
// guid regardless. See OFF/FUN notes in Offsets.h.
|
||
using BuildItemTooltip_t = void(__thiscall *)(void *self, uint32_t itemID, const void *guid,
|
||
const void *guid2, int a4, int a5, int a6,
|
||
int headerFlag, int a8, int a9);
|
||
// Raw add-line. Color args are pointers to a 4-byte packed {b,g,r,a}.
|
||
using AddLine_t = void(__thiscall *)(void *self, const char *left, const char *right,
|
||
const void *leftColor, const void *rightColor, int wrap);
|
||
using SetLineText_t = void(__thiscall *)(void *fontString, const char *text, int flag);
|
||
using SetLineColor_t = void(__thiscall *)(void *fontString, const void *colorBGRA);
|
||
|
||
// inventoryType (ItemStats_C m_inventoryType) → equipment slot ID(s).
|
||
// Slot IDs are the engine's canonical INVSLOT values (1 = Head … 19 =
|
||
// Tabard). Two-slot types (finger, trinket, one-hand weapon) fill both
|
||
// entries and return 2. Returns 0 for non-equippable types (bag, ammo,
|
||
// quiver, non-equip). `out` must hold 2 ints.
|
||
int SlotsForInvType(int invType, int *out) {
|
||
switch (invType) {
|
||
case 1: out[0] = 1; return 1; // HEAD
|
||
case 2: out[0] = 2; return 1; // NECK
|
||
case 3: out[0] = 3; return 1; // SHOULDER
|
||
case 4: out[0] = 4; return 1; // BODY (shirt)
|
||
case 5: case 20: out[0] = 5; return 1; // CHEST / ROBE
|
||
case 6: out[0] = 6; return 1; // WAIST
|
||
case 7: out[0] = 7; return 1; // LEGS
|
||
case 8: out[0] = 8; return 1; // FEET
|
||
case 9: out[0] = 9; return 1; // WRIST
|
||
case 10: out[0] = 10; return 1; // HANDS
|
||
case 11: out[0] = 11; out[1] = 12; return 2; // FINGER
|
||
case 12: out[0] = 13; out[1] = 14; return 2; // TRINKET
|
||
case 16: out[0] = 15; return 1; // CLOAK (back)
|
||
case 13: out[0] = 16; out[1] = 17; return 2; // ONE-HAND WEAPON (main/off)
|
||
case 17: out[0] = 16; return 1; // TWO-HAND WEAPON
|
||
case 21: out[0] = 16; return 1; // WEAPONMAINHAND
|
||
case 14: out[0] = 17; return 1; // SHIELD (off hand)
|
||
case 22: out[0] = 17; return 1; // WEAPONOFFHAND
|
||
case 23: out[0] = 17; return 1; // HOLDABLE (off hand)
|
||
case 15: out[0] = 18; return 1; // RANGED
|
||
case 25: out[0] = 18; return 1; // THROWN
|
||
case 26: out[0] = 18; return 1; // RANGEDRIGHT (wands)
|
||
case 28: out[0] = 18; return 1; // RELIC
|
||
case 19: out[0] = 19; return 1; // TABARD
|
||
default: return 0; // 0 non-equip, 18 bag, 24 ammo, 27 quiver
|
||
}
|
||
}
|
||
|
||
// English fallback labels, used when the client doesn't define the
|
||
// modern `_G[key]` global-string (vanilla 1.12 largely doesn't). Phrasing
|
||
// mirrors pfUI's eqcompare so the deltas read consistently on this
|
||
// client. Percent stats keep a "%" suffix since the values are native
|
||
// vanilla percentages.
|
||
struct KeyLabel {
|
||
const char *key;
|
||
const char *label;
|
||
};
|
||
constexpr KeyLabel kFallbackLabels[] = {
|
||
{"ITEM_MOD_MANA_SHORT", "Mana"},
|
||
{"ITEM_MOD_HEALTH_SHORT", "Health"},
|
||
{"ITEM_MOD_AGILITY_SHORT", "Agility"},
|
||
{"ITEM_MOD_STRENGTH_SHORT", "Strength"},
|
||
{"ITEM_MOD_INTELLECT_SHORT", "Intellect"},
|
||
{"ITEM_MOD_SPIRIT_SHORT", "Spirit"},
|
||
{"ITEM_MOD_STAMINA_SHORT", "Stamina"},
|
||
{"RESISTANCE0_NAME", "Armor"},
|
||
{"RESISTANCE1_NAME", "Holy Resistance"},
|
||
{"RESISTANCE2_NAME", "Fire Resistance"},
|
||
{"RESISTANCE3_NAME", "Nature Resistance"},
|
||
{"RESISTANCE4_NAME", "Frost Resistance"},
|
||
{"RESISTANCE5_NAME", "Shadow Resistance"},
|
||
{"RESISTANCE6_NAME", "Arcane Resistance"},
|
||
{"ITEM_MOD_ATTACK_POWER_SHORT", "Attack Power"},
|
||
{"ITEM_MOD_RANGED_ATTACK_POWER_SHORT", "Ranged Attack Power"},
|
||
{"ITEM_MOD_CRIT_MELEE_RATING", "Melee Crit %"},
|
||
{"ITEM_MOD_CRIT_RANGED_RATING", "Ranged Crit %"},
|
||
{"ITEM_MOD_HIT_MELEE_RATING", "Melee Hit %"},
|
||
{"ITEM_MOD_HIT_RANGED_RATING", "Ranged Hit %"},
|
||
{"ITEM_MOD_HIT_SPELL_RATING", "Spell Hit %"},
|
||
{"ITEM_MOD_CRIT_SPELL_RATING", "Spell Crit %"},
|
||
{"ITEM_MOD_SPELL_DAMAGE_DONE_SHORT", "Spell Damage"},
|
||
{"ITEM_MOD_SPELL_HEALING_DONE_SHORT", "Spell Healing"},
|
||
{"ITEM_MOD_MANA_REGENERATION", "Mana Regen"},
|
||
{"ITEM_MOD_DEFENSE_SKILL_RATING", "Defense"},
|
||
{"ITEM_MOD_DODGE_RATING", "Dodge %"},
|
||
{"ITEM_MOD_PARRY_RATING", "Parry %"},
|
||
{"ITEM_MOD_BLOCK_RATING", "Block %"},
|
||
{"ITEM_MOD_BLOCK_VALUE", "Block Value"},
|
||
{"ITEM_MOD_DAMAGE_PER_SECOND_SHORT", "Damage Per Second"},
|
||
{"ITEM_DELTA_DESCRIPTION",
|
||
"If you replace this item, the following stat changes will occur:"},
|
||
};
|
||
|
||
const char *FallbackLabel(const char *key) {
|
||
for (const auto &e : kFallbackLabels)
|
||
if (std::strcmp(e.key, key) == 0)
|
||
return e.label;
|
||
return key; // last resort — raw key beats crashing
|
||
}
|
||
|
||
// Resolve a display label for `key` into `out`. Prefers the client's
|
||
// `_G[key]` when it's a plain, non-empty string (respects localization /
|
||
// server-defined labels), read via a direct globals-table access — no
|
||
// pcall. Ignores format strings (a "%"-bearing global like "+%d Strength"
|
||
// would render garbage), falling back to the built-in English label.
|
||
void LabelFor(void *L, const char *key, char *out, int outSize) {
|
||
const int saved = Game::Lua::GetTop(L);
|
||
Game::Lua::PushString(L, key);
|
||
Game::Lua::GetTable(L, Game::Lua::GLOBALS_INDEX);
|
||
const char *g = (Game::Lua::Type(L, -1) == Game::Lua::TYPE_STRING)
|
||
? Game::Lua::ToString(L, -1)
|
||
: nullptr;
|
||
if (g != nullptr && *g != '\0' && std::strchr(g, '%') == nullptr)
|
||
std::snprintf(out, outSize, "%s", g);
|
||
else
|
||
std::snprintf(out, outSize, "%s", FallbackLabel(key));
|
||
Game::Lua::SetTop(L, saved);
|
||
}
|
||
|
||
// Delta colors — the canonical GlobalColor.dbc tags modern WoW uses for
|
||
// item comparison, pulled from UI::ColorData (its packed argb is already
|
||
// the {b,g,r,a} order the tooltip line-color setter wants).
|
||
constexpr uint32_t kGain = UI::ColorData::ByTag("INCREASE_STAT_COLOR"); // green
|
||
constexpr uint32_t kLoss = UI::ColorData::ByTag("DECREASE_STAT_COLOR"); // red
|
||
constexpr uint32_t kHeader = UI::ColorData::ByTag("NORMAL_FONT_COLOR"); // header yellow
|
||
|
||
// self:AddLine equivalent — left-aligned colored line via the engine's
|
||
// raw add-line. `color` must outlive the call (we pass its address).
|
||
void AddColoredLine(void *self, const char *text, const uint32_t &color) {
|
||
auto add = reinterpret_cast<AddLine_t>(Offsets::FUN_GAMETOOLTIP_ADD_LINE);
|
||
add(self, text, nullptr, &color, nullptr, 0);
|
||
}
|
||
|
||
// Appends the yellow ITEM_DELTA_DESCRIPTION header + one line per non-zero
|
||
// stat and a DPS line. No-op when nothing differs (identical items /
|
||
// self-compare add no delta section).
|
||
void RenderDeltas(void *self, void *L, const Accum *acc, double dpsDelta) {
|
||
const bool hasDps = (dpsDelta > 1e-4 || dpsDelta < -1e-4);
|
||
bool hasAny = hasDps;
|
||
for (int i = 0; !hasAny && i < Item::StatAccum::kCount; ++i)
|
||
hasAny = (acc[i].value != 0);
|
||
if (!hasAny)
|
||
return;
|
||
|
||
char label[192];
|
||
char line[256];
|
||
|
||
LabelFor(L, "ITEM_DELTA_DESCRIPTION", label, sizeof(label));
|
||
AddColoredLine(self, label, kHeader);
|
||
|
||
if (hasDps) {
|
||
LabelFor(L, "ITEM_MOD_DAMAGE_PER_SECOND_SHORT", label, sizeof(label));
|
||
std::snprintf(line, sizeof(line), "%s%.1f %s", dpsDelta > 0 ? "+" : "",
|
||
dpsDelta, label);
|
||
AddColoredLine(self, line, dpsDelta > 0 ? kGain : kLoss);
|
||
}
|
||
|
||
for (int i = 0; i < Item::StatAccum::kCount; ++i) {
|
||
const long v = acc[i].value;
|
||
if (v == 0)
|
||
continue;
|
||
LabelFor(L, acc[i].key, label, sizeof(label));
|
||
std::snprintf(line, sizeof(line), "%s%ld %s", v > 0 ? "+" : "", v, label);
|
||
AddColoredLine(self, line, v > 0 ? kGain : kLoss);
|
||
}
|
||
}
|
||
|
||
// --- "Currently Equipped" header ---------------------------------------
|
||
//
|
||
// The engine's builder can emit this header itself (FUN_0052B650 param_7),
|
||
// but that path merges it into the item's name line and force-wraps it.
|
||
// So we build the item cleanly and prepend the header the way vanilla
|
||
// addons (pfUI eqcompare) do — shift every built line's text+color down
|
||
// one slot and claim line 0 — but entirely in C via the engine's line
|
||
// FontStrings, no Lua method calls.
|
||
|
||
const char *FSText(const void *fs) {
|
||
if (fs == nullptr)
|
||
return nullptr;
|
||
return *reinterpret_cast<const char *const *>(
|
||
static_cast<const uint8_t *>(fs) + Offsets::OFF_FONTSTRING_TEXT);
|
||
}
|
||
|
||
// Whether a line's FontString is actually shown. The tooltip clear hides
|
||
// unused cells but keeps their (now stale) text, so this — not FSText —
|
||
// is what decides whether a cell carries live content to shift.
|
||
bool FSVisible(const void *fs) {
|
||
if (fs == nullptr)
|
||
return false;
|
||
return *reinterpret_cast<const int *>(
|
||
static_cast<const uint8_t *>(fs) + Offsets::OFF_FONTSTRING_VISIBLE) != 0;
|
||
}
|
||
|
||
// Reads a FontString's current color into `*out` (4-byte {b,g,r,a}).
|
||
// Returns false when the color storage isn't set, so the caller leaves
|
||
// the destination's existing color alone.
|
||
bool FSColor(const void *fs, uint32_t *out) {
|
||
if (fs == nullptr)
|
||
return false;
|
||
auto *slot = *reinterpret_cast<const uint32_t *const *>(
|
||
static_cast<const uint8_t *>(fs) + Offsets::OFF_FONTSTRING_COLOR_PTR);
|
||
if (slot == nullptr)
|
||
return false;
|
||
*out = *slot;
|
||
return true;
|
||
}
|
||
|
||
void FSSetText(void *fs, const char *text) {
|
||
if (fs != nullptr)
|
||
reinterpret_cast<SetLineText_t>(Offsets::FUN_FONTSTRING_SET_TEXT)(fs, text, 0);
|
||
}
|
||
|
||
void FSSetColor(void *fs, const uint32_t &color) {
|
||
if (fs != nullptr)
|
||
reinterpret_cast<SetLineColor_t>(Offsets::FUN_FONTSTRING_SET_COLOR)(fs, &color);
|
||
}
|
||
|
||
using ShowHideFS_t = void(__fastcall *)(void *fs);
|
||
|
||
// Realize a FontString's shown state the way the engine's AddLine/clear
|
||
// pair do: set the desired-shown flag, then call SHOW or HIDE so the
|
||
// FontString gets positioned (or dropped from) the layout. Without this a
|
||
// cell moved into a previously-hidden slot never anchors.
|
||
void FSSetShown(void *fs, bool shown) {
|
||
if (fs == nullptr)
|
||
return;
|
||
*reinterpret_cast<int *>(static_cast<uint8_t *>(fs) +
|
||
Offsets::OFF_FONTSTRING_SHOWN_FLAG) = shown ? 1 : 0;
|
||
reinterpret_cast<ShowHideFS_t>(
|
||
shown ? Offsets::FUN_FONTSTRING_SHOW : Offsets::FUN_FONTSTRING_HIDE)(fs);
|
||
}
|
||
|
||
// Copies `src`'s content (text + color) onto `dst`, replicating the shown
|
||
// state so `dst` positions correctly; hides `dst` when `src` isn't a live
|
||
// (shown) cell. Keyed on visibility, not text, so stale text the clear
|
||
// left behind in a hidden cell isn't resurrected. One column of the shift.
|
||
void CopyLineCell(void *dst, const void *src) {
|
||
if (dst == nullptr)
|
||
return;
|
||
if (FSVisible(src)) {
|
||
const char *text = FSText(src);
|
||
FSSetText(dst, text != nullptr ? text : "");
|
||
// Always set a color: source's if it has one, else white — so a
|
||
// stale color left on `dst` by a previous delta line is reset
|
||
// (lines the builder leaves at the default have no readable color).
|
||
uint32_t color = UI::ColorData::ByTag("WHITE_FONT_COLOR");
|
||
FSColor(src, &color);
|
||
FSSetColor(dst, color);
|
||
FSSetShown(dst, true);
|
||
} else {
|
||
FSSetText(dst, "");
|
||
FSSetShown(dst, false);
|
||
}
|
||
}
|
||
|
||
void PrependCurrentlyEquipped(void *self, void *L) {
|
||
auto *t = static_cast<uint8_t *>(self);
|
||
int *numLines = reinterpret_cast<int *>(t + Offsets::OFF_GAMETOOLTIP_NUM_LINES);
|
||
const int allocated =
|
||
*reinterpret_cast<const int *>(t + Offsets::OFF_GAMETOOLTIP_NUM_LINES_ALLOC);
|
||
const int n = *numLines;
|
||
if (n <= 0 || n + 1 > allocated)
|
||
return; // nothing built, or pool full (LinePool keeps 60, so rare)
|
||
|
||
auto **leftArr = *reinterpret_cast<void ***>(
|
||
t + Offsets::OFF_GAMETOOLTIP_TEXTLEFT_DESC + 8);
|
||
auto **rightArr = *reinterpret_cast<void ***>(
|
||
t + Offsets::OFF_GAMETOOLTIP_TEXTRIGHT_DESC + 8);
|
||
auto *wrapArr = *reinterpret_cast<int **>(
|
||
t + Offsets::OFF_GAMETOOLTIP_WRAPFLAG_DESC + 8);
|
||
if (leftArr == nullptr || rightArr == nullptr || wrapArr == nullptr)
|
||
return;
|
||
|
||
// Shift lines [0..n-1] down to [1..n]. High-to-low so each source is
|
||
// read before the next iteration overwrites it.
|
||
for (int i = n - 1; i >= 0; --i) {
|
||
CopyLineCell(leftArr[i + 1], leftArr[i]);
|
||
CopyLineCell(rightArr[i + 1], rightArr[i]);
|
||
wrapArr[i + 1] = wrapArr[i];
|
||
}
|
||
|
||
char header[128];
|
||
LabelFor(L, "CURRENTLY_EQUIPPED", header, sizeof(header)); // native 1.12 string
|
||
constexpr uint32_t grey = UI::ColorData::ByTag("GRAY_FONT_COLOR");
|
||
FSSetText(leftArr[0], header);
|
||
FSSetColor(leftArr[0], grey);
|
||
FSSetShown(leftArr[0], true);
|
||
FSSetText(rightArr[0], "");
|
||
FSSetShown(rightArr[0], false);
|
||
wrapArr[0] = 0;
|
||
*numLines = n + 1;
|
||
}
|
||
|
||
// Reads the live random-property (suffix) index off an equipped CGItem's
|
||
// descriptor — the same index ItemRandomProperties.dbc / ApplyRandomSuffix
|
||
// use. 0 for a plain item or a null descriptor.
|
||
int EquippedSuffix(const uint8_t *item) {
|
||
auto *desc = *reinterpret_cast<const uint8_t *const *>(
|
||
item + Offsets::OFF_ITEM_DESCRIPTOR);
|
||
if (desc == nullptr)
|
||
return 0;
|
||
return static_cast<int>(*reinterpret_cast<const uint32_t *>(
|
||
desc + Offsets::OFF_DESCRIPTOR_RANDOM_PROPERTY));
|
||
}
|
||
|
||
uint64_t EquippedGUID(const uint8_t *item) {
|
||
auto *instance = *reinterpret_cast<const uint8_t *const *>(
|
||
item + Offsets::OFF_ITEM_INSTANCE_BLOCK);
|
||
if (instance == nullptr)
|
||
return 0;
|
||
return *reinterpret_cast<const uint64_t *>(
|
||
instance + Offsets::OFF_INSTANCE_BLOCK_GUID);
|
||
}
|
||
|
||
int __fastcall Script_SetHyperlinkCompareItem(void *L) {
|
||
if (Game::Lua::Type(L, 1) != Game::Lua::TYPE_TABLE) {
|
||
Game::Lua::Error(
|
||
L, "Usage: GameTooltip:SetHyperlinkCompareItem(\"itemLink\" [, offset, shiftButton, comparisonTooltip])");
|
||
return 0;
|
||
}
|
||
const int argc = Game::Lua::GetTop(L);
|
||
|
||
auto bail = [&](int n) -> int {
|
||
Game::Lua::SetTop(L, argc);
|
||
Game::Lua::PushNumber(L, static_cast<double>(n));
|
||
return 1;
|
||
};
|
||
|
||
// Compared ("hovered") item: prefer the explicit link (arg 2). When
|
||
// it's absent, fall back to whatever the comparisonTooltip (arg 5) is
|
||
// displaying — the builder stashes that tooltip's itemID/GUID, so we
|
||
// recover the itemID directly and the suffix via the GUID's live
|
||
// CGItem. This makes the method 1:1 with the retail call, which can be
|
||
// driven purely tooltip-to-tooltip.
|
||
int hoveredID = Item::Arg::ResolveItemID(L, 2);
|
||
int hoveredSuffix = Item::StatAccum::ParseRandomSuffixFromLink(L, 2);
|
||
if (hoveredID <= 0 && Game::Lua::Type(L, 5) == Game::Lua::TYPE_TABLE) {
|
||
if (void *cmp = Game::Lua::ResolveObject(L, 5)) {
|
||
uint64_t g = 0;
|
||
hoveredID = Item::TooltipItem::CurrentID(cmp, &g);
|
||
if (g != 0) {
|
||
const uint8_t *cg = Item::Location::ResolveByGUID(g);
|
||
if (cg != nullptr)
|
||
hoveredSuffix = EquippedSuffix(cg);
|
||
}
|
||
}
|
||
}
|
||
const uint8_t *hoveredRec =
|
||
hoveredID > 0 ? Item::StatAccum::FetchRecord(static_cast<uint32_t>(hoveredID)) : nullptr;
|
||
if (hoveredRec == nullptr)
|
||
return bail(0); // no link and no comparisonTooltip item, or not cached yet
|
||
|
||
const int invType = static_cast<int>(*reinterpret_cast<const uint32_t *>(
|
||
hoveredRec + Offsets::OFF_ITEMSTATS_INVENTORY_TYPE));
|
||
int slots[2] = {0, 0};
|
||
const int nSlots = SlotsForInvType(invType, slots);
|
||
if (nSlots == 0)
|
||
return bail(0); // non-equippable
|
||
|
||
int offset = (Game::Lua::Type(L, 3) == Game::Lua::TYPE_NUMBER)
|
||
? static_cast<int>(Game::Lua::ToNumber(L, 3))
|
||
: 1;
|
||
if (offset < 1)
|
||
offset = 1;
|
||
if (offset > nSlots)
|
||
return bail(nSlots);
|
||
const int slotID = slots[offset - 1];
|
||
|
||
// shiftButton: gates the stat-change breakdown. Deltas show by default
|
||
// — for `true`, `1`, `nil`, or omitted — and are hidden ONLY for an
|
||
// explicit `false` or `0`. Accepting both the boolean and the vanilla
|
||
// 1/nil convention matches how callers (and FrameXML's
|
||
// GameTooltip_ShowCompareItem) forward the modified-click state.
|
||
bool showDeltas = true;
|
||
const int shiftType = Game::Lua::Type(L, 4);
|
||
if (shiftType == Game::Lua::TYPE_BOOLEAN)
|
||
showDeltas = Game::Lua::ToBoolean(L, 4) != 0;
|
||
else if (shiftType == Game::Lua::TYPE_NUMBER)
|
||
showDeltas = Game::Lua::ToNumber(L, 4) != 0.0;
|
||
|
||
// What's equipped there? Nothing → no comparison; leave the tooltip
|
||
// as the caller had it.
|
||
const uint8_t *eqItem = Item::Location::ResolveEquipmentSlot(slotID);
|
||
if (eqItem == nullptr)
|
||
return bail(nSlots);
|
||
const int equippedID = Item::ID::FromCGItem(eqItem);
|
||
if (equippedID <= 0)
|
||
return bail(nSlots);
|
||
const int equippedSuffix = EquippedSuffix(eqItem);
|
||
uint64_t equippedGUID = EquippedGUID(eqItem);
|
||
|
||
// The tooltip's underlying CFrameScriptObject — the `this` for the
|
||
// engine's builder / add-line thiscalls.
|
||
void *self = Game::Lua::ResolveObject(L, 1);
|
||
if (self == nullptr)
|
||
return bail(0);
|
||
|
||
// Build the equipped item into the tooltip via the engine's own
|
||
// item-tooltip builder (the call SetInventoryItem/SetHyperlink use),
|
||
// proven arg shape from FUN_005353b0/FUN_00535700 — all flags 0. This
|
||
// clears + fills the item cleanly (no wrap). The grey "Currently
|
||
// Equipped" header is prepended afterwards. Suppress OnTooltipSetItem for
|
||
// this internal build so a handler doesn't run mid-way through the
|
||
// line-shift below (it fires for the *hovered* item's real Set* instead).
|
||
{
|
||
Tooltip::SetItemEvent::Suppressor noEvent;
|
||
reinterpret_cast<BuildItemTooltip_t>(Offsets::FUN_GAMETOOLTIP_BUILD_ITEM)(
|
||
self, static_cast<uint32_t>(equippedID), &equippedGUID, &equippedGUID, 0, 0, 0, 0, 0, 0);
|
||
}
|
||
PrependCurrentlyEquipped(self, L);
|
||
|
||
// Delta = hovered − equipped, then render (unless suppressed).
|
||
if (showDeltas) {
|
||
Accum acc[Item::StatAccum::kCount];
|
||
Item::StatAccum::Init(acc);
|
||
Item::StatAccum::AccumulateRecord(acc, hoveredRec, +1);
|
||
Item::StatAccum::ApplyRandomSuffix(acc, hoveredSuffix, +1);
|
||
const uint8_t *equippedRec =
|
||
Item::StatAccum::FetchRecord(static_cast<uint32_t>(equippedID));
|
||
if (equippedRec != nullptr) {
|
||
Item::StatAccum::AccumulateRecord(acc, equippedRec, -1);
|
||
Item::StatAccum::ApplyRandomSuffix(acc, equippedSuffix, -1);
|
||
}
|
||
const double dpsDelta = Item::StatAccum::ComputeDPS(hoveredRec) -
|
||
(equippedRec ? Item::StatAccum::ComputeDPS(equippedRec) : 0.0);
|
||
RenderDeltas(self, L, acc, dpsDelta);
|
||
}
|
||
return bail(nSlots);
|
||
}
|
||
|
||
// `GameTooltip:IsEquippedItem()` → bool. True when the item the tooltip is
|
||
// currently displaying is equipped in a character-pane slot. The displayed
|
||
// item is resolved by Item::TooltipItem::CurrentID (which guards the stale
|
||
// item-GUID so unit / spell / gameobject tooltips read 0 and never
|
||
// false-positive). Backports the 3.3.5 GameTooltip method (registry
|
||
// index 63); the equipment walk mirrors C_Item.IsEquippedItem's itemID
|
||
// path.
|
||
int __fastcall Script_IsEquippedItem(void *L) {
|
||
if (Game::Lua::Type(L, 1) != Game::Lua::TYPE_TABLE) {
|
||
Game::Lua::Error(L, "Usage: GameTooltip:IsEquippedItem()");
|
||
return 0;
|
||
}
|
||
void *self = Game::Lua::ResolveObject(L, 1);
|
||
const int itemID = self != nullptr ? Item::TooltipItem::CurrentID(self, nullptr) : 0;
|
||
|
||
bool equipped = false;
|
||
for (int slot = Offsets::EQUIPMENT_SLOT_FIRST;
|
||
itemID > 0 && slot <= Offsets::EQUIPMENT_SLOT_LAST; ++slot) {
|
||
const uint8_t *it = Item::Location::ResolveEquipmentSlot(slot);
|
||
if (it != nullptr && Item::ID::FromCGItem(it) == itemID) {
|
||
equipped = true;
|
||
break;
|
||
}
|
||
}
|
||
Game::Lua::PushBool(L, equipped);
|
||
return 1;
|
||
}
|
||
|
||
const Game::Lua::FrameMethodEntry g_methods[] = {
|
||
{"SetHyperlinkCompareItem", &Script_SetHyperlinkCompareItem},
|
||
{"IsEquippedItem", &Script_IsEquippedItem},
|
||
};
|
||
|
||
void RegisterLuaFunctions() {
|
||
Game::Lua::RegisterFrameMethods(
|
||
reinterpret_cast<void *>(Offsets::VAR_GAMETOOLTIP_METHOD_REGISTRY),
|
||
g_methods,
|
||
static_cast<int>(sizeof(g_methods) / sizeof(g_methods[0])));
|
||
}
|
||
|
||
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
||
|
||
} // namespace
|
||
|
||
} // namespace Tooltip::Compare
|