mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 16:10:36 +00:00
161 lines
6.7 KiB
C++
161 lines
6.7 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 Lesser 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 Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License along with
|
|
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
#include "Game.h"
|
|
#include "Offsets.h"
|
|
#include "spell/Tooltip.h"
|
|
|
|
#include <cstdint>
|
|
|
|
namespace Talent::Tooltip {
|
|
|
|
// Walks every (tab, talent) entry the player has loaded and returns
|
|
// the (1-based) tab/idx pair where `TalentEntry+0x00 == talentID`.
|
|
// Returns false if the talent isn't in any of the player's tabs —
|
|
// 1.12 only loads the local player's class talent data, so other
|
|
// classes' talents aren't findable here. Same access pattern as
|
|
// `Talent::Info::Script_GetTalentIDByIndex` (#42), inverted.
|
|
static bool FindTalentByID(uint32_t talentID, int *outTab, int *outIdx) {
|
|
const int tabCount = *reinterpret_cast<const int *>(
|
|
static_cast<uintptr_t>(Offsets::VAR_TALENT_TAB_COUNT));
|
|
auto *tabs = *reinterpret_cast<const uint8_t *const *const *>(
|
|
static_cast<uintptr_t>(Offsets::VAR_TALENT_TAB_INFO_ARRAY));
|
|
if (tabs == nullptr)
|
|
return false;
|
|
|
|
for (int t = 1; t <= tabCount; ++t) {
|
|
const uint8_t *tabInfo = tabs[t - 1];
|
|
if (tabInfo == nullptr)
|
|
continue;
|
|
const int numTalents = *reinterpret_cast<const int *>(
|
|
tabInfo + Offsets::OFF_TABINFO_NUM_TALENTS);
|
|
auto *talents = *reinterpret_cast<const uint8_t *const *>(
|
|
tabInfo + Offsets::OFF_TABINFO_TALENT_ARRAY);
|
|
if (talents == nullptr)
|
|
continue;
|
|
|
|
for (int i = 1; i <= numTalents; ++i) {
|
|
const uint8_t *entry =
|
|
talents + (i - 1) * Offsets::TALENT_ENTRY_STRIDE;
|
|
const uint32_t id = *reinterpret_cast<const uint32_t *>(entry);
|
|
if (id == talentID) {
|
|
*outTab = t;
|
|
*outIdx = i;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Looks up the rank-1 spellID for a given talentID via Talent.dbc.
|
|
// Returns 0 if the ID is out of range, the slot is unpopulated, or
|
|
// the rank-1 SpellRank is missing. Records pointer is at the standard
|
|
// DBC class shape (`+0x08` of class instance), indexed directly by
|
|
// talentID; sparse — many slots are NULL across classes.
|
|
static uint32_t LookupTalentRank1Spell(uint32_t talentID) {
|
|
const int maxID = *reinterpret_cast<const int *>(
|
|
static_cast<uintptr_t>(Offsets::VAR_TALENT_DBC_COUNT));
|
|
if (talentID == 0 || static_cast<int>(talentID) > maxID)
|
|
return 0;
|
|
auto *records = *reinterpret_cast<const uint8_t *const *const *>(
|
|
static_cast<uintptr_t>(Offsets::VAR_TALENT_DBC_RECORDS));
|
|
if (records == nullptr)
|
|
return 0;
|
|
const uint8_t *rec = records[talentID];
|
|
if (rec == nullptr)
|
|
return 0;
|
|
return *reinterpret_cast<const uint32_t *>(rec + Offsets::OFF_TALENT_SPELL_RANK);
|
|
}
|
|
|
|
// `GameTooltip:SetTalentByID(talentID)` — modern method that renders a
|
|
// talent tooltip from just a Talent.dbc primary key. The 1.12
|
|
// equivalent is `GameTooltip:SetTalent(tabIndex, talentIndex)`, which
|
|
// only renders talents from the local player's loaded tabs (one class
|
|
// only).
|
|
//
|
|
// Two-tier resolution:
|
|
//
|
|
// 1. **Player-class fast path.** Walk the local player's TabInfo
|
|
// arrays for matching talentID. If found, dispatch to
|
|
// `Script_GameTooltip_SetTalent` (registry slot 34, `0x00535170`)
|
|
// with the resolved (tab, idx). Renders the rich talent tooltip
|
|
// with rank info, prereqs, "click to learn next rank" — same as
|
|
// hovering the talent in the talent UI.
|
|
//
|
|
// 2. **Cross-class fallback via Talent.dbc.** Look up the talent
|
|
// record by ID in the Talent.dbc array at `[VAR_TALENT_DBC_RECORDS]`,
|
|
// read the rank-1 spellID at `+0x10`, and dispatch the spell
|
|
// tooltip via `Spell::Tooltip::ShowByID` (the same path
|
|
// `GameTooltip:SetSpellByID` uses). Renders the spell info —
|
|
// cast time, range, mana cost, description — without the talent-
|
|
// specific decorations (rank counter, prereq lines), since those
|
|
// live in the per-player engine machinery we can't reach
|
|
// cross-class.
|
|
//
|
|
// Modern WoW's `SetTalentByID` shows a richer cross-class tooltip
|
|
// (talent name + "Rank 0/N" + spell description). Building that
|
|
// requires Lua-level GameTooltip:AddLine work; for now the spell
|
|
// tooltip is functionally equivalent for "what does this talent do?"
|
|
// queries, which is the dominant use case.
|
|
//
|
|
// Silent no-op when `talentID` doesn't match any record (Talent.dbc
|
|
// is sparse — talent IDs are not contiguous). Errors via `lua_error`
|
|
// only on type mismatch (non-table self, non-number talentID).
|
|
static int __fastcall Script_GameTooltipSetTalentByID(void *L) {
|
|
if (Game::Lua::Type(L, 1) != Game::Lua::TYPE_TABLE) {
|
|
Game::Lua::Error(L, "Usage: GameTooltip:SetTalentByID(talentID)");
|
|
return 0;
|
|
}
|
|
if (!Game::Lua::IsNumber(L, 2)) {
|
|
Game::Lua::Error(L, "Usage: GameTooltip:SetTalentByID(talentID)");
|
|
return 0;
|
|
}
|
|
const int talentID = static_cast<int>(Game::Lua::ToNumber(L, 2));
|
|
if (talentID <= 0)
|
|
return 0;
|
|
|
|
// Tier 1 — player's class. Rich talent tooltip via SetTalent.
|
|
int tab = 0, idx = 0;
|
|
if (FindTalentByID(static_cast<uint32_t>(talentID), &tab, &idx)) {
|
|
Game::Lua::SetTop(L, 1);
|
|
Game::Lua::PushNumber(L, static_cast<double>(tab));
|
|
Game::Lua::PushNumber(L, static_cast<double>(idx));
|
|
using Script_t = int(__fastcall *)(void *L);
|
|
auto fn = reinterpret_cast<Script_t>(Offsets::FUN_SCRIPT_GAMETOOLTIP_SET_TALENT);
|
|
return fn(L);
|
|
}
|
|
|
|
// Tier 2 — cross-class via Talent.dbc + spell tooltip fallback.
|
|
const uint32_t spellID = LookupTalentRank1Spell(static_cast<uint32_t>(talentID));
|
|
if (spellID == 0)
|
|
return 0;
|
|
Spell::Tooltip::ShowByID(L, static_cast<int>(spellID));
|
|
return 0;
|
|
}
|
|
|
|
static const Game::Lua::FrameMethodEntry g_methods[] = {
|
|
{"SetTalentByID", &Script_GameTooltipSetTalentByID},
|
|
};
|
|
|
|
static 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])));
|
|
}
|
|
|
|
static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
|
|
|
} // namespace Talent::Tooltip
|