Mobile step 6: client-side auto hunt with AUTO button

Engine-free AutoHunt state machine (search/engage/loot/return/paused) driven
from the game loop through the existing manual paths: move target, target
packet, normal attack, quickslot skills, item pick-up and belt potions.
player.SetAutoHunt/GetAutoHuntState/SetAutoHuntOption with autohunt.cfg;
AUTO button on the combat wheel (tap toggles, long press opens settings).
Tests: ava2.auto_hunt, extended ava2.touch_game; 54/54.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
shenlei
2026-10-12 22:05:15 +09:00
co-authored by Claude Opus 5.5
parent ed2c185135
commit 64d25e3571
13 changed files with 1085 additions and 2 deletions
+4
View File
@@ -76,6 +76,7 @@ if(AVA2_EMBED_PYTHON)
src/scripting/python_chr.cpp
src/scripting/python_app.cpp
src/game/player_settings.cpp
src/game/auto_hunt.cpp
src/scripting/python_wndmgr.cpp
src/scripting/python_gameplay_modules.cpp
src/scripting/python_ime.cpp
@@ -229,6 +230,9 @@ if(BUILD_TESTING AND NOT ANDROID)
add_test(NAME ava2.pack_assets COMMAND "${Python3_EXECUTABLE}" "${CMAKE_SOURCE_DIR}/tests/pack_assets_test.py")
endif()
add_executable(auto_hunt_test tests/auto_hunt_test.cpp src/game/auto_hunt.cpp)
target_include_directories(auto_hunt_test PRIVATE src/game)
add_test(NAME ava2.auto_hunt COMMAND auto_hunt_test)
add_executable(server_clock_test tests/server_clock_test.cpp)
target_include_directories(server_clock_test PRIVATE src src/network)
add_test(NAME ava2.server_clock COMMAND server_clock_test)
+2 -2
View File
@@ -122,7 +122,7 @@ Python 更新(原版脚本 + mobile HUD)
| 攻击键外圈 / 底部 | 技能圈、药水栏、翻页 | 原版快捷栏(4 页) | 技能圈对应技能格,底部栏对应道具格 |
| 攻击键附近 | 骑乘、拾取、锁定目标 | `player.PickCloseItem`;骑乘/锁定接口待核对 | 小按钮 |
| 屏幕空白处 | 转镜头、双指缩放 | `app.RotateCamera`;镜头距离接口待核对 | C++ 手势识别 |
| 可选 | 自动战斗 | 原版没有 | 客户端新功能,最后做 |
| 技能圈旁 | 自动狩猎(AUTO 键) | 原版没有 | 客户端新功能:轻点开关、长按设置;已完成(第 6 步) |
注意事项:
@@ -144,6 +144,6 @@ Python 更新(原版脚本 + mobile HUD)
3. `input/`:触摸分流、虚拟摇杆、攻击键、镜头手势——可在手机上移动和战斗。
4. `mobile/`:手机 HUD(状态面板、技能圈和快捷栏、右上角入口、小地图、左侧按钮)。
5. 界面缩放和安全区域收尾。
6. 自动战斗等新增功能;iOS 打包与 `app_loop` 拆分。
6. 自动战斗等新增功能(自动狩猎已完成,见 PORT-PLAN);iOS 打包与 `app_loop` 拆分。
第 3、4 步大部分可在 macOS 上开发(鼠标模拟单指,触控板测双指);多指同时操作和性能需要真机验证。
+41
View File
@@ -1337,3 +1337,44 @@ real cutout insets); a window size change at runtime (split screen,
foldable) keeps the logical size chosen at start; no in-game UI size option
yet (only `--ui-height` / env); original PC windows (inventory etc.) are
not rearranged for 600 px height.
### 2026-10-12 Mobile step 6 — auto hunt
Client-only feature (the original client has none; not taken from 40250).
It only drives paths that manual play already uses: walk-to (move target),
target packet, the normal attack, quickslot skills, item pick-up and
quickslot potions. Nothing new goes on the wire.
- `src/game/auto_hunt.{h,cpp}`: engine-free state machine
(off / search / engage / loot / return / paused). Hunts the nearest living
mob within `radius` of an anchor point (metin stones optional), loots own
or unowned drops before the next mob, walks back to the anchor when the
area is empty, and gives up on a target whose distance stops shrinking for
8 s (ignored for 30 s). Joystick / attack key / mouse movement pause it;
it resumes 3 s after the last input and re-anchors where the player
stopped. HP / SP potions (belt slots 1 / 2, quickslot 24 / 25) are checked
in every state with a 1 s gap. Death turns it off.
- `ProcessAutoHunt()` (python_gameplay_modules.cpp, called from the game loop
before `ProcessPlayerAttack`) builds the input from NetworkActorManager
(mobs bType 0/2), `CPythonItem::GetGroundItems()` (new read accessor) and
the combat wheel's current skill page, skipping skills on cooldown, active
toggles, 121-123 and guild skills.
- Python: `player.SetAutoHunt / IsAutoHunt / GetAutoHuntState /
SetAutoHuntOption / GetAutoHuntOption`; options (radius, skills, pickup,
stones, hp_percent, sp_percent, hp_slot, sp_slot) persist in
`autohunt.cfg` next to metin2.cfg.
- `ui_mobile_autohunt.py`: AUTO button on the combat wheel (tap toggles,
green while on with the state under it; 0.6 s long press opens the settings
board with range / skills / pick-up / stones / potion thresholds).
Verified: `ava2.auto_hunt` (targeting, range stop, skill gap, busy, loot
before next mob, area and stone filter, return, chase watchdog, pause /
resume / re-anchor, potions, death), `ava2.touch_game` (AUTO is UI under the
finger, tap on/off, engage + target VID + move target, stop in reach,
joystick pauses, long press opens settings, option persistence), 54/54
desktop tests, HUD screenshot shows AUTO above Ride.
Outstanding: not run on a device or against the server (ownership timing,
pick-up refusals, attack speed); straight-line walking only, the stuck
watchdog is the only obstacle handling; party loot rules ignored (only own /
unowned drops); no desktop hotkey (F9 is taken by the preview mode);
English labels, no locale strings; does not run in `--preview-data`.
+2
View File
@@ -2101,6 +2101,8 @@ const auto profileActiveStart = std::chrono::steady_clock::now();
static bool wasMoving = false;
static uint32_t lastMoveSent = 0;
float moveYaw = 0.0f;
// Auto hunt (mobile step 6) steers and presses attack like a player would.
ava2::ProcessAutoHunt();
// Attack input first (NEW_Attack ends walking); no movement while an attack plays.
if (ava2::ProcessPlayerAttack(orbit_camera.GetYaw(), dt, wasMoving)) wasMoving = false;
const bool attacking = ava2::IsPlayerAttacking();
+269
View File
@@ -0,0 +1,269 @@
// Client-side auto hunt state machine; see auto_hunt.h.
#include "auto_hunt.h"
#include <cmath>
#include <iterator>
namespace ava2 {
namespace {
float Distance(float ax, float az, float bx, float bz) {
const float dx = ax - bx, dz = az - bz;
return std::sqrt(dx * dx + dz * dz);
}
} // namespace
const char* AutoHuntStateName(AutoHuntState state) {
switch (state) {
case AutoHuntState::Off: return "off";
case AutoHuntState::Search: return "search";
case AutoHuntState::Engage: return "engage";
case AutoHuntState::Loot: return "loot";
case AutoHuntState::Return: return "return";
case AutoHuntState::Paused: return "paused";
}
return "off";
}
void AutoHunt::Start(float x, float z) {
m_anchorX = x;
m_anchorZ = z;
m_target = 0;
m_moving = false;
m_ignoreUntil.clear();
m_state = AutoHuntState::Search;
m_stateSince = 0;
m_lastManual = 0;
}
void AutoHunt::Stop() {
m_state = AutoHuntState::Off;
m_target = 0;
m_moving = false;
}
void AutoHunt::Enter(AutoHuntState state, uint32_t now) {
m_state = state;
m_stateSince = now;
m_lastProgress = now;
m_bestDistance = 1e30f;
}
bool AutoHunt::Ignored(uint32_t vid, uint32_t now) const {
auto it = m_ignoreUntil.find(vid);
return it != m_ignoreUntil.end() && now < it->second;
}
const AutoHuntMob* AutoHunt::FindMob(const AutoHuntInput& in, uint32_t vid) const {
for (const auto& mob : in.mobs)
if (mob.vid == vid) return &mob;
return nullptr;
}
// Nearest living mob inside the hunt area.
const AutoHuntMob* AutoHunt::PickMob(const AutoHuntInput& in) const {
const AutoHuntMob* best = nullptr;
float bestDistance = 0;
for (const auto& mob : in.mobs) {
if (mob.stone && !options.attackStones) continue;
if (Ignored(mob.vid, in.now)) continue;
if (Distance(mob.x, mob.z, m_anchorX, m_anchorZ) > options.radius) continue;
const float d = Distance(mob.x, mob.z, in.x, in.z);
if (!best || d < bestDistance) { best = &mob; bestDistance = d; }
}
return best;
}
const AutoHuntItem* AutoHunt::PickItem(const AutoHuntInput& in) const {
if (!options.pickUp) return nullptr;
const AutoHuntItem* best = nullptr;
float bestDistance = 0;
for (const auto& item : in.items) {
if (Ignored(item.vid, in.now)) continue;
if (Distance(item.x, item.z, m_anchorX, m_anchorZ) > options.radius) continue;
const float d = Distance(item.x, item.z, in.x, in.z);
if (!best || d < bestDistance) { best = &item; bestDistance = d; }
}
return best;
}
void AutoHunt::GoTo(AutoHuntOutput& out, float x, float z, uint32_t now) {
if (m_moving && now - m_lastPath < kRepathGap) return;
out.move = AutoHuntOutput::Move::Go;
out.moveX = x;
out.moveZ = z;
m_moving = true;
m_lastPath = now;
}
void AutoHunt::Halt(AutoHuntOutput& out) {
if (!m_moving) return;
out.move = AutoHuntOutput::Move::Stop;
m_moving = false;
}
void AutoHunt::Potions(const AutoHuntInput& in, AutoHuntOutput& out) {
if (in.now - m_lastPotion < kPotionGap && m_lastPotion != 0) return;
if (options.hpPercent > 0 && in.hpPercent < options.hpPercent && in.hpSlotUsable)
out.useQuickSlot = options.hpSlot;
else if (options.spPercent > 0 && in.spPercent < options.spPercent && in.spSlotUsable)
out.useQuickSlot = options.spSlot;
if (out.useQuickSlot >= 0) m_lastPotion = in.now;
}
AutoHuntOutput AutoHunt::Update(const AutoHuntInput& in) {
AutoHuntOutput out;
if (m_state == AutoHuntState::Off) return out;
const uint32_t now = in.now;
if (in.dead) {
Halt(out);
Stop();
out.stopped = true;
return out;
}
Potions(in, out);
// Manual input wins; hunting resumes where the player left off.
if (in.manual) {
m_lastManual = now;
if (m_state != AutoHuntState::Paused) {
Enter(AutoHuntState::Paused, now);
m_moving = false; // the player's own input owns the actor now
m_target = 0;
}
return out;
}
if (m_state == AutoHuntState::Paused) {
if (now - m_lastManual < kResumeDelay) return out;
m_anchorX = in.x;
m_anchorZ = in.z;
Enter(AutoHuntState::Search, now);
}
if (!in.canAct) return out;
for (auto it = m_ignoreUntil.begin(); it != m_ignoreUntil.end();)
it = now >= it->second ? m_ignoreUntil.erase(it) : std::next(it);
// Progress watchdog for anything we walk to: give up when the distance stops shrinking.
auto chase = [&](float distance, uint32_t vid) {
if (distance < m_bestDistance - 50.0f) {
m_bestDistance = distance;
m_lastProgress = now;
} else if (now - m_lastProgress > kChaseTimeout) {
if (vid) m_ignoreUntil[vid] = now + kIgnoreTime;
return false;
}
return true;
};
if (m_state == AutoHuntState::Engage) {
const AutoHuntMob* mob = FindMob(in, m_target);
if (!mob || (mob->stone && !options.attackStones)) {
// Killed (or gone): collect the drop before the next target.
m_target = 0;
const AutoHuntItem* item = PickItem(in);
if (item) {
m_target = item->vid;
Enter(AutoHuntState::Loot, now);
} else {
Enter(AutoHuntState::Search, now);
}
} else if (Distance(mob->x, mob->z, m_anchorX, m_anchorZ) > options.radius * 1.5f) {
m_target = 0;
Enter(AutoHuntState::Return, now);
} else {
const float distance = Distance(mob->x, mob->z, in.x, in.z);
if (distance <= in.attackRange + mob->radius) {
Halt(out);
out.attack = mob->vid;
m_lastProgress = now;
if (options.useSkills && !in.busy && !in.readySkillSlots.empty() &&
(m_lastSkill == 0 || now - m_lastSkill >= kSkillGap)) {
out.skillSlot = in.readySkillSlots.front();
m_lastSkill = now;
}
} else if (chase(distance, mob->vid)) {
GoTo(out, mob->x, mob->z, now);
} else {
m_target = 0;
Halt(out);
Enter(AutoHuntState::Search, now);
}
return out;
}
}
if (m_state == AutoHuntState::Loot) {
const AutoHuntItem* item = nullptr;
for (const auto& candidate : in.items)
if (candidate.vid == m_target) item = &candidate;
if (!item || Ignored(m_target, now)) {
m_target = 0;
Enter(AutoHuntState::Search, now);
} else {
const float distance = Distance(item->x, item->z, in.x, in.z);
if (distance <= kPickRange) {
Halt(out);
if (m_lastPick == 0 || now - m_lastPick >= kPickGap) {
out.pick = item->vid;
m_lastPick = now;
}
// Inventory full / someone else's drop: the server keeps refusing.
if (now - m_stateSince > 5000) m_ignoreUntil[item->vid] = now + kIgnoreTime;
} else if (chase(distance, item->vid)) {
GoTo(out, item->x, item->z, now);
} else {
m_target = 0;
Halt(out);
Enter(AutoHuntState::Search, now);
}
return out;
}
}
if (m_state == AutoHuntState::Return) {
if (!PickMob(in)) {
const float distance = Distance(m_anchorX, m_anchorZ, in.x, in.z);
if (distance <= kPickRange) {
Halt(out);
Enter(AutoHuntState::Search, now);
} else if (chase(distance, 0)) {
GoTo(out, m_anchorX, m_anchorZ, now);
return out;
} else {
// Cannot get back (blocked): hunt from here instead.
Halt(out);
m_anchorX = in.x;
m_anchorZ = in.z;
Enter(AutoHuntState::Search, now);
}
} else {
Enter(AutoHuntState::Search, now);
}
}
// Search
if (const AutoHuntMob* mob = PickMob(in)) {
m_target = mob->vid;
out.target = mob->vid;
Enter(AutoHuntState::Engage, now);
const float distance = Distance(mob->x, mob->z, in.x, in.z);
m_bestDistance = distance;
if (distance <= in.attackRange + mob->radius) {
Halt(out);
out.attack = mob->vid;
} else {
GoTo(out, mob->x, mob->z, now);
}
} else if (const AutoHuntItem* item = PickItem(in)) {
m_target = item->vid;
Enter(AutoHuntState::Loot, now);
GoTo(out, item->x, item->z, now);
} else if (Distance(m_anchorX, m_anchorZ, in.x, in.z) > kPickRange * 2) {
Enter(AutoHuntState::Return, now);
GoTo(out, m_anchorX, m_anchorZ, now);
} else {
Halt(out);
}
return out;
}
} // namespace ava2
+112
View File
@@ -0,0 +1,112 @@
// Client-side auto hunt (mobile step 6, docs/MOBILE-ARCHITECTURE.md). Not in the AVA2 client: a
// new feature written for this port, not adapted from another client. It only drives the inputs a
// player already has — walking, the attack key, quickslot skills, item pick-up and quickslot
// potions — so the server sees the same packets as manual play.
//
// Pure logic: the host (python_gameplay_modules.cpp ProcessAutoHunt) fills AutoHuntInput from the
// actor/item/skill state every frame and carries out the returned AutoHuntOutput.
#pragma once
#include <cstdint>
#include <unordered_map>
#include <vector>
namespace ava2 {
enum class AutoHuntState : uint8_t { Off, Search, Engage, Loot, Return, Paused };
struct AutoHuntOptions {
float radius = 1500.0f; // hunt area around the anchor (map units, 100 = 1 m)
bool useSkills = true; // skills on the current quickslot page
bool pickUp = true; // walk to and pick up own / free drops
bool attackStones = false; // metin stones (TYPE_STONE) as targets
int hpPercent = 50; // use hpSlot below this HP %, 0 = never
int spPercent = 30; // use spSlot below this SP %, 0 = never
int hpSlot = 24; // global quickslot (mobile potion belt = 24..31)
int spSlot = 25;
};
struct AutoHuntMob {
uint32_t vid = 0;
float x = 0, z = 0;
float radius = 0; // defending radius, added to the attack range
bool stone = false;
};
struct AutoHuntItem {
uint32_t vid = 0;
float x = 0, z = 0;
};
struct AutoHuntInput {
uint32_t now = 0; // ms
float x = 0, z = 0; // main actor
bool dead = false;
bool canAct = true;
bool busy = false; // attack or skill motion playing
bool manual = false; // player is steering / attacking this frame
int hpPercent = 100, spPercent = 100;
float attackRange = 160.0f; // weapon reach without the victim radius
bool hpSlotUsable = false, spSlotUsable = false;
std::vector<AutoHuntMob> mobs; // living attackable actors
std::vector<AutoHuntItem> items; // ground items this player may pick up
std::vector<int> readySkillSlots; // skill slots off cooldown and not already active
};
struct AutoHuntOutput {
enum class Move : uint8_t { None, Go, Stop } move = Move::None;
float moveX = 0, moveZ = 0;
uint32_t target = 0; // send a target packet (player.SetTarget)
uint32_t attack = 0; // face this vid and press attack this frame
int skillSlot = -1; // ClickSkillSlot
uint32_t pick = 0; // SendItemPickUpPacket
int useQuickSlot = -1; // global quickslot to use (potion)
bool stopped = false; // turned itself off (death)
};
class AutoHunt {
public:
static constexpr uint32_t kResumeDelay = 3000; // after the last manual input
static constexpr uint32_t kChaseTimeout = 8000; // no progress towards a target
static constexpr uint32_t kIgnoreTime = 30000; // a given-up target / item is skipped
static constexpr uint32_t kSkillGap = 1200;
static constexpr uint32_t kPotionGap = 1000;
static constexpr uint32_t kPickGap = 300;
static constexpr uint32_t kRepathGap = 250;
static constexpr float kPickRange = 150.0f;
AutoHuntOptions options;
void Start(float x, float z);
void Stop();
bool IsOn() const { return m_state != AutoHuntState::Off; }
AutoHuntState GetState() const { return m_state; }
uint32_t GetTarget() const { return m_target; }
float GetAnchorX() const { return m_anchorX; }
float GetAnchorZ() const { return m_anchorZ; }
AutoHuntOutput Update(const AutoHuntInput& in);
private:
void Enter(AutoHuntState state, uint32_t now);
bool Ignored(uint32_t vid, uint32_t now) const;
const AutoHuntMob* FindMob(const AutoHuntInput& in, uint32_t vid) const;
const AutoHuntMob* PickMob(const AutoHuntInput& in) const;
const AutoHuntItem* PickItem(const AutoHuntInput& in) const;
void GoTo(AutoHuntOutput& out, float x, float z, uint32_t now);
void Halt(AutoHuntOutput& out);
void Potions(const AutoHuntInput& in, AutoHuntOutput& out);
AutoHuntState m_state = AutoHuntState::Off;
float m_anchorX = 0, m_anchorZ = 0;
uint32_t m_target = 0; // mob vid (Engage) or item vid (Loot)
uint32_t m_stateSince = 0;
uint32_t m_lastManual = 0;
uint32_t m_lastProgress = 0;
float m_bestDistance = 0;
uint32_t m_lastSkill = 0, m_lastPotion = 0, m_lastPick = 0, m_lastPath = 0;
bool m_moving = false;
std::unordered_map<uint32_t, uint32_t> m_ignoreUntil;
};
const char* AutoHuntStateName(AutoHuntState state);
} // namespace ava2
+195
View File
@@ -15,6 +15,8 @@
#include "game_type.h"
#include "guild_state.h"
#include "skill_cooldown.h"
#include "auto_hunt.h"
#include "python_system.h"
#include "eter_net/PythonNetworkStream.h"
#include "eter_net/NetworkActorManager.h"
#include "eter_render/TerrainHeightmap.h"
@@ -37,6 +39,7 @@
#include <fstream>
#include <sstream>
#include <iostream>
#include <iterator>
#include <cctype>
#include <algorithm>
@@ -1103,6 +1106,106 @@ bool ProcessPlayerAttack(float cameraYaw, float frameDt, bool wasMoving) {
return stopSent;
}
// Mobile step 6 auto hunt (src/game/auto_hunt.h). Fills the logic's view of the world from the
// same state manual play uses and carries out its decisions through the manual paths: actor move
// target (main.cpp sends the move packets), PlayerNewAttack (= held attack key), ClickSkillSlot,
// the pick-up packet and quickslot use.
static AutoHunt s_autoHunt;
static bool IsAutoHuntSkillReady(int skillSlot, float now) {
auto it = s_playerSkills.find(skillSlot);
if (it == s_playerSkills.end() || it->second.index == 0 || it->second.level <= 0) return false;
const int index = it->second.index;
if (index == 121 || index == 122 || index == 123) return false; // fishing / combo
if (GetSkillTypeById(uint32_t(index)) == 3 /* SKILL_TYPE_GUILD */) return false;
if (it->second.cooldown.cooling(now, s_coolTimeEnabled)) return false;
const auto* data = FindSkillDescription(uint32_t(index));
const bool toggle = data && (data->attributes & (1u << 1 /* SKILL_ATTRIBUTE_TOGGLE */));
return !(toggle && it->second.active);
}
static bool IsAutoHuntPotionSlot(int global) {
if (global < 0 || global >= int(s_playerQuickSlots.size())) return false;
const auto& quick = s_playerQuickSlots[global];
return quick.type == 1 /* SLOT_TYPE_INVENTORY */ && GetPlayerItemData(1, uint16_t(quick.pos)).count > 0;
}
static int PointPercent(int cur, int max) {
auto c = s_playerPoints.find(cur), m = s_playerPoints.find(max);
if (c == s_playerPoints.end() || m == s_playerPoints.end() || m->second <= 0) return 100;
return int(c->second * 100 / m->second);
}
void ProcessAutoHunt() {
if (!s_autoHunt.IsOn()) return;
auto& manager = NetworkActorManager::Instance();
auto* main = manager.GetMainInstance();
if (!main || !main->m_pActorInstance) return;
auto& inst = *main->m_pActorInstance;
AutoHuntInput in;
in.now = GetServerMSec();
in.x = inst.GetX();
in.z = inst.GetZ();
in.dead = inst.IsDead();
in.canAct = inst.CanAct();
in.busy = inst.IsAttacking() || inst.IsUsingSkill();
float yaw;
in.manual = s_isAtkKey || GetPlayerMovementYaw(0.0f, yaw) || IsPlayerMouseMoving();
in.hpPercent = PointPercent(5 /* POINT_HP */, 6 /* POINT_MAX_HP */);
in.spPercent = PointPercent(7 /* POINT_SP */, 8 /* POINT_MAX_SP */);
in.attackRange = inst.IsBowMode() ? 900.0f : 150.0f;
in.hpSlotUsable = IsAutoHuntPotionSlot(s_autoHunt.options.hpSlot);
in.spSlotUsable = IsAutoHuntPotionSlot(s_autoHunt.options.spSlot);
for (const auto& [vid, actor] : manager.GetActorDict()) {
if (vid == main->m_dwVID || !actor.m_pActorInstance) continue;
if (actor.m_bType != 0 && actor.m_bType != 2) continue; // TYPE_ENEMY / TYPE_STONE
const auto& v = *actor.m_pActorInstance;
if (v.IsDead()) continue;
in.mobs.push_back({vid, v.GetX(), v.GetZ(), v.GetDefendingRadius(), actor.m_bType == 2});
}
for (const auto& [vid, item] : CPythonItem::Instance().GetGroundItems()) {
if (!item->stOwnership.empty() && item->stOwnership != s_playerName) continue;
in.items.push_back({vid, item->v3EndPosition.x, -item->v3EndPosition.y});
}
// The combat wheel shows quickslot pages 1-3 (ui_mobile_combat.py); page 4 is the potion belt.
const float nowSec = CTimer::Instance().GetCurrentSecond();
const int page = s_quickPage < 3 ? s_quickPage : 0;
for (int local = 0; local < 8; ++local) {
const auto& quick = s_playerQuickSlots[page * 8 + local];
if (quick.type == 2 /* SLOT_TYPE_SKILL */ && IsAutoHuntSkillReady(quick.pos, nowSec))
in.readySkillSlots.push_back(quick.pos);
}
const AutoHuntOutput out = s_autoHunt.Update(in);
if (out.move == AutoHuntOutput::Move::Go) {
inst.SetMoveTarget(out.moveX, out.moveZ);
} else if (out.move == AutoHuntOutput::Move::Stop) {
inst.ClearMoveTarget();
inst.StopMoving();
}
if (out.useQuickSlot >= 0) use_global_quick_slot(out.useQuickSlot);
if (out.target && out.target != s_targetVID) {
s_targetVID = out.target;
PythonNetworkStream::Instance().SendTargetPacket(out.target);
}
if (out.attack) {
if (const auto* victim = manager.GetActorData(out.attack); victim && victim->m_pActorInstance) {
if (!inst.IsAttacking()) {
const float dx = victim->m_pActorInstance->GetX() - inst.GetX();
const float dz = victim->m_pActorInstance->GetZ() - inst.GetZ();
inst.SetYaw(std::fmod(std::atan2(dx, dz) * 180.0f / 3.14159265f + 360.0f, 360.0f));
}
if (out.skillSlot >= 0) ClickSkillSlot(out.skillSlot);
else PlayerNewAttack();
}
}
if (out.pick) PythonNetworkStream::Instance().SendItemPickUpPacket(out.pick);
if (out.stopped) player_window_call("OnAutoHuntStopped");
}
bool IsAutoHuntOn() { return s_autoHunt.IsOn(); }
static float s_fCmrRotSpd = 0.0f;
static uint32_t s_inGuildAreaID = 0xffffffff;
@@ -3524,6 +3627,93 @@ static PyObject* player_GetItemUnSealLeftTime(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
// Mobile step 6 auto hunt (ui_mobile_autohunt.py). Not in the original player module.
static void auto_hunt_load();
static PyObject* player_SetAutoHunt(PyObject*, PyObject* args) {
int on = 0;
if (!PyArg_ParseTuple(args, "i", &on)) return nullptr;
auto_hunt_load();
if (on && !s_autoHunt.IsOn()) {
const auto* main = NetworkActorManager::Instance().GetMainInstance();
if (main && main->m_pActorInstance) s_autoHunt.Start(main->m_pActorInstance->GetX(), main->m_pActorInstance->GetZ());
} else if (!on && s_autoHunt.IsOn()) {
s_autoHunt.Stop();
if (auto* main = NetworkActorManager::Instance().GetMainInstance(); main && main->m_pActorInstance) {
main->m_pActorInstance->ClearMoveTarget();
main->m_pActorInstance->StopMoving();
}
}
return PyInt_FromLong(s_autoHunt.IsOn());
}
static PyObject* player_IsAutoHunt(PyObject*, PyObject*) { return PyInt_FromLong(s_autoHunt.IsOn()); }
static PyObject* player_GetAutoHuntState(PyObject*, PyObject*) {
return Py_BuildValue("(si)", AutoHuntStateName(s_autoHunt.GetState()), int(s_autoHunt.GetTarget()));
}
static int* auto_hunt_int_option(const std::string& name) {
auto& o = s_autoHunt.options;
if (name == "hp_percent") return &o.hpPercent;
if (name == "sp_percent") return &o.spPercent;
if (name == "hp_slot") return &o.hpSlot;
if (name == "sp_slot") return &o.spSlot;
return nullptr;
}
static bool* auto_hunt_bool_option(const std::string& name) {
auto& o = s_autoHunt.options;
if (name == "skills") return &o.useSkills;
if (name == "pickup") return &o.pickUp;
if (name == "stones") return &o.attackStones;
return nullptr;
}
// autohunt.cfg next to metin2.cfg (CPythonSystem config directory), "name value" per line.
static std::string auto_hunt_config_path() {
std::string directory = CPythonSystem::GetConfigDirectory();
if (!directory.empty() && directory.back() != '/' && directory.back() != '\\') directory += '/';
return directory + "autohunt.cfg";
}
static void auto_hunt_set(const std::string& name, int value) {
if (name == "radius") s_autoHunt.options.radius = float(std::clamp(value, 300, 5000));
else if (int* i = auto_hunt_int_option(name)) *i = name == "hp_slot" || name == "sp_slot" ? std::clamp(value, 0, 31) : std::clamp(value, 0, 100);
else if (bool* b = auto_hunt_bool_option(name)) *b = value != 0;
}
static void auto_hunt_load() {
static bool loaded = false;
if (loaded) return;
loaded = true;
std::ifstream file(auto_hunt_config_path());
std::string name; int value;
while (file >> name >> value) auto_hunt_set(name, value);
}
static void auto_hunt_save() {
const auto& o = s_autoHunt.options;
std::ofstream file(auto_hunt_config_path(), std::ios::trunc);
file << "radius " << int(o.radius) << "\nskills " << o.useSkills << "\npickup " << o.pickUp
<< "\nstones " << o.attackStones << "\nhp_percent " << o.hpPercent << "\nsp_percent " << o.spPercent
<< "\nhp_slot " << o.hpSlot << "\nsp_slot " << o.spSlot << "\n";
}
static PyObject* player_SetAutoHuntOption(PyObject*, PyObject* args) {
char* name = nullptr; int value = 0;
if (!PyArg_ParseTuple(args, "si", &name, &value)) return nullptr;
const std::string key(name);
if (key != "radius" && !auto_hunt_int_option(key) && !auto_hunt_bool_option(key)) {
PyErr_Format(PyExc_KeyError, "%s", name);
return nullptr;
}
auto_hunt_load();
auto_hunt_set(key, value);
auto_hunt_save();
Py_RETURN_NONE;
}
static PyObject* player_GetAutoHuntOption(PyObject*, PyObject* args) {
char* name = nullptr;
if (!PyArg_ParseTuple(args, "s", &name)) return nullptr;
auto_hunt_load();
if (std::string(name) == "radius") return PyInt_FromLong(long(s_autoHunt.options.radius));
if (int* i = auto_hunt_int_option(name)) return PyInt_FromLong(*i);
if (bool* b = auto_hunt_bool_option(name)) return PyInt_FromLong(*b);
PyErr_Format(PyExc_KeyError, "%s", name);
return nullptr;
}
void initPlayer() {
static PyMethodDef methods[] = {
{"GetAutoPotionInfo", player_GetAutoPotionInfo, METH_VARARGS, nullptr},
@@ -3691,6 +3881,11 @@ void initPlayer() {
{"GetGem", player_GetGem, METH_VARARGS, nullptr},
{"SetEventGame", player_SetEventGame, METH_VARARGS, nullptr},
{"GetEventGame", player_GetEventGame, METH_VARARGS, nullptr},
{"SetAutoHunt", player_SetAutoHunt, METH_VARARGS, nullptr},
{"IsAutoHunt", player_IsAutoHunt, METH_VARARGS, nullptr},
{"GetAutoHuntState", player_GetAutoHuntState, METH_VARARGS, nullptr},
{"SetAutoHuntOption", player_SetAutoHuntOption, METH_VARARGS, nullptr},
{"GetAutoHuntOption", player_GetAutoHuntOption, METH_VARARGS, nullptr},
{nullptr, nullptr, 0, nullptr}
};
NetworkActorManager::SetPartyMemberQuery(IsPartyMemberByVID);
+4
View File
@@ -99,6 +99,10 @@ void SetPlayerAttackKey(bool pressed);
bool ProcessPlayerAttack(float cameraYaw, float frameDt, bool wasMoving);
// The main actor is playing an attack motion (movement input is ignored meanwhile).
bool IsPlayerAttacking();
// Mobile auto hunt (src/game/auto_hunt.h), per frame before ProcessPlayerAttack: steers the main
// actor and presses attack / skills / pick-up while player.SetAutoHunt(1) is on.
void ProcessAutoHunt();
bool IsAutoHuntOn();
// True when handler is the window passed to player.SetGameWindow (game.GameWindow).
bool IsPlayerGameWindow(const void* handler);
void SetWeaponPower(uint32_t dwMinPower, uint32_t dwMaxPower, uint32_t dwMinMagicPower, uint32_t dwMaxMagicPower, uint32_t dwAddPower);
+2
View File
@@ -397,6 +397,8 @@ public:
void Update() {}
void Render() {}
// Port addition for the auto hunt driver (python_gameplay_modules.cpp ProcessAutoHunt).
const TGroundItemInstanceMap& GetGroundItems() const { return m_GroundItemInstanceMap; }
void GetInfo(std::string* pstInfo) {
if (pstInfo) {
pstInfo->append("Item: Inst " + std::to_string(m_GroundItemInstanceMap.size()));
+145
View File
@@ -0,0 +1,145 @@
// Mobile step 6 auto hunt state machine (src/game/auto_hunt.h), without the engine.
#include "auto_hunt.h"
#include <cassert>
#include <cmath>
#include <iostream>
using namespace ava2;
namespace {
AutoHuntInput At(uint32_t now, float x, float z) {
AutoHuntInput in;
in.now = now;
in.x = x;
in.z = z;
return in;
}
} // namespace
int main() {
// Off does nothing.
{
AutoHunt hunt;
auto in = At(1000, 0, 0);
in.mobs.push_back({7, 300, 0, 50, false});
const auto out = hunt.Update(in);
assert(out.move == AutoHuntOutput::Move::None && !out.attack && !out.target);
}
// Search -> engage: target packet + walk; in range: stop + attack; skill when ready.
{
AutoHunt hunt;
hunt.Start(0, 0);
auto in = At(1000, 0, 0);
in.mobs.push_back({7, 600, 0, 50, false});
in.mobs.push_back({8, 900, 0, 50, false});
auto out = hunt.Update(in);
assert(hunt.GetState() == AutoHuntState::Engage && hunt.GetTarget() == 7);
assert(out.target == 7 && out.move == AutoHuntOutput::Move::Go && out.moveX == 600.0f);
in = At(2000, 450, 0);
in.mobs.push_back({7, 600, 0, 50, false});
in.readySkillSlots = {3};
out = hunt.Update(in);
assert(out.move == AutoHuntOutput::Move::Stop && out.attack == 7 && out.skillSlot == 3);
// Skill gap: next frame only attacks.
in.now = 2100;
out = hunt.Update(in);
assert(out.attack == 7 && out.skillSlot == -1 && out.move == AutoHuntOutput::Move::None);
// Busy (attack motion) blocks skills even after the gap.
in.now = 4000;
in.busy = true;
out = hunt.Update(in);
assert(out.attack == 7 && out.skillSlot == -1);
// Target died, own drop nearby -> loot before the next mob.
in = At(4100, 450, 0);
in.mobs.push_back({8, 900, 0, 50, false});
in.items.push_back({100, 500, 300});
out = hunt.Update(in);
assert(hunt.GetState() == AutoHuntState::Loot && hunt.GetTarget() == 100);
assert(out.move == AutoHuntOutput::Move::Go && out.moveX == 500.0f && out.moveZ == 300.0f);
in = At(4500, 500, 250);
in.mobs.push_back({8, 900, 0, 50, false});
in.items.push_back({100, 500, 300});
out = hunt.Update(in);
assert(out.pick == 100 && out.move == AutoHuntOutput::Move::Stop);
// Picked up -> next mob.
in = At(4800, 500, 250);
in.mobs.push_back({8, 900, 0, 50, false});
out = hunt.Update(in);
assert(hunt.GetState() == AutoHuntState::Engage && out.target == 8);
}
// Area: mobs outside the radius and stones (unless enabled) are skipped; return to the anchor.
{
AutoHunt hunt;
hunt.options.radius = 1000;
hunt.Start(0, 0);
auto in = At(1000, 800, 0);
in.mobs.push_back({1, 2500, 0, 50, false});
in.mobs.push_back({2, 700, 0, 80, true});
auto out = hunt.Update(in);
assert(hunt.GetState() == AutoHuntState::Return && out.move == AutoHuntOutput::Move::Go && out.moveX == 0.0f);
hunt.options.attackStones = true;
out = hunt.Update(At(1100, 700, 0));
in.now = 1200;
out = hunt.Update(in);
assert(hunt.GetState() == AutoHuntState::Engage && hunt.GetTarget() == 2 && out.attack == 2);
}
// Chase watchdog: no progress for kChaseTimeout -> target ignored for kIgnoreTime.
{
AutoHunt hunt;
hunt.Start(0, 0);
auto in = At(1000, 0, 0);
in.mobs.push_back({5, 800, 0, 50, false});
hunt.Update(in);
in.now = 1000 + AutoHunt::kChaseTimeout + 10;
auto out = hunt.Update(in);
assert(hunt.GetState() == AutoHuntState::Search && out.move == AutoHuntOutput::Move::Stop);
in.now += 100;
out = hunt.Update(in);
assert(hunt.GetState() == AutoHuntState::Search && !out.target);
in.now += AutoHunt::kIgnoreTime;
out = hunt.Update(in);
assert(out.target == 5);
}
// Manual input pauses, resumes after kResumeDelay and re-anchors where the player stopped.
{
AutoHunt hunt;
hunt.options.radius = 500;
hunt.Start(0, 0);
auto in = At(1000, 0, 0);
in.manual = true;
auto out = hunt.Update(in);
assert(hunt.GetState() == AutoHuntState::Paused && out.move == AutoHuntOutput::Move::None);
in = At(2000, 3000, 0);
in.mobs.push_back({9, 3200, 0, 50, false});
out = hunt.Update(in);
assert(hunt.GetState() == AutoHuntState::Paused && !out.target);
in.now = 1000 + AutoHunt::kResumeDelay;
out = hunt.Update(in);
assert(hunt.GetState() == AutoHuntState::Engage && out.target == 9);
assert(hunt.GetAnchorX() == 3000.0f);
}
// Potions run in every state with their own gap; HP first. Death turns it off.
{
AutoHunt hunt;
hunt.Start(0, 0);
auto in = At(1000, 0, 0);
in.hpPercent = 30;
in.spPercent = 10;
in.hpSlotUsable = in.spSlotUsable = true;
auto out = hunt.Update(in);
assert(out.useQuickSlot == 24);
in.now = 1500;
assert(hunt.Update(in).useQuickSlot == -1);
in.now = 2100;
in.hpPercent = 80;
assert(hunt.Update(in).useQuickSlot == 25);
in.now = 3200;
in.spSlotUsable = false;
assert(hunt.Update(in).useQuickSlot == -1);
in.dead = true;
out = hunt.Update(in);
assert(out.stopped && !hunt.IsOn());
}
std::cout << "Auto hunt state machine passed" << std::endl;
return 0;
}
+68
View File
@@ -8,11 +8,16 @@
#include "eter_image/GrpDevice.h"
#include "test_rundir.h"
#include "eter_net/PythonNetworkStream.h"
#include "eter_net/NetworkActorManager.h"
#include "python_system.h"
#include <Python.h>
#include <SDL3/SDL.h>
#include <array>
#include <cassert>
#include <cmath>
#include <filesystem>
#include <fstream>
#include <iterator>
#include <iostream>
namespace {
@@ -148,6 +153,69 @@ int main(int argc, char** argv) {
"assert mm.GetGlobalPosition()[0] + mm.GetWidth() == 1024\n"
"game.OnUpdate()\n");
// Auto hunt (mobile step 6): the AUTO button sits on the combat wheel and is real UI; with a
// main actor and a mob the native driver targets, walks, stops in reach and gives up on the dead.
ava2::CPythonSystem::SetConfigDirectory(std::filesystem::temp_directory_path().string());
std::filesystem::remove(std::filesystem::temp_directory_path() / "autohunt.cfg");
runtime.execute("ab = hud.combat_wheel.auto_button\n"
"assert ab.IsShow() and not player.IsAutoHunt()\n"
"assert player.SetAutoHunt(1) == 0\n" // no main actor yet
"touch_tb = ab.GetGlobalPosition()\n"
"touch_tb = (touch_tb[0] + ab.GetWidth() / 2, touch_tb[1] + ab.GetHeight() / 2)\n"
"assert player.GetAutoHuntOption('radius') == 1500\n"
"player.SetAutoHuntOption('radius', 2000)\nplayer.SetAutoHuntOption('stones', 1)\n"
"assert player.GetAutoHuntOption('radius') == 2000 and player.GetAutoHuntOption('stones') == 1\n"
"player.SetAutoHuntOption('stones', 0)\n");
tb = PyDict_GetItemString(PyModule_GetDict(main), "touch_tb");
const float ab_x = float(PyInt_AsLong(PyTuple_GetItem(tb, 0)));
const float ab_y = float(PyInt_AsLong(PyTuple_GetItem(tb, 1)));
assert(sink.IsUiAt(ab_x, ab_y));
{
std::ifstream cfg(std::filesystem::temp_directory_path() / "autohunt.cfg");
std::string text((std::istreambuf_iterator<char>(cfg)), std::istreambuf_iterator<char>());
assert(text.find("radius 2000\n") != std::string::npos && text.find("stones 0\n") != std::string::npos);
}
auto& actors = ava2::NetworkActorManager::Instance();
ava2::SNetworkActorData me{};
me.m_dwVID = 5001; me.m_bType = 6; me.m_stName = "AutoHunter"; me.m_lCurX = 10000; me.m_lCurY = 10000;
actors.AppendActor(me);
ava2::PythonNetworkStream::Instance().SetMainActorVID(5001);
ava2::SNetworkActorData mob{};
mob.m_dwVID = 5002; mob.m_bType = 0; mob.m_dwRace = 101; mob.m_lCurX = 10800; mob.m_lCurY = 10000;
actors.AppendActor(mob);
auto hunter = actors.GetActorInstance(5001);
auto prey = actors.GetActorInstance(5002);
assert(hunter && prey);
// Tap AUTO: on (button turns green, state text shows the fight).
wm->RunMouseMove(long(ab_x), long(ab_y));
runtime.execute("ab.OnMouseLeftButtonDown()\nab.OnMouseLeftButtonUp()\n"
"assert player.IsAutoHunt() and ab.isOn\n");
ava2::ProcessAutoHunt();
runtime.execute("assert player.GetAutoHuntState() == ('engage', 5002), player.GetAutoHuntState()\n"
"assert player.GetTargetVID() == 5002\n"
"ab.OnUpdate()\nassert ab.state_text.GetText() == 'Fight'\n");
assert(hunter->HasMoveTarget());
hunter->SetPosition(10700.0f, hunter->GetY(), 10000.0f);
ava2::ProcessAutoHunt();
assert(!hunter->HasMoveTarget());
// Steering pauses it; the mob dies; turning it off from the button.
ava2::SetPlayerJoystick(true, 1.0f, 0.0f);
ava2::ProcessAutoHunt();
runtime.execute("assert player.GetAutoHuntState()[0] == 'paused'\n");
ava2::SetPlayerJoystick(false, 0.0f, 0.0f);
prey->SetHP(0);
runtime.execute("ab.OnMouseLeftButtonDown()\nab.OnMouseLeftButtonUp()\n"
"assert not player.IsAutoHunt()\nab.OnUpdate()\nassert not ab.isOn\n"
// Long press opens the settings window instead of toggling.
"ab.OnMouseLeftButtonDown()\nab.pressTime -= 1000\nab.OnUpdate()\nab.OnMouseLeftButtonUp()\n"
"import ui_mobile_autohunt\n"
"assert not player.IsAutoHunt() and ui_mobile_autohunt._settings.IsShow()\n"
"ui_mobile_autohunt._settings.Close()\n");
actors.RemoveActor(5002);
actors.RemoveActor(5001);
ava2::PythonNetworkStream::Instance().SetMainActorVID(0);
std::filesystem::remove(std::filesystem::temp_directory_path() / "autohunt.cfg");
SDL_FillSurfaceRect(surface, nullptr, 0xff10141e);
wm->Render(); SDL_RenderPresent(renderer);
// CDisc geometry: the attack disc is dark red between the icon and the rim; empty screen is not.
+233
View File
@@ -0,0 +1,233 @@
# -*- coding: utf-8 -*-
# 移动端自动狩猎(docs/MOBILE-ARCHITECTURE.md 第 6 步)。原版没有这个功能,是本客户端新增的;
# 逻辑在原生 src/game/auto_hunt.cpp,只走玩家手动操作本来就有的路径(走路、攻击键、快捷栏技能、
# 拾取、快捷栏药水)。这里只有 HUD 上的 AUTO 键和设置窗。
# AUTO 键:轻点开关;长按打开设置
# 设置项保存在 metin2.cfg 同目录的 autohunt.cfg(原生 player.SetAutoHuntOption 负责读写)
import ui
import grp
import app
import player
import chat
import wndMgr
import ui_mobile_widgets as widgets
Color = widgets.Color
STYLE_AUTO_ON = (Color(0.20, 0.45, 0.18, 0.90), Color(0.05, 0.15, 0.05, 0.90), Color(0.75, 1.0, 0.55), Color(0.20, 0.40, 0.12), 3.0)
STYLE_AUTO_ON_DOWN = (Color(0.35, 0.65, 0.30, 0.95), Color(0.10, 0.25, 0.08, 0.95), Color(0.90, 1.0, 0.70), Color(0.30, 0.50, 0.18), 3.0)
STATE_TEXT = {
"search": "Search",
"engage": "Fight",
"loot": "Loot",
"return": "Return",
"paused": "Paused",
}
# 设置窗全局一个:HUD 按安全区重建时 AUTO 键会重建,设置窗不跟着重建
_settings = None
def OpenSettings():
global _settings
if not _settings:
_settings = AutoHuntSettingsWindow()
_settings.Open()
def Toggle():
on = player.SetAutoHunt(0 if player.IsAutoHunt() else 1)
chat.AppendChat(chat.CHAT_TYPE_INFO, "Auto hunt ON" if on else "Auto hunt OFF")
return on
class AutoHuntButton(widgets.RoundButton):
"""AUTO 键:轻点开关自动狩猎,长按(0.6 秒)打开设置窗。开启时绿色,下方显示当前状态。"""
LONG_PRESS = 600
def __init__(self, diameter):
widgets.RoundButton.__init__(self, diameter)
self.SetLabel("AUTO")
self.pressTime = 0
self.longPressed = False
self.isOn = False
self.lastState = None
self.state_text = ui.TextLine()
self.state_text.SetParent(self)
self.state_text.AddFlag("not_pick")
self.state_text.SetPosition(diameter / 2, diameter + 1)
self.state_text.SetHorizontalAlignCenter()
self.state_text.SetOutline()
self.state_text.SetPackedFontColor(grp.GenerateColor(0.75, 1.0, 0.55, 1.0))
self.state_text.Show()
self.__Apply(False)
def __del__(self):
widgets.RoundButton.__del__(self)
def __Apply(self, on):
self.isOn = on
if on:
self.style, self.downStyle = STYLE_AUTO_ON, STYLE_AUTO_ON_DOWN
else:
self.style, self.downStyle = widgets.STYLE_FRAME, widgets.STYLE_FRAME_DOWN
self.disc.SetStyle(self.style)
if not on:
self.state_text.SetText("")
self.lastState = None
def OnMouseLeftButtonDown(self):
self.pressTime = app.GetGlobalTime()
self.longPressed = False
return widgets.RoundButton.OnMouseLeftButtonDown(self)
def OnMouseLeftButtonUp(self):
self.disc.SetStyle(self.style)
held = self.pressTime
self.pressTime = 0
if self.longPressed or not self.IsIn():
return True
if held:
self.__Apply(Toggle())
return True
def OnUpdate(self):
if self.pressTime and not self.longPressed and app.GetGlobalTime() - self.pressTime >= self.LONG_PRESS:
self.longPressed = True
self.disc.SetStyle(self.style)
OpenSettings()
on = player.IsAutoHunt()
if on != self.isOn:
# 死亡等原因由原生自行关闭
self.__Apply(on)
if on:
state = player.GetAutoHuntState()[0]
if state != self.lastState:
self.lastState = state
self.state_text.SetText(STATE_TEXT.get(state, ""))
class AutoHuntSettingsWindow(ui.BoardWithTitleBar):
"""自动狩猎设置:范围、技能、拾取、打石头、HP/SP 药水阈值。药水用底部药水栏第 1/2 格。"""
WIDTH = 300
ROW = 32
RADIUS_STEP = 500
PERCENT_STEP = 10
def __init__(self):
ui.BoardWithTitleBar.__init__(self)
self.SetWindowName("AutoHuntSettings")
self.AddFlag("movable")
self.AddFlag("float")
self.SetTitleName("Auto Hunt")
self.SetCloseEvent(ui.__mem_func__(self.Close))
rows = [
("radius", "Range", self.__RadiusText),
("skills", "Use skills", None),
("pickup", "Pick up items", None),
("stones", "Attack metin stones", None),
("hp_percent", "HP potion (belt 1) below", self.__PercentText),
("sp_percent", "SP potion (belt 2) below", self.__PercentText),
]
self.values = {}
self.parts = []
y = 38
for key, label, fmt in rows:
text = ui.TextLine()
text.SetParent(self)
text.SetPosition(16, y + 6)
text.SetText(label)
text.Show()
self.parts.append(text)
if fmt:
self.__AddStepper(key, y, fmt)
else:
self.__AddToggle(key, y)
y += self.ROW
hint = ui.TextLine()
hint.SetParent(self)
hint.SetPosition(16, y + 4)
hint.SetPackedFontColor(grp.GenerateColor(0.7, 0.7, 0.7, 1.0))
hint.SetText("Skills: current quick page. Moving pauses 3 s.")
hint.Show()
self.parts.append(hint)
self.SetSize(self.WIDTH, y + 34)
self.SetCenterPosition()
self.Hide()
def __del__(self):
ui.BoardWithTitleBar.__del__(self)
def __RadiusText(self, value):
return "%d m" % (value / 100)
def __PercentText(self, value):
return "Off" if value <= 0 else "%d%%" % value
def __SmallButton(self, x, y, text, event):
button = ui.Button()
button.SetParent(self)
button.SetPosition(x, y)
button.SetUpVisual("d:/ymir work/ui/public/small_button_01.sub")
button.SetOverVisual("d:/ymir work/ui/public/small_button_02.sub")
button.SetDownVisual("d:/ymir work/ui/public/small_button_03.sub")
button.SetText(text)
button.SetEvent(event)
button.Show()
self.parts.append(button)
return button
def __AddStepper(self, key, y, fmt):
value = ui.TextLine()
value.SetParent(self)
value.SetPosition(self.WIDTH - 66, y + 6)
value.SetHorizontalAlignCenter()
value.Show()
self.parts.append(value)
step = self.RADIUS_STEP if key == "radius" else self.PERCENT_STEP
self.__SmallButton(self.WIDTH - 118, y + 2, "-", lambda: self.__Step(key, -step))
self.__SmallButton(self.WIDTH - 58, y + 2, "+", lambda: self.__Step(key, step))
self.values[key] = (value, fmt)
def __AddToggle(self, key, y):
button = self.__SmallButton(self.WIDTH - 72, y + 2, "", lambda: self.__Flip(key))
self.values[key] = (button, None)
def __Step(self, key, delta):
value = player.GetAutoHuntOption(key) + delta
if key == "radius":
value = max(500, min(5000, value))
else:
value = max(0, min(90, value))
player.SetAutoHuntOption(key, value)
self.Refresh()
def __Flip(self, key):
player.SetAutoHuntOption(key, 0 if player.GetAutoHuntOption(key) else 1)
self.Refresh()
def Refresh(self):
for key, (widget, fmt) in self.values.items():
value = player.GetAutoHuntOption(key)
if fmt:
widget.SetText(fmt(value))
else:
widget.SetText("On" if value else "Off")
def Open(self):
self.Refresh()
self.Show()
self.SetTop()
def Close(self):
self.Hide()
def OnPressEscapeKey(self):
self.Close()
return True
+8
View File
@@ -8,6 +8,7 @@ import wndMgr
import touch
import constInfo
import ui_mobile_widgets as widgets
import ui_mobile_autohunt
class MobileCombatWheel(ui.Window):
"""
@@ -17,10 +18,12 @@ class MobileCombatWheel(ui.Window):
- 攻击键外两圈共 8 个快捷格 = 当前快捷页的 8 格(PC 任务栏 1-4 / F1-F4 同一份数据),
第 4 页留给底部药水栏,所以这里只在第 1-3 页间切换
- 小按钮:快捷页切换、上下马(原版 Ctrl+G 的 /ride)、拾取(原版 ` / Z 键)
- AUTO 键(第 6 步自动狩猎,ui_mobile_autohunt.py):轻点开关,长按设置
"""
ATTACK_RADIUS = 60
SLOT_DIAMETER = 50
SMALL_DIAMETER = 40
AUTO_DIAMETER = 46
# (半径, 角度):角度从 +x 逆时针,内外圈各 4 格,外圈错开半格;相邻格间距大于格子直径
SLOT_LAYOUT = [(108, 90), (108, 120), (108, 150), (108, 180),
(172, 97.5), (172, 122.5), (172, 147.5), (172, 172.5)]
@@ -87,6 +90,10 @@ class MobileCombatWheel(ui.Window):
self.mount_button.SetLabel("Ride")
self.pickup_button = self.__MakeSmall(cx - 86 - d / 2, cy + 82 - d / 2, ui.__mem_func__(self.__OnPickUp))
self.pickup_button.SetLabel("Pick")
self.auto_button = ui_mobile_autohunt.AutoHuntButton(self.AUTO_DIAMETER)
self.auto_button.SetParent(self)
self.auto_button.SetPosition(cx + 70 - self.AUTO_DIAMETER / 2, cy - 160 - self.AUTO_DIAMETER / 2)
self.auto_button.Show()
self.page = -1
self.lastRefresh = 0
@@ -135,6 +142,7 @@ class MobileCombatWheel(ui.Window):
if pressed != self.attack_pressed:
self.attack_pressed = pressed
self.attack_disc.SetStyle(widgets.STYLE_ATTACK_DOWN if pressed else widgets.STYLE_ATTACK)
self.auto_button.OnUpdate()
# 与 uitaskbar.TaskBar.OnUpdate 相同的 500 ms 刷新(冷却、数量、激活状态)
if app.GetGlobalTime() - self.lastRefresh > 500: