// 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 .
// Raid-target marker chat substitutions ({rt1}..{rt8} / {star} / {skull} / ...).
//
// Modern WoW lets players type `{skull}` (etc.) in chat and everyone sees the
// raid-target icon. Vanilla 1.12 has no such substitution. We backport it onto
// the inline-texture (`|T…|t`) renderer: each recognized token is rewritten into
// a `|T` escape that crops the shared raid-target sprite sheet
// `Interface\TargetingFrame\UI-RaidTargetingIcons` to the matching 64×64 cell.
//
// Runs in Chat::Dispatch AFTER Chat::IconFilter::Sanitize. Order is deliberate:
// sanitize first defangs any player-typed raw `|T` spoof, then we add ONLY the
// fixed, known-safe marker escapes — so players get the markers without a path to
// inject arbitrary textures.
//
// Icon→texcoord mapping verified against the client's own UnitPopup.lua
// (RAID_TARGET_1..8): the sheet is 256×256 with 64-pixel cells, marker N at
// column (N-1)%4, row (N-1)/4. So RT1(star) is the top-left cell and RT8(skull)
// is row 1, column 3. The inline renderer's OpenGL v-flip already draws this sheet
// right-side-up (it's the sheet that flip was verified against), so top
#include
namespace Chat::RaidMarkers {
namespace {
struct Token {
const char *name; // lowercase alias, no braces
int marker; // raid-target index 1..8
};
// Aliases per the modern client, all case-insensitive. `{coin}` is a colloquial
// alias for `{circle}` (RT2) and `{x}` for `{cross}` (RT7) — both shown in the
// in-game substitution help.
constexpr Token kTokens[] = {
{"rt1", 1}, {"star", 1},
{"rt2", 2}, {"circle", 2}, {"coin", 2},
{"rt3", 3}, {"diamond", 3},
{"rt4", 4}, {"triangle", 4},
{"rt5", 5}, {"moon", 5},
{"rt6", 6}, {"square", 6},
{"rt7", 7}, {"cross", 7}, {"x", 7},
{"rt8", 8}, {"skull", 8},
};
char LowerAscii(char c) { return (c >= 'A' && c <= 'Z') ? static_cast(c + 32) : c; }
// Case-insensitive match of the n-char token body [s, s+n) against a lowercase
// literal — true only when `lit` is exactly n chars long.
bool EqCI(const char *s, size_t n, const char *lit) {
for (size_t i = 0; i < n; ++i)
if (lit[i] == '\0' || LowerAscii(s[i]) != lit[i])
return false;
return lit[n] == '\0';
}
// Raid-target index (1..8) for the token body [name, name+n), or 0 if unknown.
int MatchMarker(const char *name, size_t n) {
for (const Token &t : kTokens)
if (EqCI(name, n, t.name))
return t.marker;
return 0;
}
bool HasBrace(const char *s) {
for (; *s != '\0'; ++s)
if (*s == '{')
return true;
return false;
}
} // namespace
const char *Substitute(const char *msg, char *buf, size_t bufSize) {
if (msg == nullptr || !HasBrace(msg))
return msg; // common case: forward untouched, no copy
// A token inflates ~28x (a 3-char `{rtN}` -> ~85-byte `|T` markup), so a
// marker-dense message can exceed `buf`. Never DROP message content to fit:
// only expand a token when the expansion AND the whole remaining input (worst
// case copied 1:1 as literal text) still fit. Past that point later tokens
// stay literal `{rtN}`, so the full message text is always preserved — a DLL
// user never sees a shorter line than a non-DLL user, just fewer icons.
const size_t msgLen = std::strlen(msg);
size_t j = 0;
for (size_t i = 0; msg[i] != '\0' && j + 1 < bufSize;) {
if (msg[i] == '{') {
// Scan the token body to the closing brace (bounded — longest alias
// is 8 chars, so a `{` with no nearby `}` is just literal text).
size_t k = i + 1;
while (msg[k] != '\0' && msg[k] != '}' && k - i <= 12)
++k;
if (msg[k] == '}') {
const int marker = MatchMarker(msg + i + 1, k - (i + 1));
if (marker != 0) {
const int col = (marker - 1) % 4;
const int row = (marker - 1) / 4;
const int l = col * 64, r = l + 64, t = row * 64, b = t + 64;
// Emit the pipe-DOUBLED form `||T…||t`. The inline emitter
// renders both `|T` and `||T`, but the vanilla speech-bubble
// text builder (FUN_004b1600) TRUNCATES at a lone `|T` while
// PRESERVING `||` — so the doubled form is what survives into
// the bubble's FontString (which pfUI's bubble reskin copies
// and renders). Anti-spoof Sanitize runs before this, so these
// are the only `||T` openers a player can produce.
char markup[128];
// `:0:0` = auto-size. The inline emitter resolves height/width
// to the target line's font pixel height at draw time, so a
// marker tracks the chat font size (and grows in speech bubbles)
// exactly like retail's ICON_LIST `…Icon_%d:0`. The rest of the
// payload crops the 256x256 sheet to the cell (l,r,t,b).
const int m = std::snprintf(
markup, sizeof markup,
"||TInterface\\TargetingFrame\\UI-RaidTargetingIcons:0:0:0:0:256:256:"
"%d:%d:%d:%d||t",
l, r, t, b);
// Reserve room for the literal tail after this token
// (msg[k+1..]) so the rest of the message always fits.
const size_t tail = msgLen - (k + 1);
if (m > 0 && j + static_cast(m) + tail + 1 <= bufSize) {
std::memcpy(buf + j, markup, static_cast(m));
j += static_cast(m);
i = k + 1; // consume through the closing `}`
continue;
}
// No room for the expansion — fall through and copy the
// literal `{` so the message is never left truncated mid-token.
}
}
}
buf[j++] = msg[i++];
}
buf[j] = '\0';
return buf;
}
} // namespace Chat::RaidMarkers