// 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 .
// `GetMirrorTimerInfo(index)` / `GetMirrorTimerProgress(label)` — modern
// (3.0+) readers for the BREATH / FATIGUE / EXHAUSTION / FEIGNDEATH
// timer state. Vanilla 1.12's engine fires `MIRROR_TIMER_START` /
// `MIRROR_TIMER_PAUSE` / `MIRROR_TIMER_STOP` events with the full
// packet payload, but doesn't cache anything internally — so we hook
// the SMSG handler (`FUN_005E7990`) and build a 3-slot side cache.
//
// The hook peeks the packet via cursor save/restore on the CDataStore
// (offset `+0x14`) before the original consumes the bytes. After
// peeking, we restore the cursor and let the original handler run
// normally, which fires the existing Lua events untouched.
//
// Timer types in vanilla 1.12 (per `FUN_005E7AE0`):
// 0 → "EXHAUSTION" (sliding outside playable bounds; map edges)
// 1 → "BREATH" (underwater drowning)
// 2 → "FEIGNDEATH" (Hunter Feign Death duration)
//
// Modern uses "FATIGUE" instead of "EXHAUSTION" for the same concept;
// we preserve the engine's wording. Addons that hardcode "FATIGUE"
// from backported code need to handle either.
#include "Game.h"
#include "Offsets.h"
#include
#include
#include
namespace Unit::MirrorTimer {
namespace {
using DataStoreReadU32_t = void(__thiscall *)(void *self, uint32_t *out);
using DataStoreReadU8_t = void(__thiscall *)(void *self, uint8_t *out);
using TimerTypeName_t = const char *(__fastcall *)(int type);
using TimerLabel_t = const char *(__fastcall *)(int type, int spellID);
// Windows `GetTickCount` rather than the engine's `FUN_ENGINE_TICK_MS`
// — the engine helper has two internal branches (`GetTickCount` vs a
// high-res counter with a different epoch) selected by a runtime flag,
// and the caller chain runs the result through `__ftol`, suggesting at
// least one path returns via the FPU rather than EAX. Reading those
// bytes as a plain `uint64_t` return picks up garbage. `GetTickCount`
// is single-epoch (ms since boot), monotonic, and unambiguous.
uint32_t NowMs() {
return ::GetTickCount();
}
const char *TypeName(int type) {
auto fn = reinterpret_cast(Offsets::FUN_MIRROR_TIMER_TYPE_NAME);
return fn(type);
}
const char *LabelFor(int type, int spellID) {
auto fn = reinterpret_cast(Offsets::FUN_MIRROR_TIMER_LABEL);
return fn(type, spellID);
}
struct Slot {
bool active = false;
int type = 0;
int initialValue = 0; // value as received in the START packet (ms)
int maxValue = 0;
int scale = 0; // packet rate (positive = decreasing)
bool paused = false;
int spellID = 0; // populated for FEIGNDEATH; 0 otherwise
uint32_t baseMs = 0; // engine ms at which `initialValue` was true
};
Slot g_slots[Offsets::MIRROR_TIMER_SLOT_COUNT];
// Compute the live current value given a slot's snapshot + a current
// engine tick. Matches what the vanilla FrameXML breath/fatigue bars
// do internally: linear interpolation `value = initial + elapsed *
// scale`. Vanilla sends `scale = -1` for depleting timers (breath
// drains 60000 → 0 over 60s = `+ 25000 * -1 = -25000` per 25s
// real-time), so the sign in the formula is `+`, not `-`. Modern's
// docs describe positive scale as depleting; that's a post-vanilla
// convention flip — we follow the wire format the 1.12 server
// actually sends. Returns the snapshot verbatim while paused.
int LiveValue(const Slot &s, uint32_t now) {
if (!s.active)
return 0;
if (s.paused)
return s.initialValue;
const int elapsed = static_cast(now - s.baseMs);
const int value = s.initialValue + elapsed * s.scale;
if (value < 0)
return 0;
if (s.maxValue > 0 && value > s.maxValue)
return s.maxValue;
return value;
}
void OnStart(int type, int value, int maxValue, int scale,
bool paused, int spellID) {
if (type < 0 || type >= Offsets::MIRROR_TIMER_SLOT_COUNT)
return;
Slot &s = g_slots[type];
s.active = true;
s.type = type;
s.initialValue = value;
s.maxValue = maxValue;
s.scale = scale;
s.paused = paused;
s.spellID = spellID;
s.baseMs = NowMs();
}
void OnPause(int type, bool paused) {
if (type < 0 || type >= Offsets::MIRROR_TIMER_SLOT_COUNT)
return;
Slot &s = g_slots[type];
if (!s.active)
return;
if (paused) {
// Freeze: snapshot the live value as the new initial, and
// mark paused so `LiveValue` returns it verbatim.
s.initialValue = LiveValue(s, NowMs());
s.paused = true;
} else if (s.paused) {
// Unpause: reset the base tick so live interpolation
// resumes from the frozen value.
s.paused = false;
s.baseMs = NowMs();
}
}
void OnStop(int type) {
if (type < 0 || type >= Offsets::MIRROR_TIMER_SLOT_COUNT)
return;
g_slots[type] = Slot{};
}
// Peek the packet by reading the fields out of the data store, then
// rewind the cursor so the original handler reads the same bytes.
// `out`-only — caches into our slot table; returns whether the read
// successfully observed the expected fields.
void PeekStartPacket(void *dataStore) {
auto readU32 = reinterpret_cast(
Offsets::FUN_DATASTORE_READ_U32);
auto readU8 = reinterpret_cast(
Offsets::FUN_DATASTORE_READ_U8);
auto cursorPtr = reinterpret_cast(
static_cast(dataStore) + Offsets::OFF_DATASTORE_CURSOR);
const uint32_t saved = *cursorPtr;
uint32_t type = 0, value = 0, maxValue = 0, scale = 0, spellID = 0;
uint8_t paused = 0;
readU32(dataStore, &type);
readU32(dataStore, &value);
readU32(dataStore, &maxValue);
readU32(dataStore, &scale);
readU8(dataStore, &paused);
readU32(dataStore, &spellID);
*cursorPtr = saved;
OnStart(static_cast(type), static_cast(value),
static_cast(maxValue), static_cast(scale),
paused != 0, static_cast(spellID));
}
void PeekPausePacket(void *dataStore) {
auto readU32 = reinterpret_cast(
Offsets::FUN_DATASTORE_READ_U32);
auto readU8 = reinterpret_cast(
Offsets::FUN_DATASTORE_READ_U8);
auto cursorPtr = reinterpret_cast(
static_cast(dataStore) + Offsets::OFF_DATASTORE_CURSOR);
const uint32_t saved = *cursorPtr;
uint32_t type = 0;
uint8_t paused = 0;
readU32(dataStore, &type);
readU8(dataStore, &paused);
*cursorPtr = saved;
OnPause(static_cast(type), paused != 0);
}
void PeekStopPacket(void *dataStore) {
auto readU32 = reinterpret_cast(
Offsets::FUN_DATASTORE_READ_U32);
auto cursorPtr = reinterpret_cast(
static_cast(dataStore) + Offsets::OFF_DATASTORE_CURSOR);
const uint32_t saved = *cursorPtr;
uint32_t type = 0;
readU32(dataStore, &type);
*cursorPtr = saved;
OnStop(static_cast(type));
}
// Slot lookup by type-name string. Used by `GetMirrorTimerProgress`,
// whose caller passes the engine's literal name (e.g. "BREATH").
const Slot *FindSlotByName(const char *name) {
if (name == nullptr)
return nullptr;
for (int i = 0; i < Offsets::MIRROR_TIMER_SLOT_COUNT; ++i) {
const Slot &s = g_slots[i];
if (!s.active)
continue;
const char *engineName = TypeName(s.type);
if (engineName != nullptr && std::strcmp(engineName, name) == 0)
return &s;
}
return nullptr;
}
// `GetMirrorTimerInfo(index)` — returns `(timer, value, maxValue,
// scale, paused, label)` for the timer in slot `index` (1..3), or
// nothing if that slot is empty. Matches modern's 6-tuple shape.
// `value` is the snapshot from the last server packet (not
// live-interpolated) — modern documents the same "possibly outdated"
// caveat. Use `GetMirrorTimerProgress(timer)` for the live value.
int __fastcall Script_GetMirrorTimerInfo(void *L) {
if (!Game::Lua::IsNumber(L, 1)) {
Game::Lua::Error(L, "Usage: GetMirrorTimerInfo(index)");
return 0;
}
const int index1 = static_cast(Game::Lua::ToNumber(L, 1));
const int slotIdx = index1 - 1;
if (slotIdx < 0 || slotIdx >= Offsets::MIRROR_TIMER_SLOT_COUNT)
return 0;
const Slot &s = g_slots[slotIdx];
if (!s.active)
return 0;
const char *name = TypeName(s.type);
const char *label = LabelFor(s.type, s.spellID);
Game::Lua::PushString(L, name != nullptr ? name : "");
Game::Lua::PushNumber(L, static_cast(s.initialValue));
Game::Lua::PushNumber(L, static_cast(s.maxValue));
Game::Lua::PushNumber(L, static_cast(s.scale));
Game::Lua::PushBool(L, s.paused);
Game::Lua::PushString(L, label != nullptr ? label : "");
return 6;
}
// `GetMirrorTimerProgress(label)` — returns the live current value of
// the timer matching `label` (one of the engine's type-name strings:
// "EXHAUSTION", "BREATH", "FEIGNDEATH"), in milliseconds. Returns 0
// when no matching timer is currently active. Computed each call by
// linearly interpolating from the last packet snapshot using the
// engine's millisecond clock — same logic the stock FrameXML bars
// run in their `OnUpdate` handlers.
int __fastcall Script_GetMirrorTimerProgress(void *L) {
if (!Game::Lua::IsString(L, 1)) {
Game::Lua::Error(L, "Usage: GetMirrorTimerProgress(\"timer\")");
return 0;
}
const char *name = Game::Lua::ToString(L, 1);
const Slot *s = FindSlotByName(name);
if (s == nullptr) {
Game::Lua::PushNumber(L, 0);
return 1;
}
Game::Lua::PushNumber(L, static_cast(LiveValue(*s, NowMs())));
return 1;
}
void RegisterLuaFunctions() {
Game::Lua::RegisterGlobalFunction("GetMirrorTimerInfo",
&Script_GetMirrorTimerInfo);
Game::Lua::RegisterGlobalFunction("GetMirrorTimerProgress",
&Script_GetMirrorTimerProgress);
}
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
} // namespace
// `FUN_005E7990` is a true `__fastcall` with 4 real args — `param_1` in
// ECX, the opcode (`param_2`) in EDX, then `param_3` and `param_4` on the
// stack. NOT a thiscall — there's no dummy EDX slot. Declaring it with
// the thiscall shape (extra `void *edx` parameter) shifts every
// subsequent arg by one slot, leaving `dataStore` reading garbage off the
// end of the stack frame and crashing inside `FUN_00418E30`'s
// vtable-fallback path when the cursor bounds check fails.
using SMSGHandler_t = int(__fastcall *)(void *param_1, int opcode,
void *param_3, void *dataStore);
SMSGHandler_t SMSGHandler_o = nullptr;
int __fastcall SMSGHandler_h(void *param_1, int opcode,
void *param_3, void *dataStore) {
if (dataStore != nullptr) {
switch (opcode) {
case Offsets::SMSG_OPCODE_MIRROR_TIMER_START:
PeekStartPacket(dataStore);
break;
case Offsets::SMSG_OPCODE_MIRROR_TIMER_PAUSE:
PeekPausePacket(dataStore);
break;
case Offsets::SMSG_OPCODE_MIRROR_TIMER_STOP:
PeekStopPacket(dataStore);
break;
}
}
return SMSGHandler_o(param_1, opcode, param_3, dataStore);
}
static const Game::HookAutoRegister _hookreg{
Offsets::FUN_SMSG_MIRROR_TIMER_HANDLER,
reinterpret_cast(&SMSGHandler_h),
reinterpret_cast(&SMSGHandler_o)};
} // namespace Unit::MirrorTimer