// 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 .
// `GetActionCooldown` / `GetActionCount` / `IsConsumableAction` for macro
// slots whose `#showtooltip` / `#show` resolved to an ITEM. A spell
// resolution needs none of this — the engine reads a macro slot's spell from
// its primary-spell cache, which `Macro::ShowTooltip` writes — but the engine
// has no per-macro item field, so the item forms of these three are answered
// here, each with the engine's own helper for the item-by-ID slot case:
//
// - cooldown → `FUN_ITEM_QUERY_COOLDOWN` via `Item::Cooldown::PushCooldown`
// (the same triple `GetContainerItemCooldown` returns);
// - count → `FUN_ACTION_ITEM_COUNT`, the value `UseAction` caches per
// item-by-ID slot;
// - consumable → the rule of the inner `IsConsumableAction` (`0x004E5250`):
// ammo / thrown, or any on-use spell slot with negative
// charges.
//
// Registered in front of the engine globals (last registration wins) and a
// strict superset of them: every other slot tail-calls the engine function
// with the untouched stack.
#include "Game.h"
#include "Offsets.h"
#include "item/Cooldown.h"
#include "item/Record.h"
#include "macro/ShowTooltip.h"
#include
namespace Action::ItemState {
namespace {
using ScriptFn_t = int(__fastcall *)(void *L);
using ItemCount_t = uint32_t(__fastcall *)(uint32_t itemID);
int Engine(uintptr_t fn, void *L) {
return reinterpret_cast(fn)(L);
}
// True (and fills `info`) when stack[1] is a slot whose macro resolved to an item.
bool ItemTarget(void *L, Macro::ShowTooltip::Info *info) {
if (!Game::Lua::IsNumber(L, 1))
return false;
const int slot0 = static_cast(Game::Lua::ToNumber(L, 1)) - 1;
return Macro::ShowTooltip::ForSlot(slot0, info) &&
info->target == Macro::ShowTooltip::Target::Item;
}
int __fastcall Script_GetActionCooldown(void *L) {
Macro::ShowTooltip::Info info;
if (!ItemTarget(L, &info))
return Engine(Offsets::FUN_SCRIPT_GET_ACTION_COOLDOWN, L);
Item::Cooldown::PushCooldown(L, info.itemID);
return 3;
}
int __fastcall Script_GetActionCount(void *L) {
Macro::ShowTooltip::Info info;
if (!ItemTarget(L, &info))
return Engine(Offsets::FUN_SCRIPT_GET_ACTION_COUNT, L);
const uint32_t count = reinterpret_cast(Offsets::FUN_ACTION_ITEM_COUNT)(
static_cast(info.itemID));
Game::Lua::PushNumber(L, static_cast(count));
return 1;
}
bool IsConsumable(int itemID) {
const uint8_t *record = Item::PeekRecord(static_cast(itemID));
if (record == nullptr)
return false;
const uint32_t invType = Game::Read(record, Offsets::OFF_ITEMSTATS_INVENTORY_TYPE);
if (invType == Offsets::INVTYPE_AMMO || invType == Offsets::INVTYPE_THROWN)
return true;
for (int i = 0; i < Offsets::ITEMSTATS_SPELL_SLOT_COUNT; ++i) {
const uint32_t spellID = Game::Read(record, Offsets::OFF_ITEMSTATS_SPELL_ID + i * 4);
const uint32_t trigger = Game::Read(record, Offsets::OFF_ITEMSTATS_SPELL_TRIGGER + i * 4);
const int32_t charges = Game::Read(record, Offsets::OFF_ITEMSTATS_SPELL_CHARGES + i * 4);
if (spellID != 0 && trigger == Offsets::ITEM_SPELLTRIGGER_ON_USE && charges < 0)
return true;
}
return false;
}
int __fastcall Script_IsConsumableAction(void *L) {
Macro::ShowTooltip::Info info;
if (!ItemTarget(L, &info))
return Engine(Offsets::FUN_SCRIPT_IS_CONSUMABLE_ACTION, L);
if (IsConsumable(info.itemID))
Game::Lua::PushNumber(L, 1.0);
else
Game::Lua::PushNil(L);
return 1;
}
void RegisterLuaFunctions() {
Game::Lua::RegisterGlobalFunction("GetActionCooldown", &Script_GetActionCooldown);
Game::Lua::RegisterGlobalFunction("GetActionCount", &Script_GetActionCount);
Game::Lua::RegisterGlobalFunction("IsConsumableAction", &Script_IsConsumableAction);
}
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
} // namespace
} // namespace Action::ItemState