Files
ClassicAPI/src/frame/MotionScriptsWhileDisabled.cpp
T
Brues 165ccf3e9c refactor(lua): share the engine's flag readers as Game::Lua::ToFlag and Game::StringToFlag
Twenty modules each declared their own typedef or wrapper for
FUN_LUA_TO_BOOLEAN_LOOSE (4.3.4's StringToBOOL(L, index, default)) or
FUN_XML_ATTR_TO_BOOL (StringToBOOL(const char *)). Route them all
through one helper each.

frame/Cooldown.cpp had a C++ copy of both that read unknown attribute
text as true; the engine's reader, which 4.3.4's XML loader uses, reads
it as false. SetReverse/SetDrawEdge now also truncate numbers like
every other 1.12 flag method.
2026-10-23 01:15:38 -05:00

160 lines
6.2 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 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 <https://www.gnu.org/licenses/>.
// `button:SetMotionScriptsWhileDisabled(enabled)` /
// `button:GetMotionScriptsWhileDisabled()` and the XML attribute
// `motionScriptsWhileDisabled`.
//
// 1.12's button enter and leave (FUN_BUTTON_ON_ENTER / FUN_BUTTON_ON_LEAVE)
// do nothing for a disabled button but notify their C++ listener, so a
// disabled button never runs OnEnter / OnLeave and cannot show a tooltip.
// 4.3.4's CSimpleButton::OnLayerCursorEnter / Exit are the same functions
// with a per-button flag: a disabled button with the flag set shows its
// companion frame and runs ONLY the OnEnter / OnLeave script - no highlight,
// no label refresh, no drag reset. The co-hooks add that branch. 1.12's
// companion frame (+0xA4) is set by no code the class runs, so the branch
// is only the script, fired as the frame's own enter/leave fires it.
//
// The original runs first and the script after it: a script that enables
// the button would otherwise run the enabled path in the original too, and
// fire OnEnter twice.
//
// 4.3.4 keeps the flag in the button (m_motionScriptsWhileDisabled). 1.12's
// button has no room for it, so it lives here, keyed by the button, and is
// dropped when the frame is destroyed.
#include "Game.h"
#include "Offsets.h"
#include "frame/Destruction.h"
#include "xml/FrameLoad.h"
#include <cstdint>
#include <unordered_set>
namespace Frame::MotionScriptsWhileDisabled {
namespace {
using OnEnter_t = void(__fastcall *)(void *button, void *edx);
using OnLeave_t = void(__fastcall *)(void *button, void *edx, int removed);
using FireScript_t = void(__fastcall *)(void *frame, void *edx, int *slot);
std::unordered_set<const void *> g_enabled;
OnEnter_t g_origOnEnter = nullptr;
OnLeave_t g_origOnLeave = nullptr;
bool RunsWhileDisabled(void *button) {
return Game::Read<int>(button, Offsets::OFF_BUTTON_STATE) == Offsets::BUTTON_STATE_DISABLED &&
g_enabled.count(button) != 0;
}
void Fire(void *button, uint32_t slotOffset) {
int *slot = &Game::Ref<int>(button, slotOffset);
if (*slot != 0)
reinterpret_cast<FireScript_t>(Offsets::FUN_FRAME_FIRE_SCRIPT)(button, nullptr, slot);
}
void __fastcall OnEnter_h(void *button, void *edx) {
const bool fire = RunsWhileDisabled(button);
g_origOnEnter(button, edx);
if (fire)
Fire(button, Offsets::OFF_FRAME_ONENTER_SLOT);
}
void __fastcall OnLeave_h(void *button, void *edx, int removed) {
const bool fire = RunsWhileDisabled(button);
g_origOnLeave(button, edx, removed);
if (fire)
Fire(button, Offsets::OFF_FRAME_ONLEAVE_SLOT);
}
const Game::HookAutoRegister _enterHook{Offsets::FUN_BUTTON_ON_ENTER, reinterpret_cast<void *>(&OnEnter_h),
reinterpret_cast<void **>(&g_origOnEnter)};
const Game::HookAutoRegister _leaveHook{Offsets::FUN_BUTTON_ON_LEAVE, reinterpret_cast<void *>(&OnLeave_h),
reinterpret_cast<void **>(&g_origOnLeave)};
void Set(const void *button, bool enabled) {
if (enabled)
g_enabled.insert(button);
else
g_enabled.erase(button);
}
// 4.3.4 sets the flag only when the node has the attribute (m_buttonFlags
// 0x4), so a template's value stays unless the element names its own.
void OnFrameNode(void *object, const void *node, void * /*status*/) {
const char *value = Xml::Attr(node, "motionScriptsWhileDisabled");
if (value == nullptr || *value == '\0' || !Game::Lua::IsA(object, Offsets::VAR_BUTTON_LUA_TYPE_ID))
return;
Set(object, Game::StringToFlag(value));
}
const Xml::FrameLoad::AutoSubscribe _xmlSub{&OnFrameNode};
void OnFrameDestroyed(void *frame) { g_enabled.erase(frame); }
const Frame::Destruction::AutoSubscribe _destructionSub{&OnFrameDestroyed};
void *ResolveButton(void *L) { return Game::Lua::ResolveTypedObject(L, 1, Offsets::VAR_BUTTON_LUA_TYPE_ID); }
// 4.3.4 reads the flag with StringToBOOL(L, 2, 0): no argument clears it.
int __fastcall Script_SetMotionScriptsWhileDisabled(void *L) {
void *button = ResolveButton(L);
if (button == nullptr)
return 0;
Set(button, Game::Lua::ToFlag(L, 2));
return 0;
}
// 4.3.4 pushes a boolean.
int __fastcall Script_GetMotionScriptsWhileDisabled(void *L) {
void *button = ResolveButton(L);
if (button == nullptr)
return 0;
Game::Lua::PushBool(L, g_enabled.count(button) != 0);
return 1;
}
const Game::Lua::FrameMethodEntry kMethods[] = {
{"SetMotionScriptsWhileDisabled", &Script_SetMotionScriptsWhileDisabled},
{"GetMotionScriptsWhileDisabled", &Script_GetMotionScriptsWhileDisabled},
};
const Game::Doc::Field kSetArgs[] = {
Game::Doc::Opt("enabled", "boolean", "false",
"When true, OnEnter and OnLeave also run while the button is disabled."),
};
const Game::Doc::Field kGetRets[] = {
Game::Doc::Req("enabled", "boolean", "True when OnEnter and OnLeave also run while the button is disabled."),
};
const Game::Doc::Function kSet{"Sets whether OnEnter and OnLeave run while the button is disabled.", kSetArgs, {}};
const Game::Doc::Function kGet{"Returns whether OnEnter and OnLeave run while the button is disabled.", {},
kGetRets};
const Game::Doc::Method kDocs[] = {
{"SetMotionScriptsWhileDisabled", &kSet},
{"GetMotionScriptsWhileDisabled", &kGet},
};
void RegisterLuaFunctions() {
Game::Lua::RegisterFrameMethods(reinterpret_cast<void *>(Offsets::VAR_BUTTON_METHOD_REGISTRY), kMethods, 2,
kDocs, 2);
}
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
} // namespace
} // namespace Frame::MotionScriptsWhileDisabled