// 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 TargetNearest / TargetDirection functions 1.12 lacks, following 4.3.4 // (decomp GameUI.cpp / GameUI_Scripts.cpp): // // TargetNearest([reverse]) TargetDirectionEnemy(facing [, angle]) // TargetNearestEnemyPlayer([reverse]) TargetDirectionFriend(facing [, angle]) // TargetNearestFriendPlayer([reverse]) TargetDirectionFinished() // // TargetNearest*: 4.3.4 runs all seven through one routine, // TargetNearestEnemy(reverse, type). 1.12 has that routine whole — // FUN_TARGET_NEAREST_CYCLE with the same snapshot, timers, ranges, sort and // predicate (see Offsets.h) — and its natives call it with modes 1..4. The // three missing types become three more predicate modes: a co-hook on // FUN_TARGET_CANDIDATE_VALID answers them (4.3.4's UnitMatchesTargetType // cases 0 / 2 / 4) and passes every engine mode through. The cycle state is // the engine's, shared with the natives, as 4.3.4's is. // // TargetDirection*: 4.3.4's CGGameUI::TargetDirection, which 1.12 lacks, built // on 1.12's own pieces — the world frame's GetScreenCoordinates, the camera's // forward vector, the predicate, and the tab search's range / creature-type / // visibility tests. `facing` is a direction on screen relative to the camera // (0 = ahead, pi/2 = right); the start point is the current target when it is // on screen, else the player. A hit sets the target and locks further calls // until TargetDirectionFinished, or until the locked unit leaves (4.3.4's // BreakTarget: out of the object table unless a group member or pet, or // unselectable) or the player logs out (LeaveWorld). #include "Game.h" #include "Offsets.h" #include "cvar/Factory.h" #include "object/Resolve.h" #include "target/Nearest.h" #include "tick/WorldTick.h" #include "unit/Identity.h" #include "unit/Position.h" #include #include #include namespace Target::Nearest { bool NotTabTarget(void *unit) { using CreatureType_t = int(__fastcall *)(void *unit); const int type = reinterpret_cast(Offsets::FUN_UNIT_CREATURE_TYPE)(unit); if (type < 0 || type > Game::Read(Offsets::VAR_CREATURETYPE_COUNT)) return false; const auto *const *records = Game::Read(Offsets::VAR_CREATURETYPE_RECORDS); const uint8_t *rec = records != nullptr ? records[type] : nullptr; return rec != nullptr && (Game::Read(rec, Offsets::OFF_CREATURETYPE_FLAGS) & Offsets::CREATURETYPE_FLAG_NOT_TAB_TARGET) != 0; } namespace { using Cycle_t = void(__fastcall *)(int reverse, int mode); using Valid_t = int(__fastcall *)(void *player, void *cand, int mode); using SetSelection_t = void(__stdcall *)(uint32_t guidLo, uint32_t guidHi); using ScreenCoords_t = bool(__thiscall *)(void *worldFrame, const float *world, float *screen); using Transform_t = float *(__fastcall *)(float *out, const float *v, const float *m); using Forward_t = void(__thiscall *)(void *camera, float *out); using Visible_t = bool(__fastcall *)(void *worldObject); using GroupMember_t = int(__fastcall *)(const uint64_t *guid); // 4.3.4's minimum direction cone (22.5°); `angle` can only widen it. constexpr float kMinConeAngle = 0.39269909f; constexpr float kTwoPi = 6.2831855f; Valid_t g_validOriginal = nullptr; bool IsPlayerObject(void *unit) { return Game::Read(unit, Offsets::OFF_CGOBJECT_TYPE_ID) == Offsets::OBJECT_TYPE_PLAYER; } // 4.3.4's UnitMatchesTargetType for the types 1.12 lacks. The searcher is // never its own candidate (4.3.4's enumeration skips it); the engine's modes // already exclude it where it matters. int __fastcall Valid_h(void *player, void *cand, int mode) { switch (mode) { case Offsets::TARGET_MODE_ANY: return cand != player; case Offsets::TARGET_MODE_ENEMY_PLAYER: return cand != player && IsPlayerObject(cand) && g_validOriginal(player, cand, Offsets::TARGET_MODE_ENEMY); case Offsets::TARGET_MODE_FRIEND_PLAYER: return cand != player && IsPlayerObject(cand) && g_validOriginal(player, cand, Offsets::TARGET_MODE_FRIEND); default: return g_validOriginal(player, cand, mode); } } const Game::HookAutoRegister _validHook{Offsets::FUN_TARGET_CANDIDATE_VALID, reinterpret_cast(&Valid_h), reinterpret_cast(&g_validOriginal)}; void Cycle(void *L, int mode) { reinterpret_cast(Offsets::FUN_TARGET_NEAREST_CYCLE)(Game::Lua::ToFlag(L, 1), mode); } void SetSelection(uint64_t guid) { reinterpret_cast(Offsets::FUN_SET_SELECTION_BY_GUID)( static_cast(guid), static_cast(guid >> 32)); } uint64_t CurrentSelection() { return Game::Read(Offsets::VAR_CURRENT_SELECTION_GUID_LO); } // --- TargetDirection ------------------------------------------------------ // 4.3.4's m_directionalTarget. uint64_t g_directional = 0; float CVarFloat(uintptr_t slot) { return CVar::Factory::GetFloat(Game::Read(slot)); } // C2Vector::NormalizeSafe. void NormalizeSafe(float &x, float &y) { const float len = std::sqrt(x * x + y * y); if (len > 0.0f) { x /= len; y /= len; } } // CGWorldFrame::GetScreenCoordinates with 4.3.4's depth: x / y and the result // from the engine's projection, z the view-projected depth it computes on the // way. Like 4.3.4's, the point is filled even when the result is false. bool ScreenCoords(void *worldFrame, const float *world, float *screen) { screen[0] = screen[1] = screen[2] = 0.0f; const bool onScreen = reinterpret_cast( Offsets::FUN_WORLDFRAME_GET_SCREEN_COORDS)(worldFrame, world, screen); const void *camera = Game::Read(worldFrame, Offsets::OFF_GAME_STATE_CAMERA_PTR); const float *camPos = Game::Ptr(camera, Offsets::OFF_CAMERA_POSITION); const float rel[4] = {world[0] - camPos[0], world[1] - camPos[1], world[2] - camPos[2], 0.0f}; float out[4]; reinterpret_cast(Offsets::FUN_C44_TRANSFORM)( out, rel, Game::Ptr(worldFrame, Offsets::OFF_WORLDFRAME_VIEW_PROJECTION)); screen[2] = out[2]; return onScreen; } // 4.3.4's TargetDirectionData. struct DirectionData { void *worldFrame; void *unit; void *origin; float originPosition[2]; float facing[2]; float originScreen[3]; float screenDirection[2]; int mode; uint64_t bestGuid; float cosHalfAngle; bool bestInCone; float bestDistance; float playerPosition[3]; float maxDistanceSq; }; // 4.3.4's TargetDirectionProc. void DirectionProc(DirectionData *data, uint64_t guid) { void *unit = Object::ByGuid(Offsets::TYPEMASK_UNIT, guid, nullptr, 0); if (unit == nullptr || unit == data->unit || unit == data->origin || !reinterpret_cast(Offsets::FUN_TARGET_CANDIDATE_VALID)(data->unit, unit, data->mode)) return; float position[3]; if (!Unit::Position::Read(unit, position)) return; if (Game::DistanceSq(position, data->playerPosition) > data->maxDistanceSq) return; if (NotTabTarget(unit) || !reinterpret_cast(Offsets::FUN_WORLD_OBJECT_VISIBLE)( Game::Read(unit, Offsets::OFF_CGOBJECT_WORLD_OBJECT))) return; float screen[3]; if (!ScreenCoords(data->worldFrame, position, screen)) return; bool inCone = true; float dirX = position[0] - data->originPosition[0]; float dirY = position[1] - data->originPosition[1]; NormalizeSafe(dirX, dirY); const float dot = data->facing[1] * dirY + data->facing[0] * dirX; float sdX = screen[0] - data->originScreen[0]; float sdY = screen[1] - data->originScreen[1]; NormalizeSafe(sdX, sdY); if (data->screenDirection[1] * sdY + data->screenDirection[0] * sdX < 0.0f) return; if (data->cosHalfAngle <= dot) { if (!data->bestInCone) data->bestDistance = FLT_MAX; } else { if (data->bestInCone) return; inCone = false; } const float ex = screen[0] - data->originScreen[0]; const float ey = screen[1] - data->originScreen[1]; const float ez = screen[2] - data->originScreen[2]; float distance = ez * ez + ey * ey + ex * ex; if (!inCone) distance = distance * ((1.0f - dot) * (1.0f - dot)); if (distance > data->bestDistance) return; data->bestDistance = distance; data->bestGuid = guid; data->bestInCone = inCone; } // 4.3.4's CGGameUI::TargetDirection. void TargetDirection(float facing, float angle, int mode) { if (g_directional != 0) return; if (!Object::RegistryReady()) return; void *unit = const_cast(Unit::Identity::PlayerObject()); if (unit == nullptr) return; void *worldFrame = Game::Read(Offsets::VAR_GAME_STATE_PTR); if (worldFrame == nullptr) return; void *camera = Game::Read(worldFrame, Offsets::OFF_GAME_STATE_CAMERA_PTR); if (camera == nullptr) return; void *origin = Object::ByGuid(Offsets::TYPEMASK_UNIT, CurrentSelection(), nullptr, 0); if (origin == nullptr) origin = unit; float position[3]; float screen[3]; if (!Unit::Position::Read(origin, position) || !ScreenCoords(worldFrame, position, screen)) { origin = unit; if (!Unit::Position::Read(unit, position)) return; ScreenCoords(worldFrame, position, screen); } // Camera forward × C33Matrix::Rotation(2pi - facing), row vector. float forward[3]; auto *vtable = Game::Read(camera, 0); reinterpret_cast(vtable[Offsets::VTBL_CAMERA_FORWARD / sizeof(uintptr_t)])(camera, forward); const float c = std::cos(kTwoPi - facing); const float s = std::sin(kTwoPi - facing); DirectionData data{}; data.worldFrame = worldFrame; data.unit = unit; data.origin = origin; data.originPosition[0] = position[0]; data.originPosition[1] = position[1]; data.facing[0] = forward[0] * c - forward[1] * s; data.facing[1] = forward[0] * s + forward[1] * c; data.originScreen[0] = screen[0]; data.originScreen[1] = screen[1]; data.originScreen[2] = screen[2]; data.screenDirection[0] = std::sin(facing); data.screenDirection[1] = std::cos(facing); data.mode = mode; data.bestGuid = 0; data.cosHalfAngle = std::cos((angle > kMinConeAngle ? angle : kMinConeAngle) * 0.5f); data.bestInCone = false; data.bestDistance = FLT_MAX; if (!Unit::Position::Read(unit, data.playerPosition)) return; // 4.3.4's 41 yd; 1.12's tab search reads it from targetNearestDistance. const float range = CVarFloat(Offsets::VAR_CVAR_TARGET_NEAREST_DISTANCE); data.maxDistanceSq = range * range; Object::ForEachVisible([&](uint64_t guid) { DirectionProc(&data, guid); return true; }); if (data.bestGuid != 0) { SetSelection(data.bestGuid); g_directional = data.bestGuid; } } // 4.3.4 clears the lock in BreakTarget; these are the 1.12 cases it has. void OnWorldTick() { if (g_directional == 0) return; void *unit = Object::ByGuid(Offsets::TYPEMASK_UNIT, g_directional, nullptr, 0); if (unit == nullptr) { const uint64_t guid = g_directional; if (!reinterpret_cast(Offsets::FUN_UNIT_IS_GROUP_MEMBER_OR_PET)(&guid)) g_directional = 0; return; } const auto *fields = Game::Read(unit, Offsets::OFF_CGUNIT_OBJECT_FIELDS); if (fields != nullptr && (Game::Read(fields, Offsets::OFF_UNIT_FIELD_FLAGS) & Offsets::UNIT_FLAG_NOT_SELECTABLE) != 0) g_directional = 0; } const Tick::WorldTick::AutoSubscribe _tickSub{&OnWorldTick}; // LeaveWorld: the world→glue return. void ClearOnLogout() { g_directional = 0; } const Game::GlueModuleAutoRegister _clearOnLogout{&ClearOnLogout}; int DirectionScript(void *L, int mode, const char *usage) { if (!Game::Lua::IsNumber(L, 1)) { Game::Lua::Error(L, usage); return 0; } const float facing = static_cast(Game::Lua::ToNumber(L, 1)); const float angle = Game::Lua::IsNumber(L, 2) ? static_cast(Game::Lua::ToNumber(L, 2)) : 0.0f; TargetDirection(facing, angle, mode); return 0; } // --- Lua entry points ------------------------------------------------------- int __fastcall Script_TargetNearest(void *L) { Cycle(L, Offsets::TARGET_MODE_ANY); return 0; } int __fastcall Script_TargetNearestEnemyPlayer(void *L) { Cycle(L, Offsets::TARGET_MODE_ENEMY_PLAYER); return 0; } int __fastcall Script_TargetNearestFriendPlayer(void *L) { Cycle(L, Offsets::TARGET_MODE_FRIEND_PLAYER); return 0; } int __fastcall Script_TargetDirectionEnemy(void *L) { return DirectionScript(L, Offsets::TARGET_MODE_ENEMY, "Usage: TargetDirectionEnemy(facing)"); } int __fastcall Script_TargetDirectionFriend(void *L) { return DirectionScript(L, Offsets::TARGET_MODE_FRIEND, "Usage: TargetDirectionFriend(facing)"); } int __fastcall Script_TargetDirectionFinished(void * /*L*/) { g_directional = 0; return 0; } // --- Documentation ---------------------------------------------------------- const Game::Doc::Field kReverseArgs[] = { Game::Doc::Opt("reverse", "bool", "false", "Cycles the other way."), }; const Game::Doc::Function kTargetNearest{ "Targets the next nearest unit of any kind, cycling on each call like TargetNearestEnemy.", kReverseArgs, {}, "TargetGlobals"}; const Game::Doc::Function kTargetNearestEnemyPlayer{ "Targets the next nearest enemy player, cycling on each call.", kReverseArgs, {}, "TargetGlobals"}; const Game::Doc::Function kTargetNearestFriendPlayer{ "Targets the next nearest friendly player, cycling on each call.", kReverseArgs, {}, "TargetGlobals"}; const Game::Doc::Field kDirectionArgs[] = { Game::Doc::Req("facing", "number", "A direction on the screen in radians, clockwise: 0 up, pi/2 right."), Game::Doc::Opt("coneAngle", "number", nullptr, "The cone width in radians; it is never narrower than 22.5 degrees."), }; const Game::Doc::Function kTargetDirectionEnemy{ "Targets the enemy in a direction on the screen from your target, or from you.", kDirectionArgs, {}, "TargetGlobals"}; const Game::Doc::Function kTargetDirectionFriend{ "Targets the friendly unit in a direction on the screen from your target, or from you.", kDirectionArgs, {}, "TargetGlobals"}; const Game::Doc::Function kTargetDirectionFinished{ "Ends the lock that a TargetDirectionEnemy or TargetDirectionFriend hit sets, so the next " "call can target again.", {}, {}, "TargetGlobals"}; void RegisterLuaFunctions() { Game::Lua::RegisterGlobalFunction("TargetNearest", &Script_TargetNearest, &kTargetNearest); Game::Lua::RegisterGlobalFunction("TargetNearestEnemyPlayer", &Script_TargetNearestEnemyPlayer, &kTargetNearestEnemyPlayer); Game::Lua::RegisterGlobalFunction("TargetNearestFriendPlayer", &Script_TargetNearestFriendPlayer, &kTargetNearestFriendPlayer); Game::Lua::RegisterGlobalFunction("TargetDirectionEnemy", &Script_TargetDirectionEnemy, &kTargetDirectionEnemy); Game::Lua::RegisterGlobalFunction("TargetDirectionFriend", &Script_TargetDirectionFriend, &kTargetDirectionFriend); Game::Lua::RegisterGlobalFunction("TargetDirectionFinished", &Script_TargetDirectionFinished, &kTargetDirectionFinished); } const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; } // namespace } // namespace Target::Nearest