// 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 .
// The `autoStand`, `autoDismount` and `autoUnshift` cvars — 4.3.4's
// stand / dismount / leave-form before a cast.
//
// 4.3.4 splits it in two. The caster check (CGUnit_C::CheckCasterState-
// ForSpell's mount, stand and form rungs) refuses only when the matching
// `CGUnit_C::CanAutoStand/CanAutoDismount/CanAutoUnshift` is false; then,
// with every rung passed, the cast path (Spell_C.cpp, before the send)
// stands, dismounts and cancels the form in that order. A form refusal
// for SPELL_FAILED_ONLY_SHAPESHIFT is never auto-handled. Spell_C_Is-
// UsableAction honors CanAutoUnshift the same way, so the button stays lit.
//
// 1.12's caster check (FUN_CHECK_CASTER_STATE_FOR_SPELL) has the same three
// rungs and refuses unconditionally. We mirror the split on them:
// - the mount rung's descriptor read and the stand rung's GetStandState
// call become calls that report "not mounted" / "standing" when the
// auto action is allowed, noting it as pending;
// - both calls to the form check (caster check and FUN_SPELL_IS_USABLE)
// pass a SPELL_FAILED_NOT_SHAPESHIFT refusal when CanAutoUnshift holds;
// - the cast request's one call of the caster check keeps the pending
// actions when it passes, and the send of the pending cast runs them.
// 1.12's request checks the caster before it arms the targets, so the
// actions wait for the send, as in 4.3.4: a cast with no target, or a
// targeting cursor the player cancels, does not stand or dismount.
// The actions are the engine's own: the stand setter, and CMSG_CANCEL_AURA
// for the mount / form aura (1.12 has no CMSG_CANCEL_MOUNT_AURA; cancelling
// the mount aura is how its own UI dismounts). The server applies the
// cancel / stand before the cast packet that follows it.
//
// autoUnshift and autoDismount also cover interaction, as in 4.3.4:
// - NPC right-click: 4.3.4's CGPlayer_C::HandleOnRightClick cancels a form
// without SHAPESHIFT_FORM_FLAG_CAN_INTERACT in place of
// ERR_CANT_INTERACT_SHAPESHIFTED, before its range check, so we do the
// same at 1.12's gate. Neither client gates an NPC on the mount. The
// hover cursor asks CanInteractNow, whose form test 4.3.4 also passes
// on CanAutoUnshift, so the NPC's service cursor shows while shifted.
// - game objects: for an object with no Lock row, 4.3.4's CanUseNow lets
// the mount pass when CanAutoDismount holds and the form when
// CanAutoUnshift holds. The 1.12 use check is also the hover cursor's
// query, so it only passes. Then TypeBase::Use, on its no-spell branch
// only, dismounts (unless the object is usable mounted, the mailbox) and
// cancels the form before CMSG_GAMEOBJ_USE. 4.3.4 does that with no
// cvar test, the gate having run; we keep the cvars, so with them off
// an object with a Lock row is still used as 1.12 uses it. 1.12's
// mailbox and text types replace that use slot, which 4.3.4 does not,
// so they get the same step. A locked object (a chest, a vein) opens by
// a spell whose cast passes the caster check above.
//
// 4.3.4's mount-in-form step (the cast path's and CGItem_C::Use's
// CancelShapeshiftForMount, for a SPELL_AURA_MOUNTED spell when
// !CanCurrentFormMount) needs no site of its own: 482 of 1.12's 484 mount
// spells carry SPELL_ATTR_NOT_SHAPESHIFT, so the form check refuses them
// with SPELL_FAILED_NOT_SHAPESHIFT and the form rung above unshifts; an item
// reaches the same rung through its cast.
//
// The remaining 4.3.4 sites:
// - loot (autoStand): CGUnit_C / CGCorpse_C::OnRightClick stand up in
// place of ERR_LOOT_NOTSTANDING. 1.12's two loot steps read the stand
// state the same way, so the read stands the player and reports 0.
// - loot (autoDismount): 4.3.4's unit right-click has no mount test on
// its loot step, and LootUnit dismounts before CMSG_LOOT. 1.12's loot
// step skips a mounted player, so its read passes, and 1.12's LootUnit
// dismounts at the same point. A corpse is not looted mounted in either.
// - item use (autoUnshift): CGItem_C::Use leaves the form in place of
// ERR_NO_ITEMS_WHILE_SHAPESHIFTED, after its toggle test (an item
// whose aura is up only turns it off). 1.12 tests the toggle after the
// form, so its refusal passes and the form is left at the next test,
// the bind-on-use one, where 4.3.4 has it.
// - attack (autoDismount): CanAttackNow (the attack cursor, the right-click
// attack) and VerifyAttackIconPressed (ERR_ATTACK_MOUNTED) pass a mount
// when CanAutoDismount holds; CombatModeEnter then dismounts in melee
// reach, else shows ERR_OUT_OF_RANGE and does not attack. 1.12 inlines
// the CanAttackNow mount test in four places and has the resolver's
// refusal; each read passes, and StartAttack, past all its tests, runs
// the CombatModeEnter step. The reach is Combat::Swing::InMeleeRange,
// 4.3.4's GetMeleeRange formula on the engine's own constants.
// - taxi: the taxi map's open stands, dismounts and leaves the form when
// it has more than one node. 4.3.4 does that with no cvar; here each
// action needs its cvar, so with them off the map opens as in 1.12.
#include "Common.h"
#include "Game.h"
#include "Offsets.h"
#include "combat/Swing.h"
#include "cvar/Factory.h"
#include "dbc/Lookup.h"
#include "spell/Cancel.h"
#include "unit/Identity.h"
#include
#include
namespace Spell::AutoPrepare {
namespace {
using CheckCasterState_t = char(__fastcall *)(void *caster, void *edx,
const uint8_t *record, void *item);
using CheckForm_t = char(__fastcall *)(void *unit, void *edx,
const uint8_t *record, int *reason);
using GetStandState_t = int(__fastcall *)(const void *unit, void *edx);
using SendStandState_t = void(__fastcall *)(const void *player, void *edx, uint32_t state);
using IsShapeShifted_t = char(__fastcall *)(const void *unit);
using UsableMounted_t = bool(__fastcall *)(const void *descriptorSlot);
using ObjectUse_t = char(__fastcall *)(void *handler);
using DisplayError_t = void(__cdecl *)(int id, ...);
using TriggerTutorial_t = void(__fastcall *)(int id, int arg);
using CanAutoInteract_t = bool(__fastcall *)(const void *player);
// Continuation addresses the naked thunks load from memory.
uintptr_t g_itemUseFormPassed = Offsets::ITEM_USE_FORM_PASSED;
uintptr_t g_startAttackReturn = Offsets::START_ATTACK_RETURN;
constexpr int kGetStandStateSlot = 0xA4 / 4;
// The instructions the sites replace, by name: the mount reads
// (`mov dst,[base+0x1FC]`) and the GetStandState calls (`call [base+0xA4]`).
constexpr uint8_t kMovEaxEcxMount[6] = {0x8B, 0x81, 0xFC, 0x01, 0x00, 0x00};
constexpr uint8_t kMovEaxEdxMount[6] = {0x8B, 0x82, 0xFC, 0x01, 0x00, 0x00};
constexpr uint8_t kMovEcxEaxMount[6] = {0x8B, 0x88, 0xFC, 0x01, 0x00, 0x00};
constexpr uint8_t kMovEdxEaxMount[6] = {0x8B, 0x90, 0xFC, 0x01, 0x00, 0x00};
constexpr uint8_t kMovEdxEcxMount[6] = {0x8B, 0x91, 0xFC, 0x01, 0x00, 0x00};
constexpr uint8_t kCallEaxStandState[6] = {0xFF, 0x90, 0xA4, 0x00, 0x00, 0x00};
constexpr uint8_t kCallEdxStandState[6] = {0xFF, 0x92, 0xA4, 0x00, 0x00, 0x00};
// Common::ReplaceWithCall / RedirectCall / RedirectSlot, taking the hook
// as a typed function.
template
bool Replace(uintptr_t site, const uint8_t (&original)[N], Fn *target) {
return Common::ReplaceWithCall(site, original, N, reinterpret_cast(target));
}
template bool Redirect(uintptr_t site, uintptr_t expected, Fn *target) {
return Common::RedirectCall(site, expected, reinterpret_cast(target));
}
template bool RedirectSlot(uintptr_t slot, uintptr_t expected, Fn *target) {
return Common::RedirectSlot(slot, expected, reinterpret_cast(target));
}
CVar::Factory::Handle g_autoStand = nullptr;
CVar::Factory::Handle g_autoDismount = nullptr;
CVar::Factory::Handle g_autoUnshift = nullptr;
// Set by the rungs during one caster check, run when it passes.
struct Pending {
bool stand;
bool dismount;
bool unshift;
};
Pending g_pending{};
const uint8_t *Fields(const void *unit) {
return *reinterpret_cast(
static_cast(unit) + Offsets::OFF_UNIT_DESCRIPTOR);
}
bool IsActivePlayer(const void *unit) {
return unit != nullptr && unit == Unit::Identity::PlayerObject();
}
bool OnTaxi(const void *unit) {
return (Game::Read(Fields(unit), Offsets::OFF_UNIT_FIELD_FLAGS) &
Offsets::UNIT_FLAG_TAXI_FLIGHT) != 0;
}
int Form(const void *unit) {
return (Game::Read(Fields(unit), Offsets::OFF_UNIT_FIELD_BYTES_1) >> 16) & 0xFF;
}
// The unit's SpellShapeshiftForm row's flags; a form with no row reads as 0.
uint32_t FormFlags(const void *unit) {
const uint8_t *form = DBC::Record(Offsets::VAR_SPELL_SHAPESHIFT_FORM_RECORDS,
Offsets::VAR_SPELL_SHAPESHIFT_FORM_COUNT,
static_cast(Form(unit)));
return form != nullptr ? Game::Read(form, Offsets::OFF_SPELL_SHAPESHIFT_FORM_FLAGS)
: 0;
}
bool Enabled(CVar::Factory::Handle cvar) { return CVar::Factory::GetInt(cvar) != 0; }
// 4.3.4 CGUnit_C::CanAutoStand.
bool CanAutoStand(const void *unit) { return IsActivePlayer(unit) && Enabled(g_autoStand); }
// 4.3.4 CGUnit_C::CanAutoDismount (no flying in 1.12, so no
// autoDismountFlying leg).
bool CanAutoDismount(const void *unit) {
return IsActivePlayer(unit) && !OnTaxi(unit) && Enabled(g_autoDismount);
}
// 4.3.4 CGUnit_C::CanAutoUnshift.
bool CanAutoUnshift(const void *unit) {
return IsActivePlayer(unit) && !OnTaxi(unit) && Enabled(g_autoUnshift) &&
(FormFlags(unit) & Offsets::SHAPESHIFT_FORM_FLAG_NO_AUTO_UNSHIFT) == 0;
}
int StandState(const void *unit) {
auto getStandState =
(*reinterpret_cast(unit))[kGetStandStateSlot];
return getStandState(unit, nullptr);
}
int MountDisplay(const void *unit) {
return Game::Read(Fields(unit), Offsets::OFF_UNIT_FIELD_MOUNTDISPLAYID);
}
// 4.3.4's pairing at every site: the state holds and its CanAuto* allows
// the action.
bool AutoStands(const void *unit) { return StandState(unit) != 0 && CanAutoStand(unit); }
bool AutoDismounts(const void *unit) { return MountDisplay(unit) > 0 && CanAutoDismount(unit); }
// The engine's actions: the stand setter, and CMSG_CANCEL_AURA for the
// mount / form aura.
void Stand(const void *player) {
reinterpret_cast(Offsets::FUN_PLAYER_SEND_STAND_STATE)(player, nullptr, 0);
}
void Dismount() { Spell::Cancel::CancelPlayerAura(Offsets::SPELL_AURA_MOUNTED); }
void CancelForm(const void *unit) {
Spell::Cancel::CancelPlayerAura(Offsets::SPELL_AURA_MOD_SHAPESHIFT, Form(unit));
}
char IsShapeShifted(const void *unit) {
return reinterpret_cast(Offsets::FUN_UNIT_IS_SHAPESHIFTED)(unit);
}
// The gates' test after IsShapeShifted: a form with no row, or one
// without the interact flag.
bool FormBlocksInteraction(const void *unit) {
return (FormFlags(unit) & Offsets::SHAPESHIFT_FORM_FLAG_CAN_INTERACT) == 0;
}
// True when the gate would refuse and autoUnshift takes the form off instead.
bool UnshiftsForInteraction(const void *player) {
return IsShapeShifted(player) && FormBlocksInteraction(player) && CanAutoUnshift(player);
}
// The NPC right-click's IsShapeShifted: leaves the form and reports "not
// shifted", as 4.3.4's HandleOnRightClick does.
char __fastcall IsShapeShiftedForTalk(const void *player) {
if (UnshiftsForInteraction(player)) {
CancelForm(player);
return 0;
}
return IsShapeShifted(player);
}
// The game-object use check's and CanInteractNow's IsShapeShifted (4.3.4's
// CanUseNow / CanInteractNow): the same verdict, nothing done. Both are
// hover-cursor queries, so the cursor shows the service while shifted.
char __fastcall IsShapeShiftedForQuery(const void *player) {
return UnshiftsForInteraction(player) ? 0 : IsShapeShifted(player);
}
// The mount reads of the gates 4.3.4 passes on CanAutoDismount (an object
// use, a loot, an attack): the mount display, or 0 when the action that
// follows dismounts first.
int __fastcall MountDisplayForAction(const void *player) {
return AutoDismounts(player) ? 0 : MountDisplay(player);
}
// Stands in for `mov ecx,[eax+0x1FC]` at SITE_GAMEOBJECT_CAN_USE_MOUNT_READ,
// player in EDI. EAX and EDX are dead there; ECX takes the display.
__declspec(naked) void UseMountReadThunk() {
__asm {
mov ecx, edi
call MountDisplayForAction
mov ecx, eax
ret
}
}
// Stand in for a `mov eax,[reg+0x1FC]` mount read, the player in ESI or EDI;
// EAX takes the display, every other register is kept.
__declspec(naked) void MountReadEsiThunk() {
__asm {
push ecx
push edx
mov ecx, esi
call MountDisplayForAction
pop edx
pop ecx
ret
}
}
__declspec(naked) void MountReadEdiThunk() {
__asm {
push ecx
push edx
mov ecx, edi
call MountDisplayForAction
pop edx
pop ecx
ret
}
}
// Stands in for `mov edx,[eax+0x1FC]` at SITE_ATTACK_RESOLVER_CAN_ATTACK_-
// MOUNT_READ, player in ECX, which the can-attack call after it still uses.
__declspec(naked) void ResolverMountReadThunk() {
__asm {
push ecx
call MountDisplayForAction
mov edx, eax
pop ecx
ret
}
}
// The loot steps' GetStandState call (ECX = the player): stands the player
// up and reports 0 when autoStand allows, as 4.3.4's OnRightClick does.
int __fastcall StandStateForLoot(const void *player) {
if (AutoStands(player)) {
Stand(player);
return 0;
}
return StandState(player);
}
// LootUnit before CMSG_LOOT: 4.3.4's dismount.
void __fastcall DismountForLoot(const void *player) {
if (AutoDismounts(player))
Dismount();
}
// Stands in for `push 0; xor dl,dl; mov cl,1` at SITE_LOOT_UNIT_SEND, player
// in ESI: the dismount, then the replaced code with its push kept under the
// return address.
__declspec(naked) void LootSendThunk() {
__asm {
mov ecx, esi
call DismountForLoot
pop eax
push 0
push eax
xor dl, dl
mov cl, 1
ret
}
}
// Set at the item use's form refusal when autoUnshift lets the use go on;
// the bind-on-use test runs the unshift, the toggle cancel drops it. Every
// path past the form test reaches one of the two.
bool g_itemUnshift = false;
// The item use's form refusal: lets the use go on when autoUnshift allows.
// The form is left later, at 4.3.4's point: past the toggle test, so an
// item whose aura is up is only turned off, as 4.3.4 does it.
bool __fastcall UnshiftForItem(const void *player) {
g_itemUnshift = CanAutoUnshift(player);
return g_itemUnshift;
}
// Stands in for `push 0x15E` at SITE_ITEM_USE_FORM_REFUSAL, player in ESI:
// continues at ITEM_USE_FORM_PASSED, or pushes the error for the `jmp` to
// the error tail that follows.
__declspec(naked) void ItemFormRefusalThunk() {
__asm {
mov ecx, esi
call UnshiftForItem
test al, al
jz refuse
mov eax, g_itemUseFormPassed
mov [esp], eax
ret
refuse:
pop eax
push 0x15E
jmp eax
}
}
// The toggle test's cancel: the use turns the aura off and casts nothing,
// so the form stays.
void __fastcall ItemToggleCancel(int spellId) {
g_itemUnshift = false;
reinterpret_cast(Offsets::FUN_CANCEL_AURA_SEND)(spellId);
}
// Before the bind-on-use test: 4.3.4 CGItem_C::Use's form cancel.
void UnshiftBeforeItemBind() {
if (!g_itemUnshift)
return;
g_itemUnshift = false;
if (const void *player = Unit::Identity::PlayerObject())
CancelForm(player);
}
// Stands in for `mov ecx,[ebp-8]; cmp dword [ecx+0x194],3` at
// SITE_ITEM_USE_BIND_TEST: the unshift, then the replaced code, whose flags
// the `jne` after the return reads. The call keeps EBX, ESI, EDI and EBP.
__declspec(naked) void ItemBindTestThunk() {
__asm {
call UnshiftBeforeItemBind
mov ecx, [ebp - 8]
cmp dword ptr [ecx + 0x194], 3
ret
}
}
// StartAttack past its tests: 4.3.4 CombatModeEnter's dismount, in melee
// reach only; out of reach it does not attack, and shows ERR_OUT_OF_RANGE
// unless click-to-move is walking the player there (4.3.4's `silent`).
bool __fastcall PrepareAttack(const void *player, void *target) {
if (!AutoDismounts(player))
return true;
if (!Combat::Swing::InMeleeRange(const_cast(player), target)) {
if (!reinterpret_cast(Offsets::FUN_PLAYER_CAN_AUTO_INTERACT)(player))
reinterpret_cast(Offsets::FUN_GAMEUI_DISPLAY_ERROR)(
Offsets::GAME_ERROR_OUT_OF_RANGE);
return false;
}
Dismount();
return true;
}
// Stands in for `mov eax,[esi+0xC8C]` at SITE_START_ATTACK_PASSED, player in
// ESI, target in EDI: on a refusal, returns from StartAttack.
__declspec(naked) void StartAttackPassedThunk() {
__asm {
mov ecx, esi
mov edx, edi
call PrepareAttack
test al, al
jz abort
mov eax, [esi + 0xC8C]
ret
abort:
mov eax, g_startAttackReturn
mov [esp], eax
ret
}
}
// The taxi map opener's tutorial call, its last step: then 4.3.4's
// stand, dismount and form cancel for a map with more than one node.
void __fastcall TaxiMapOpenedTutorial(int id, int arg) {
reinterpret_cast(Offsets::FUN_TRIGGER_TUTORIAL)(id, arg);
if (Game::Read(static_cast(Offsets::VAR_TAXI_MAP_NODE_COUNT)) <= 1)
return;
const void *player = Unit::Identity::PlayerObject();
if (player == nullptr)
return;
if (AutoStands(player))
Stand(player);
if (AutoDismounts(player))
Dismount();
// 4.3.4's IsCancelShapeshiftAtFlightMaster adds forms with flag 0x800,
// which no 1.12 SpellShapeshiftForm row carries.
if (IsShapeShifted(player) && CanAutoUnshift(player))
CancelForm(player);
}
// 4.3.4 TypeBase::Use's step before CMSG_GAMEOBJ_USE: dismount unless the
// object is usable mounted, then leave a form that cannot interact.
void __fastcall PrepareObjectUse(const void *handler) {
const void *player = Unit::Identity::PlayerObject();
if (player == nullptr)
return;
const uint8_t *object =
Game::Read(handler, Offsets::OFF_GAMEOBJECT_HANDLER_OBJECT);
if (AutoDismounts(player) &&
!reinterpret_cast(Offsets::FUN_GAMEOBJECT_USABLE_MOUNTED)(
object + Offsets::OFF_GAMEOBJECT_DESCRIPTOR))
Dismount();
if (UnshiftsForInteraction(player))
CancelForm(player);
}
// Stands in for `mov edi,0x7FF9E4` at SITE_GAMEOBJECT_USE_SEND, handler at
// [EBP-4]. EAX, ECX and EDX are dead there.
__declspec(naked) void UseSendThunk() {
__asm {
mov ecx, [ebp - 4]
call PrepareObjectUse
mov edi, 0x7FF9E4
ret
}
}
// The mailbox and text use slots: the same step, then the type's own use.
char __fastcall MailboxUse(void *handler) {
PrepareObjectUse(handler);
return reinterpret_cast(Offsets::FUN_GAMEOBJECT_MAILBOX_USE)(handler);
}
char __fastcall TextUse(void *handler) {
PrepareObjectUse(handler);
return reinterpret_cast(Offsets::FUN_GAMEOBJECT_TEXT_USE)(handler);
}
// The mount rung's read: the mount display, or 0 when the cast will
// dismount first.
int __fastcall MountDisplayForCast(const void *caster) {
if (AutoDismounts(caster)) {
g_pending.dismount = true;
return 0;
}
return MountDisplay(caster);
}
// Stands in for `mov edx,[ecx+0x1FC]` at SITE_CASTER_STATE_MOUNT_READ. The
// caster is in EDI; EAX holds the spell's Attributes, which the stand rung
// reads next, so only EDX may change.
__declspec(naked) void MountReadThunk() {
__asm {
push eax
mov ecx, edi
call MountDisplayForCast
mov edx, eax
pop eax
ret
}
}
// Stands in for `call [edx+0xA4]` (GetStandState) at
// SITE_CASTER_STATE_STAND_CALL, caster in ECX: the stand state, or 0 when
// the cast will stand first.
int __fastcall StandStateForCast(const void *caster) {
if (AutoStands(caster)) {
g_pending.stand = true;
return 0;
}
return StandState(caster);
}
char CheckForm(void *unit, const uint8_t *record, int *reason) {
return reinterpret_cast(Offsets::FUN_CHECK_SPELL_SHAPESHIFT_FORM)(
unit, nullptr, record, reason);
}
// The caster check's form call.
char __fastcall CheckFormForCast(void *unit, void *, const uint8_t *record, int *reason) {
if (CheckForm(unit, record, reason))
return 1;
if (*reason != Offsets::SPELL_FAILED_NOT_SHAPESHIFT || !CanAutoUnshift(unit))
return 0;
g_pending.unshift = true;
return 1;
}
// FUN_SPELL_IS_USABLE's form call: the same verdict, nothing pending.
char __fastcall CheckFormForUsable(void *unit, void *, const uint8_t *record, int *reason) {
if (CheckForm(unit, record, reason))
return 1;
return *reason == Offsets::SPELL_FAILED_NOT_SHAPESHIFT && CanAutoUnshift(unit);
}
// The cast request's call of the caster check: a passed check keeps what its
// rungs noted for the send; a refused one drops it.
char __fastcall CheckCasterState(void *caster, void *, const uint8_t *record, void *item) {
g_pending = {};
const char passed = reinterpret_cast(
Offsets::FUN_CHECK_CASTER_STATE_FOR_SPELL)(caster, nullptr, record, item);
if (!passed)
g_pending = {};
return passed;
}
// The pending cast's send (4.3.4's Spell_C_SendPendingCast): stand, dismount,
// then leave the form, in that order, before the packet. Here, past the
// target arm, a cast that finds no target ("You have no target") or whose
// targeting cursor is cancelled has not dismounted. The rungs note only for
// the active player; each action runs only while its state still holds, as
// the cursor can be up while the player stands, dismounts or leaves the form.
void __fastcall SendCast(void *pendingCast, uint8_t flag) {
const Pending pending = g_pending;
g_pending = {};
if (const void *player = Unit::Identity::PlayerObject()) {
if (pending.stand && StandState(player) != 0)
Stand(player);
if (pending.dismount && MountDisplay(player) > 0)
Dismount();
if (pending.unshift && Form(player) != 0)
CancelForm(player);
}
reinterpret_cast(Offsets::FUN_SPELL_SEND_CAST)(
pendingCast, flag);
}
void Register() {
// 4.3.4 defaults all three to 1. Here they default to 0, 1.12's own
// behavior: autoUnshift drops a form the player may want to keep
// (Shadowform on a Renew, Bear Form on a heal), so it is opted into.
g_autoStand = CVar::Factory::Register("autoStand", "Automatically stand when needed", Offsets::CVAR_CATEGORY_GAME, "0");
g_autoDismount = CVar::Factory::Register("autoDismount", "Automatically dismount when needed", Offsets::CVAR_CATEGORY_GAME, "0");
g_autoUnshift = CVar::Factory::Register("autoUnshift", "Automatically leave shapeshift form when needed", Offsets::CVAR_CATEGORY_GAME, "0");
// Interaction. The use check passes the mount and form only together
// with the step at every use; without it the object would be used still
// mounted or shifted.
Redirect(Offsets::CALL_NPC_INTERACT_IS_SHAPESHIFTED, Offsets::FUN_UNIT_IS_SHAPESHIFTED,
&IsShapeShiftedForTalk);
static const uint8_t kUseSend[5] = {0xBF, 0xE4, 0xF9, 0x7F, 0x00};
if (Replace(Offsets::SITE_GAMEOBJECT_USE_SEND, kUseSend, &UseSendThunk) &&
RedirectSlot(Offsets::SLOT_GAMEOBJECT_MAILBOX_USE, Offsets::FUN_GAMEOBJECT_MAILBOX_USE,
&MailboxUse) &&
RedirectSlot(Offsets::SLOT_GAMEOBJECT_TEXT_USE, Offsets::FUN_GAMEOBJECT_TEXT_USE,
&TextUse)) {
Replace(Offsets::SITE_GAMEOBJECT_CAN_USE_MOUNT_READ, kMovEcxEaxMount, &UseMountReadThunk);
Redirect(Offsets::CALL_GAMEOBJECT_CAN_USE_IS_SHAPESHIFTED,
Offsets::FUN_UNIT_IS_SHAPESHIFTED, &IsShapeShiftedForQuery);
}
Redirect(Offsets::CALL_UNIT_CAN_INTERACT_NOW_IS_SHAPESHIFTED,
Offsets::FUN_UNIT_IS_SHAPESHIFTED, &IsShapeShiftedForQuery);
// Loot. The loot step passes the mount only together with LootUnit's
// dismount.
Replace(Offsets::SITE_UNIT_LOOT_STAND_CALL, kCallEaxStandState, &StandStateForLoot);
Replace(Offsets::SITE_CORPSE_LOOT_STAND_CALL, kCallEdxStandState, &StandStateForLoot);
static const uint8_t kLootSend[6] = {0x6A, 0x00, 0x32, 0xD2, 0xB1, 0x01};
if (Replace(Offsets::SITE_LOOT_UNIT_SEND, kLootSend, &LootSendThunk))
Replace(Offsets::SITE_UNIT_LOOT_MOUNT_READ, kMovEaxEcxMount, &MountReadEsiThunk);
// Item use. The refusal passes only together with the unshift after the
// toggle test; without it the item would be used still shifted.
static const uint8_t kItemBindTest[10] = {0x8B, 0x4D, 0xF8, 0x83, 0xB9,
0x94, 0x01, 0x00, 0x00, 0x03};
static const uint8_t kItemFormRefusal[5] = {0x68, 0x5E, 0x01, 0x00, 0x00};
if (Redirect(Offsets::CALL_ITEM_USE_TOGGLE_CANCEL, Offsets::FUN_CANCEL_AURA_SEND,
&ItemToggleCancel) &&
Replace(Offsets::SITE_ITEM_USE_BIND_TEST, kItemBindTest, &ItemBindTestThunk))
Replace(Offsets::SITE_ITEM_USE_FORM_REFUSAL, kItemFormRefusal, &ItemFormRefusalThunk);
// Attack. The mount reads pass only together with StartAttack's
// dismount; without it the attack would start mounted.
static const uint8_t kStartAttackPassed[6] = {0x8B, 0x86, 0x8C, 0x0C, 0x00, 0x00};
if (Replace(Offsets::SITE_START_ATTACK_PASSED, kStartAttackPassed, &StartAttackPassedThunk)) {
Replace(Offsets::SITE_START_ATTACK_MOUNT_READ, kMovEaxEcxMount, &MountReadEsiThunk);
Replace(Offsets::SITE_RIGHT_CLICK_ATTACK_MOUNT_READ, kMovEaxEdxMount, &MountReadEsiThunk);
Replace(Offsets::SITE_CURSOR_ATTACK_MOUNT_READ, kMovEaxEdxMount, &MountReadEdiThunk);
Replace(Offsets::SITE_ATTACK_RESOLVER_MOUNT_READ, kMovEaxEcxMount, &MountReadEdiThunk);
Replace(Offsets::SITE_ATTACK_RESOLVER_CAN_ATTACK_MOUNT_READ, kMovEdxEaxMount,
&ResolverMountReadThunk);
}
// Taxi.
Redirect(Offsets::CALL_TAXI_MAP_OPENED_TUTORIAL, Offsets::FUN_TRIGGER_TUTORIAL,
&TaxiMapOpenedTutorial);
// The rungs only note what to do; the caster-check call keeps it and
// every send runs it. Without all of them a passed rung would send the
// cast still mounted or seated. A send with nothing noted is the
// original send, so sites redirected before a miss are harmless.
for (const uintptr_t site :
{Offsets::CALL_TARGET_ARM_SEND_CAST, Offsets::CALL_TARGET_ARM_SEND_CAST_GUID,
Offsets::CALL_BIND_TARGET_OBJECT_SEND_CAST, Offsets::CALL_BIND_TARGET_LOCATION_SEND_CAST,
Offsets::CALL_BIND_TARGET_TRADE_SLOT_SEND_CAST}) {
if (!Redirect(site, Offsets::FUN_SPELL_SEND_CAST, &SendCast))
return;
}
if (!Redirect(Offsets::CALL_TRY_CAST_CHECK_CASTER_STATE,
Offsets::FUN_CHECK_CASTER_STATE_FOR_SPELL, &CheckCasterState))
return;
Replace(Offsets::SITE_CASTER_STATE_MOUNT_READ, kMovEdxEcxMount, &MountReadThunk);
Replace(Offsets::SITE_CASTER_STATE_STAND_CALL, kCallEdxStandState, &StandStateForCast);
if (Redirect(Offsets::CALL_CASTER_STATE_SHAPESHIFT_FORM,
Offsets::FUN_CHECK_SPELL_SHAPESHIFT_FORM, &CheckFormForCast))
Redirect(Offsets::CALL_SPELL_USABLE_SHAPESHIFT_FORM,
Offsets::FUN_CHECK_SPELL_SHAPESHIFT_FORM, &CheckFormForUsable);
}
const Game::ModuleAutoRegister _autoreg{&Register};
} // namespace
} // namespace Spell::AutoPrepare