// 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 .
// Every unit event the engine fires reaches ClassicAPI's unit tokens —
// `focus`, `nameplateN`, `markN`, `softenemy`, `softfriend` — as it reaches
// `target`.
//
// This is how 4.3.4 makes its focus a full unit token (decomp: GameUI.cpp
// SetFocusTarget, ScriptEvents.cpp token maps), in two steps: the unit gets a
// script-registration bit, so the engine watches its fields, and the
// GUID→token maps return the token, so whatever the engine fires for that unit
// fires for the token too. 1.12 has both pieces, less these tokens:
//
// Watching. The engine rebuilds a unit's registration mask from scratch in
// FUN_UNIT_SCRIPT_RECOMPUTE on every target / group / pet change and at unit
// post-init. A co-hook keeps UNIT_SCRIPT_REG_TOKENS (one bit for all three
// tokens) on any unit that has one, through the engine's own
// FUN_UNIT_SCRIPT_REGISTER / _UNREGISTER, which start and stop the field
// watch on 0 ↔ nonzero. Post-init covers a unit coming back into range — a
// case 4.3.4's own recompute forgets for its focus. A token's owner calls
// Refresh when it gives or takes the token.
//
// Tokens. 1.12 fires every unit event through one of the two callers of the
// token map: the broadcast FUN_UNIT_EVENT_BROADCAST (field changes, names,
// portraits, classification, group stats, auras, …) and the combat feedback
// FUN_UNIT_COMBAT_FEEDBACK (UNIT_COMBAT). nampower replaces both functions
// with detours that never call the original, so neither can be co-hooked —
// the last DLL to patch wins. Their CALL / JMP sites, which nobody patches,
// point at the functions below instead: each calls the original address
// (running nampower's detour or the engine, whichever is there), then fires
// the event once more for each ClassicAPI token of the unit. The sites are
// found by scanning `.text` for direct rel32 calls to the two addresses and
// patched only when the counts match Ghidra's xref lists, so a different
// binary is left alone. The token map itself is SuperWoW's patch site.
//
// All of a token's unit events come from here, none from Unit::TokenObserver:
// SuperWoW sets a registration bit on every unit, so every unit's field
// changes already reach the broadcast, and an observer of our own would fire
// them a second time. Only `focustarget` (no unit has it in any token map)
// stays on TokenObserver.
#include "TokenEvents.h"
#include "Common.h"
#include "Game.h"
#include "Offsets.h"
#include "debug/Log.h"
#include "nameplate/Walk.h"
#include "object/Resolve.h"
#include "target/SoftUnit.h"
#include "unit/Focus.h"
#include "unit/Identity.h"
#include "unit/RaidTarget.h"
#include
#include
#include
#include
namespace Unit::TokenEvents {
namespace {
using Fire_t = void(__cdecl *)(int eventId, const char *fmt, ...);
using UnitFn_t = void(__fastcall *)(void *unit);
using ScriptBits_t = void(__thiscall *)(void *unit, uint32_t bits);
using Broadcast_t = void(__fastcall *)(const uint64_t *guid, uint32_t eventId);
using CombatFeedback_t = void(__fastcall *)(const uint64_t *guid, const char *action, int amount,
int school, uint32_t hitInfo);
// At most one focus, nameplate, mark, softenemy and softfriend per unit.
constexpr int kMaxTokens = 5;
using TokenList = char[kMaxTokens][24];
// The ClassicAPI tokens `guid` has right now, in UnitTokenFromGUID's order.
int TokensOf(uint64_t guid, TokenList &out) {
if (guid == 0)
return 0;
int n = 0;
for (int i = 1, count = NamePlate::Events::GetSlotCount(); i <= count; ++i)
if (NamePlate::Events::GetGUIDByIndex(i) == guid) {
std::snprintf(out[n++], sizeof out[0], "nameplate%d", i);
break;
}
if (guid == Unit::Focus::Get())
std::snprintf(out[n++], sizeof out[0], "focus");
for (int m = 1; m <= Unit::RaidTarget::kMarkCount; ++m)
if (Unit::RaidTarget::GetGUIDByMark(m) == guid) {
std::snprintf(out[n++], sizeof out[0], "mark%d", m);
break;
}
if (guid == Target::SoftUnit::Current(Target::SoftUnit::Side::Enemy))
std::snprintf(out[n++], sizeof out[0], "softenemy");
if (guid == Target::SoftUnit::Current(Target::SoftUnit::Side::Friend))
std::snprintf(out[n++], sizeof out[0], "softfriend");
return n;
}
bool HasTokens(uint64_t guid) {
TokenList t;
return TokensOf(guid, t) > 0;
}
// The tokens to fire for, empty before the world is up (the token map
// answers nothing before the player exists; neither does this).
int FireTokensOf(uint64_t guid, TokenList &out) {
if (guid == 0 || Unit::Identity::PlayerObject() == nullptr)
return 0;
return TokensOf(guid, out);
}
uint64_t UnitGuid(const void *unit) {
const auto *block = Game::Read(unit, Offsets::OFF_UNIT_GUID_PTR);
return (block != nullptr) ? Game::Read(block, Offsets::OFF_INSTANCE_BLOCK_GUID) : 0;
}
// --- watching: the registration bit -----------------------------------------
UnitFn_t g_recomputeOriginal = nullptr;
void __fastcall Recompute_h(void *unit) {
g_recomputeOriginal(unit);
if (unit == nullptr)
return;
const uint32_t mask = Game::Read(unit, Offsets::OFF_CGUNIT_SCRIPT_REGISTRATION);
const bool has = (mask & Offsets::UNIT_SCRIPT_REG_TOKENS) != 0;
const bool want = HasTokens(UnitGuid(unit));
if (want && !has)
reinterpret_cast(static_cast(Offsets::FUN_UNIT_SCRIPT_REGISTER))(
unit, Offsets::UNIT_SCRIPT_REG_TOKENS);
else if (!want && has)
reinterpret_cast(
static_cast(Offsets::FUN_UNIT_SCRIPT_UNREGISTER))(
unit, Offsets::UNIT_SCRIPT_REG_TOKENS);
}
const Game::HookAutoRegister _recomputeHook{Offsets::FUN_UNIT_SCRIPT_RECOMPUTE,
reinterpret_cast(&Recompute_h),
reinterpret_cast(&g_recomputeOriginal)};
// --- tokens: the redirected call sites ---------------------------------------
// FUN_UNIT_COMBAT_FEEDBACK's modifier pick, exactly as the engine makes it.
const char *CombatModifier(int amount, uint32_t hitInfo) {
uintptr_t s = Offsets::VAR_STR_EMPTY;
if (amount > 0) {
if (hitInfo & 0x80u)
s = Offsets::VAR_STR_COMBAT_CRITICAL;
else if (hitInfo & 0x4000u)
s = Offsets::VAR_STR_COMBAT_GLANCING;
else if (hitInfo & 0x8000u)
s = Offsets::VAR_STR_COMBAT_CRUSHING;
} else if (hitInfo & 0x20u) {
s = Offsets::VAR_STR_COMBAT_ABSORB;
} else if (hitInfo & 0x800u) {
s = Offsets::VAR_STR_COMBAT_BLOCK;
} else if (hitInfo & 0x40u) {
s = Offsets::VAR_STR_COMBAT_RESIST;
}
return reinterpret_cast(s);
}
void __fastcall CombatFeedbackSite(const uint64_t *guid, const char *action, int amount,
int school, uint32_t hitInfo) {
const uint64_t g = (guid != nullptr) ? *guid : 0;
reinterpret_cast(static_cast(Offsets::FUN_UNIT_COMBAT_FEEDBACK))(
guid, action, amount, school, hitInfo);
TokenList tokens;
const int n = FireTokensOf(g, tokens);
if (n == 0)
return;
const char *modifier = CombatModifier(amount, hitInfo);
const auto fire = reinterpret_cast(static_cast(Offsets::FUN_FIRE_EVENT));
const auto *fmt = reinterpret_cast(Offsets::VAR_STR_UNIT_COMBAT_FORMAT);
for (int i = 0; i < n; ++i)
fire(Offsets::UNIT_EVENT_UNIT_COMBAT, fmt, tokens[i], action, modifier, amount, school);
}
// Direct `E8` / `E9` rel32 instructions in `.text` that reach `target`.
std::vector FindCallSites(uintptr_t target) {
std::vector sites;
auto *p = reinterpret_cast(Offsets::SECTION_TEXT_START);
auto *end = reinterpret_cast(Offsets::SECTION_TEXT_END) - 5;
for (; p <= end; ++p) {
if (*p != 0xE8 && *p != 0xE9)
continue;
int32_t rel;
std::memcpy(&rel, p + 1, sizeof rel);
if (reinterpret_cast(p) + 5 + rel == target)
sites.push_back(p);
}
return sites;
}
void Redirect(const std::vector &sites, const void *to) {
for (uint8_t *site : sites) {
const int32_t rel = static_cast(reinterpret_cast(to) -
(reinterpret_cast(site) + 5));
Common::PatchBytes(site + 1, &rel, sizeof rel);
}
}
// Once per process; every in-game registration runs it, and patched sites no
// longer reach the original address, so a second scan would find none.
bool g_redirected = false;
void Apply() {
if (g_redirected)
return;
g_redirected = true;
const auto broadcast = FindCallSites(Offsets::FUN_UNIT_EVENT_BROADCAST);
const auto combat = FindCallSites(Offsets::FUN_UNIT_COMBAT_FEEDBACK);
if (broadcast.size() != Offsets::UNIT_EVENT_BROADCAST_CALL_SITES ||
combat.size() != Offsets::UNIT_COMBAT_FEEDBACK_CALL_SITES) {
Debug::Log::Printf("TokenEvents: call sites differ (broadcast %u, combat %u); "
"focus/nameplate/mark tokens get no engine unit events",
static_cast(broadcast.size()),
static_cast(combat.size()));
return;
}
Redirect(broadcast, reinterpret_cast(&Broadcast));
Redirect(combat, reinterpret_cast(&CombatFeedbackSite));
}
const Game::ModuleAutoRegister _autoreg{&Apply};
} // namespace
void __fastcall Broadcast(const uint64_t *guid, uint32_t eventId) {
const uint64_t g = (guid != nullptr) ? *guid : 0;
reinterpret_cast(static_cast(Offsets::FUN_UNIT_EVENT_BROADCAST))(
guid, eventId);
TokenList tokens;
const int n = FireTokensOf(g, tokens);
const auto fire = reinterpret_cast(static_cast(Offsets::FUN_FIRE_EVENT));
for (int i = 0; i < n; ++i)
fire(static_cast(eventId), "%s", tokens[i]);
}
void Refresh(uint64_t guid) {
// The engine's watch start / stop walks the player-rooted observer
// registry, NULL out of world — and nameplates drop during world teardown.
if (guid == 0 || !Object::RegistryReady())
return;
if (void *unit = Object::ByGuid(Offsets::TYPEMASK_UNIT, guid, "TokenEvents", 0))
reinterpret_cast(static_cast(Offsets::FUN_UNIT_SCRIPT_RECOMPUTE))(
unit);
}
} // namespace Unit::TokenEvents