// 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 .
// `CastSpellNoToggle(name | spellID)` — spam-safe variant of
// `CastSpellByName` that won't toggle off an already-active self-aura
// or auto-repeat. Covers everything the modern `/cast !Name` syntax
// covers in vanilla terms:
//
// - Auto-repeat: Shoot, Auto-Shot, Wand. Engine tracks via the
// `VAR_ACTIVE_AUTO_REPEAT_SPELL` global.
// - Self-aura: shapeshift (Cat/Bear/Travel/Moonkin/Shadowform),
// stance (Battle/Defensive/Berserker), aspect (Hunter), seal
// (Paladin), blessing-on-self, etc. Engine tracks via the unit
// descriptor's aura array; we query through
// `FUN_SPELL_IS_TOGGLE_AURA_ACTIVE` to ask "would casting this
// trigger CMSG_CANCEL_AURA instead of CMSG_CAST_SPELL?".
//
// Either signal causes a no-op; otherwise we delegate to the engine's
// `Script_CastSpellByName` to do the actual cast.
//
// **Why no-op and not re-cast for active forms?** 3.3.5's `!` path
// sends CMSG_CAST_SPELL even when the form is active, with a "fresh-
// cast flag" bit (`spellID | 0x1000000`) in the payload — the server
// then re-applies the form, which breaks roots/snares as a stance-
// change side effect. **Vanilla 1.12 servers reject this** ("You are
// in shapeshift form"). Verified empirically against vmangos with a
// direct CMSG_CAST_SPELL bypass: the server refuses duplicate-aura
// casts. So 1.12's safe behavior is to not send the packet at all
// when active.
#include "Game.h"
#include "Offsets.h"
#include "spell/Arg.h"
#include "spell/Lookup.h"
#include "spell/MacroPrimarySpell.h"
#include
#include
#include
namespace Spell::CastNoToggle {
namespace {
using CastSpellByName_t = int(__fastcall *)(void *L);
using NameToSlot_t = int(__fastcall *)(const char *name, int *outBookType);
using IsToggleAuraActive_t = int(__fastcall *)(unsigned slot, int bookType);
const CastSpellByName_t Script_CastSpellByName_Engine =
reinterpret_cast(Offsets::FUN_SCRIPT_CAST_SPELL_BY_NAME);
int ReadActiveSpellID() {
return *reinterpret_cast(
static_cast(Offsets::VAR_ACTIVE_AUTO_REPEAT_SPELL));
}
const char *LocaleName(int spellID) {
const uint8_t *record = Spell::Lookup::RecordForID(spellID);
if (record == nullptr)
return nullptr;
const int locale = *reinterpret_cast(
static_cast(Offsets::VAR_LOCALE_INDEX));
return *reinterpret_cast(record + Offsets::OFF_SPELL_NAMES + locale * 4);
}
// Case-insensitive name match for the auto-repeat-name gate. Walks
// `userInput` and `spellName` together; on the user side, treats `(`
// and trailing spaces before `(` as end-of-name so `"Shoot(Rank 1)"`
// matches the bare `"Shoot"` we read out of Spell.dbc — mirrors how
// the engine's own name resolver (`FUN_004B3950`) strips the
// parenthetical rank suffix before looking the spell up.
bool NameMatches(const char *userInput, const char *spellName) {
auto lc = [](unsigned char c) -> unsigned char {
return (c >= 'A' && c <= 'Z') ? static_cast(c + 32) : c;
};
if (userInput == nullptr || spellName == nullptr)
return false;
while (*userInput != '\0' && *userInput != '(' && *spellName != '\0') {
if (lc(static_cast(*userInput)) !=
lc(static_cast(*spellName))) {
return false;
}
++userInput;
++spellName;
}
while (*userInput == ' ')
++userInput;
return (*userInput == '\0' || *userInput == '(') && *spellName == '\0';
}
// Resolves `name` to a (slot, bookType) pair via the engine's name
// resolver. Goes through `Spell::CastByID`'s hook so numeric input
// like `"5019"` is accepted in addition to spell names. Returns -1 on
// resolution failure.
int ResolveSlot(const char *name, int *outBookType) {
auto fn = reinterpret_cast(
static_cast(Offsets::FUN_RESOLVE_SPELL_NAME_TO_SLOT));
*outBookType = 0;
return fn(name, outBookType);
}
bool IsAuraToggleActive(int slot, int bookType) {
if (slot < 0)
return false;
auto fn = reinterpret_cast(
static_cast(Offsets::FUN_SPELL_IS_TOGGLE_AURA_ACTIVE));
return fn(static_cast(slot), bookType) != 0;
}
// `CastSpellNoToggle(name | spellID)` — see the file-header block.
// Returns a boolean indicating whether the requested spell is, at
// function exit, in the "active" state the caller asked for: true
// when we either started the cast or determined the spell was already
// active; false when input was invalid or the cast didn't take effect.
int __fastcall Script_CastSpellNoToggle(void *L) {
char nameBuf[128];
int requestedID = 0;
const int argType = Game::Lua::Type(L, 1);
if (argType == Game::Lua::TYPE_NUMBER) {
requestedID = static_cast(Game::Lua::ToNumber(L, 1));
if (requestedID <= 0) {
Game::Lua::PushBool(L, false);
return 1;
}
const char *name = LocaleName(requestedID);
if (name == nullptr || *name == '\0') {
Game::Lua::PushBool(L, false);
return 1;
}
std::snprintf(nameBuf, sizeof(nameBuf), "%s", name);
} else if (argType == Game::Lua::TYPE_STRING) {
const char *s = Game::Lua::ToString(L, 1);
if (s == nullptr || *s == '\0') {
Game::Lua::PushBool(L, false);
return 1;
}
// Copy off Lua's string heap — the SetTop+PushString below
// could shift it and invalidate `s`.
std::snprintf(nameBuf, sizeof(nameBuf), "%s", s);
} else {
Game::Lua::Error(L, "Usage: CastSpellNoToggle(\"name\" | spellID)");
return 0;
}
// Check 1 — auto-repeat (Shoot / Auto-Shot / Wand). Cheap global
// read; the spell-cast subsystem owns this state separately from
// the aura system.
const int activeAutoRepeat = ReadActiveSpellID();
if (activeAutoRepeat != 0) {
const bool match = (requestedID > 0)
? (activeAutoRepeat == requestedID)
: NameMatches(nameBuf, LocaleName(activeAutoRepeat));
if (match) {
Game::Lua::PushBool(L, true); // already auto-repeating — spam-safe
return 1;
}
// A different auto-repeat is active. Don't disrupt it — silently
// refuse.
Game::Lua::PushBool(L, false);
return 1;
}
// Check 2 — self-aura (shapeshift / stance / aspect / blessing /
// seal / etc.). Resolve name → slot, then ask the engine.
int bookType = 0;
const int slot = ResolveSlot(nameBuf, &bookType);
if (IsAuraToggleActive(slot, bookType)) {
Game::Lua::PushBool(L, true); // already active — no-op
return 1;
}
// Neither toggle would fire — safe to cast. Delegate to the engine
// with a fresh, one-arg stack so `lua_toboolean(L, 2)` (the
// `onSelf` flag inside Script_CastSpellByName) sees nil → false.
Game::Lua::SetTop(L, 0);
Game::Lua::PushString(L, nameBuf);
Script_CastSpellByName_Engine(L);
// Reflect the post-cast state: true if either toggle is now active.
const bool autoRepeatNow = ReadActiveSpellID() != 0;
const bool auraNow = !autoRepeatNow && slot >= 0
? IsAuraToggleActive(slot, bookType)
: false;
Game::Lua::PushBool(L, autoRepeatNow || auraNow);
return 1;
}
void RegisterLuaFunctions() {
Game::Lua::RegisterGlobalFunction("CastSpellNoToggle",
&Script_CastSpellNoToggle);
}
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
// ---------------------------------------------------------------------------
// Macro parser pattern
//
// Tags macros containing `CastSpellNoToggle("Name")` with the
// resolved spellID, so `IsAutoRepeatAction(macroSlot)` reports
// correctly and action-bar UIs (pfUI etc.) highlight the slot for
// auto-repeat spells. `Spell::MacroPrimarySpell` owns the parser
// hook and the line walk; we just declare our `(prefix, extractor)`.
// ---------------------------------------------------------------------------
int ExtractCastSpellNoToggleArg(const char *p, const char *end) {
while (p < end && (*p == ' ' || *p == '\t'))
++p;
if (p >= end || *p != '"')
return 0;
++p;
const char *q = p;
while (q < end && *q != '"')
++q;
if (q >= end)
return 0;
const size_t n = static_cast(q - p);
if (n == 0 || n >= 128)
return 0;
char name[128];
std::memcpy(name, p, n);
name[n] = '\0';
return Spell::Arg::NameToSpellID(name);
}
const Spell::MacroPrimarySpell::PatternAutoRegister _patreg{
"CastSpellNoToggle(", &ExtractCastSpellNoToggleArg};
} // namespace
} // namespace Spell::CastNoToggle