654 lines
24 KiB
C++
654 lines
24 KiB
C++
#pragma once
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "UIRenderCommands.h"
|
|
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
#include "platform/ScriptLib/PythonBoot.h"
|
|
#endif
|
|
|
|
class TouchController {
|
|
public:
|
|
struct ButtonDef {
|
|
int id; // 1 = attack, 2..7 = quick slots 1..6
|
|
int dik;
|
|
float x, y, radius;
|
|
const char* label;
|
|
uint32_t color_idle;
|
|
uint32_t color_pressed;
|
|
bool pressed = false;
|
|
int64_t finger_id = -1;
|
|
};
|
|
|
|
TouchController() {
|
|
init_buttons();
|
|
}
|
|
|
|
void set_enabled(bool enabled) { enabled_ = enabled; }
|
|
bool is_enabled() const { return enabled_; }
|
|
|
|
void update_screen_size(int width, int height) {
|
|
if (width <= 0 || height <= 0) return;
|
|
screen_w_ = width;
|
|
screen_h_ = height;
|
|
// Position joystick on lower-left
|
|
joystick_base_x_ = std::max(90.0f, float(width) * 0.12f);
|
|
joystick_base_y_ = float(height) - std::max(90.0f, float(height) * 0.22f);
|
|
if (!joystick_active_) {
|
|
joystick_knob_x_ = joystick_base_x_;
|
|
joystick_knob_y_ = joystick_base_y_;
|
|
}
|
|
layout_buttons();
|
|
}
|
|
|
|
// Called once per frame to maintain continuous analog movement
|
|
void update() {
|
|
if (!enabled_) return;
|
|
const bool controls_visible = gameplay_controls_visible();
|
|
if (!controls_visible) {
|
|
if (controls_were_visible_)
|
|
release_gameplay_controls();
|
|
controls_were_visible_ = false;
|
|
return;
|
|
}
|
|
controls_were_visible_ = true;
|
|
if (joystick_active_) {
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::SetMoveDirection(move_angle_, true);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// Handles finger touch down (norm_x, norm_y in 0.0 .. 1.0)
|
|
bool on_finger_down(int64_t finger_id, float norm_x, float norm_y) {
|
|
if (!enabled_) return false;
|
|
const float px = norm_x * float(screen_w_);
|
|
const float py = norm_y * float(screen_h_);
|
|
const bool controls_visible = gameplay_controls_visible();
|
|
|
|
// The mobile overlay owns only the movement and combat control regions.
|
|
if (controls_visible) {
|
|
const int btn_idx = find_button(px, py);
|
|
if (btn_idx >= 0) {
|
|
auto& btn = buttons_[btn_idx];
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
if (btn.id >= 2 && PythonBoot::TryAssignAttachedObjectToLocalQuickSlot(btn.id - 2))
|
|
return true;
|
|
#endif
|
|
btn.pressed = true;
|
|
btn.finger_id = finger_id;
|
|
trigger_button(btn.dik, true);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Everything else uses the unchanged 40250 UI and its normal mouse path.
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
if (PythonBoot::IsPointInsideActiveUI(int(px), int(py))) {
|
|
ui_touch_finger_id_ = finger_id;
|
|
PythonBoot::UIMouseMove(int(px), int(py));
|
|
PythonBoot::UIMouseButton(1, true, int(px), int(py));
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
// Start movement only in the gameplay phase.
|
|
if (controls_visible && norm_x < 0.40f && norm_y > 0.35f && !joystick_active_) {
|
|
joystick_active_ = true;
|
|
joystick_finger_id_ = finger_id;
|
|
joystick_base_x_ = px;
|
|
joystick_base_y_ = py;
|
|
joystick_knob_x_ = px;
|
|
joystick_knob_y_ = py;
|
|
update_joystick_motion(px, py);
|
|
return true;
|
|
}
|
|
|
|
if (!controls_visible)
|
|
return false;
|
|
|
|
// The remaining gameplay area controls camera and world selection.
|
|
if (camera_finger_id_ < 0) {
|
|
camera_finger_id_ = finger_id;
|
|
camera_last_x_ = px;
|
|
camera_last_y_ = py;
|
|
camera_start_x_ = px;
|
|
camera_start_y_ = py;
|
|
camera_dragged_ = false;
|
|
camera_down_time_ = get_time_sec();
|
|
return true;
|
|
} else if (pinch_finger2_ < 0) {
|
|
pinch_finger1_ = camera_finger_id_;
|
|
pinch_finger2_ = finger_id;
|
|
pinch_last_dist_ = std::hypot(px - camera_last_x_, py - camera_last_y_);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Handles finger motion
|
|
bool on_finger_motion(int64_t finger_id, float norm_x, float norm_y) {
|
|
if (!enabled_) return false;
|
|
const float px = norm_x * float(screen_w_);
|
|
const float py = norm_y * float(screen_h_);
|
|
|
|
// 1. UI Touch dragging (e.g. dragging item in inventory or scrollbar)
|
|
if (ui_touch_finger_id_ == finger_id) {
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::UIMouseMove(int(px), int(py));
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
// 2. Virtual Joystick finger
|
|
if (joystick_active_ && finger_id == joystick_finger_id_) {
|
|
update_joystick_motion(px, py);
|
|
return true;
|
|
}
|
|
|
|
// 3. Button drag tracking (check if finger slid off)
|
|
for (auto& btn : buttons_) {
|
|
if (btn.finger_id == finger_id) {
|
|
const float dist = std::hypot(px - btn.x, py - btn.y);
|
|
if (dist > btn.radius * 1.5f && btn.pressed) {
|
|
btn.pressed = false;
|
|
trigger_button(btn.dik, false);
|
|
} else if (dist <= btn.radius * 1.5f && !btn.pressed) {
|
|
btn.pressed = true;
|
|
trigger_button(btn.dik, true);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// 4. Two-finger pinch zoom
|
|
if (pinch_finger1_ >= 0 && pinch_finger2_ >= 0 &&
|
|
(finger_id == pinch_finger1_ || finger_id == pinch_finger2_)) {
|
|
const float cur_dist = std::hypot(px - camera_last_x_, py - camera_last_y_);
|
|
if (pinch_last_dist_ > 1.0f && cur_dist > 1.0f) {
|
|
const float delta_d = cur_dist - pinch_last_dist_;
|
|
if (std::abs(delta_d) > 2.0f) {
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::UIMouseWheel(int(delta_d * 8.0f));
|
|
#endif
|
|
pinch_last_dist_ = cur_dist;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 5. Single-finger camera drag
|
|
if (finger_id == camera_finger_id_) {
|
|
const float total_dist = std::hypot(px - camera_start_x_, py - camera_start_y_);
|
|
if (total_dist > 6.0f) {
|
|
if (!camera_dragged_) {
|
|
camera_dragged_ = true;
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::CameraBeginDrag(int(camera_start_x_), int(camera_start_y_));
|
|
#endif
|
|
}
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::CameraDrag(int(px), int(py));
|
|
#endif
|
|
}
|
|
camera_last_x_ = px;
|
|
camera_last_y_ = py;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Handles finger touch up
|
|
bool on_finger_up(int64_t finger_id, float norm_x, float norm_y) {
|
|
if (!enabled_) return false;
|
|
const float px = norm_x * float(screen_w_);
|
|
const float py = norm_y * float(screen_h_);
|
|
|
|
// 1. UI Touch release (e.g. dropped item in inventory or clicked button)
|
|
if (ui_touch_finger_id_ == finger_id) {
|
|
ui_touch_finger_id_ = -1;
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::UIMouseButton(1, false, int(px), int(py));
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
// 2. Joystick release
|
|
if (joystick_active_ && finger_id == joystick_finger_id_) {
|
|
joystick_active_ = false;
|
|
joystick_finger_id_ = -1;
|
|
joystick_knob_x_ = joystick_base_x_;
|
|
joystick_knob_y_ = joystick_base_y_;
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::SetMoveDirection(0.0f, false);
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
// 3. Button release
|
|
for (auto& btn : buttons_) {
|
|
if (btn.finger_id == finger_id) {
|
|
if (btn.pressed) {
|
|
btn.pressed = false;
|
|
trigger_button(btn.dik, false);
|
|
}
|
|
btn.finger_id = -1;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// 4. Pinch end
|
|
if (finger_id == pinch_finger1_ || finger_id == pinch_finger2_) {
|
|
pinch_finger1_ = -1;
|
|
pinch_finger2_ = -1;
|
|
pinch_last_dist_ = 0.0f;
|
|
if (finger_id == camera_finger_id_) camera_finger_id_ = -1;
|
|
return true;
|
|
}
|
|
|
|
// 5. Camera finger release
|
|
if (finger_id == camera_finger_id_) {
|
|
camera_finger_id_ = -1;
|
|
if (camera_dragged_) {
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::CameraEndDrag();
|
|
#endif
|
|
} else if ((get_time_sec() - camera_down_time_) < 0.35) {
|
|
// Short tap on 3D world: select target (mob, NPC, ground)
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::UIMouseMove(int(px), int(py));
|
|
PythonBoot::UIMouseButton(1, true, int(px), int(py));
|
|
PythonBoot::UIMouseButton(1, false, int(px), int(py));
|
|
#endif
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Overlay only the controls that have no practical desktop-UI touch equivalent.
|
|
void append_ui_commands(std::vector<UIRenderCommand>& commands) const {
|
|
if (!enabled_ || !gameplay_controls_visible()) return;
|
|
|
|
// Right-side attack and quick-slot buttons.
|
|
for (const auto& btn : buttons_) {
|
|
const uint32_t col = btn.pressed ? btn.color_pressed : btn.color_idle;
|
|
draw_filled_disc(commands, btn.x, btn.y, btn.radius, col);
|
|
draw_circle(commands, btn.x, btn.y, btn.radius * 0.85f, btn.pressed ? 0xFFFFFFFF : 0x70FFFFFF, 16);
|
|
|
|
const uint32_t icon_col = btn.pressed ? 0xFFFFFFFF : 0xDDFFFFFF;
|
|
const float r = btn.radius;
|
|
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
if (btn.id >= 2) {
|
|
const std::string skill_icon = PythonBoot::LocalQuickSlotSkillIcon(btn.id - 2);
|
|
if (!skill_icon.empty()) {
|
|
UIRenderCommand icon{};
|
|
icon.kind = UIRenderCommand::Image;
|
|
icon.x1 = btn.x - r * 0.68f;
|
|
icon.y1 = btn.y - r * 0.68f;
|
|
icon.x2 = btn.x + r * 0.68f;
|
|
icon.y2 = btn.y + r * 0.68f;
|
|
icon.argb = icon_col;
|
|
icon.text = skill_icon;
|
|
commands.push_back(std::move(icon));
|
|
continue;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
switch (btn.id) {
|
|
case 1: { // ATK: crossed swords
|
|
const float s = r * 0.35f;
|
|
draw_line(commands, btn.x - s, btn.y - s, btn.x + s, btn.y + s, icon_col);
|
|
draw_line(commands, btn.x + s, btn.y - s, btn.x - s, btn.y + s, icon_col);
|
|
const float g = s * 0.35f;
|
|
draw_line(commands, btn.x - s*0.4f - g, btn.y - s*0.4f + g, btn.x - s*0.4f + g, btn.y - s*0.4f - g, icon_col);
|
|
draw_line(commands, btn.x + s*0.4f - g, btn.y - s*0.4f - g, btn.x + s*0.4f + g, btn.y - s*0.4f + g, icon_col);
|
|
break;
|
|
}
|
|
case 2: { // S1: I
|
|
const float h = r * 0.35f;
|
|
draw_line(commands, btn.x, btn.y - h, btn.x, btn.y + h, icon_col);
|
|
draw_line(commands, btn.x - 4.0f, btn.y - h, btn.x + 4.0f, btn.y - h, icon_col);
|
|
draw_line(commands, btn.x - 4.0f, btn.y + h, btn.x + 4.0f, btn.y + h, icon_col);
|
|
break;
|
|
}
|
|
case 3: { // S2: II
|
|
const float h = r * 0.35f;
|
|
draw_line(commands, btn.x - 4.0f, btn.y - h, btn.x - 4.0f, btn.y + h, icon_col);
|
|
draw_line(commands, btn.x + 4.0f, btn.y - h, btn.x + 4.0f, btn.y + h, icon_col);
|
|
break;
|
|
}
|
|
case 4: { // S3: III
|
|
const float h = r * 0.35f;
|
|
draw_line(commands, btn.x - 6.0f, btn.y - h, btn.x - 6.0f, btn.y + h, icon_col);
|
|
draw_line(commands, btn.x, btn.y - h, btn.x, btn.y + h, icon_col);
|
|
draw_line(commands, btn.x + 6.0f, btn.y - h, btn.x + 6.0f, btn.y + h, icon_col);
|
|
break;
|
|
}
|
|
case 5: { // S4: IV
|
|
const float h = r * 0.35f;
|
|
draw_line(commands, btn.x - 7.0f, btn.y - h, btn.x - 7.0f, btn.y + h, icon_col);
|
|
draw_line(commands, btn.x, btn.y - h, btn.x + 7.0f, btn.y + h, icon_col);
|
|
draw_line(commands, btn.x + 14.0f, btn.y - h, btn.x + 7.0f, btn.y + h, icon_col);
|
|
break;
|
|
}
|
|
case 6: { // S5: V
|
|
const float h = r * 0.35f;
|
|
draw_line(commands, btn.x - 8.0f, btn.y - h, btn.x, btn.y + h, icon_col);
|
|
draw_line(commands, btn.x + 8.0f, btn.y - h, btn.x, btn.y + h, icon_col);
|
|
break;
|
|
}
|
|
case 7: { // S6: VI
|
|
const float h = r * 0.35f;
|
|
draw_line(commands, btn.x - 11.0f, btn.y - h, btn.x - 3.0f, btn.y + h, icon_col);
|
|
draw_line(commands, btn.x + 5.0f, btn.y - h, btn.x - 3.0f, btn.y + h, icon_col);
|
|
draw_line(commands, btn.x + 11.0f, btn.y - h, btn.x + 11.0f, btn.y + h, icon_col);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Left-side movement joystick.
|
|
draw_circle(commands, joystick_base_x_, joystick_base_y_, joystick_radius_, 0x8080C0FF, 24);
|
|
draw_circle(commands, joystick_base_x_, joystick_base_y_, joystick_radius_ * 0.45f, 0x4080C0FF, 16);
|
|
draw_line(commands, joystick_base_x_ - joystick_radius_, joystick_base_y_,
|
|
joystick_base_x_ - joystick_radius_ + 8.0f, joystick_base_y_, 0x90FFFFFF);
|
|
draw_line(commands, joystick_base_x_ + joystick_radius_ - 8.0f, joystick_base_y_,
|
|
joystick_base_x_ + joystick_radius_, joystick_base_y_, 0x90FFFFFF);
|
|
draw_line(commands, joystick_base_x_, joystick_base_y_ - joystick_radius_,
|
|
joystick_base_x_, joystick_base_y_ - joystick_radius_ + 8.0f, 0x90FFFFFF);
|
|
draw_line(commands, joystick_base_x_, joystick_base_y_ + joystick_radius_ - 8.0f,
|
|
joystick_base_x_, joystick_base_y_ + joystick_radius_, 0x90FFFFFF);
|
|
|
|
if (joystick_active_) {
|
|
draw_line(commands, joystick_base_x_, joystick_base_y_, joystick_knob_x_, joystick_knob_y_, 0xB000FFFF);
|
|
}
|
|
const uint32_t knob_color = joystick_active_ ? 0xB040A0FF : 0x6040A0FF;
|
|
draw_filled_disc(commands, joystick_knob_x_, joystick_knob_y_, joystick_knob_radius_, knob_color);
|
|
draw_circle(commands, joystick_knob_x_, joystick_knob_y_, joystick_knob_radius_ * 0.5f, 0x80FFFFFF, 12);
|
|
}
|
|
|
|
// Desktop mouse testing simulation
|
|
bool on_mouse_button(int button, bool pressed, int x, int y) {
|
|
if (!enabled_) return false;
|
|
const float norm_x = float(x) / float(screen_w_);
|
|
const float norm_y = float(y) / float(screen_h_);
|
|
if (pressed) {
|
|
if (button == 1) {
|
|
return on_finger_down(101, norm_x, norm_y);
|
|
}
|
|
return false;
|
|
} else {
|
|
if (button == 1) {
|
|
return on_finger_up(101, norm_x, norm_y);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool on_mouse_motion(int x, int y) {
|
|
if (!enabled_) return false;
|
|
const float norm_x = float(x) / float(screen_w_);
|
|
const float norm_y = float(y) / float(screen_h_);
|
|
bool handled = false;
|
|
if (ui_touch_finger_id_ == 101) {
|
|
handled |= on_finger_motion(101, norm_x, norm_y);
|
|
}
|
|
if (joystick_active_ && joystick_finger_id_ == 101) {
|
|
handled |= on_finger_motion(101, norm_x, norm_y);
|
|
}
|
|
if (camera_finger_id_ == 101) {
|
|
handled |= on_finger_motion(101, norm_x, norm_y);
|
|
}
|
|
return handled;
|
|
}
|
|
|
|
private:
|
|
bool gameplay_controls_visible() const {
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
return !PythonBoot::CurrentMapName().empty();
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
void release_gameplay_controls() {
|
|
if (joystick_active_) {
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::SetMoveDirection(0.0f, false);
|
|
#endif
|
|
}
|
|
joystick_active_ = false;
|
|
joystick_finger_id_ = -1;
|
|
joystick_knob_x_ = joystick_base_x_;
|
|
joystick_knob_y_ = joystick_base_y_;
|
|
for (auto& btn : buttons_) {
|
|
if (btn.pressed)
|
|
trigger_button(btn.dik, false);
|
|
btn.pressed = false;
|
|
btn.finger_id = -1;
|
|
}
|
|
if (camera_dragged_) {
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::CameraEndDrag();
|
|
#endif
|
|
}
|
|
camera_finger_id_ = -1;
|
|
camera_dragged_ = false;
|
|
pinch_finger1_ = -1;
|
|
pinch_finger2_ = -1;
|
|
pinch_last_dist_ = 0.0f;
|
|
}
|
|
|
|
void init_buttons() {
|
|
buttons_.clear();
|
|
// Lower-right combat controls. All menus and status UI remain the original 40250 UI.
|
|
buttons_.push_back({1, 0x39, 0, 0, 42.0f, "ATK", 0x80D48820, 0xD0FFB040});
|
|
buttons_.push_back({2, 0x02, 0, 0, 26.0f, "S1", 0x803060C0, 0xD05080FF});
|
|
buttons_.push_back({3, 0x03, 0, 0, 26.0f, "S2", 0x80903090, 0xD0D050D0});
|
|
buttons_.push_back({4, 0x04, 0, 0, 26.0f, "S3", 0x80309060, 0xD050D080});
|
|
buttons_.push_back({5, 0x05, 0, 0, 26.0f, "S4", 0x80906030, 0xD0D08050});
|
|
buttons_.push_back({6, 0x06, 0, 0, 26.0f, "S5", 0x80603090, 0xD08050D0});
|
|
buttons_.push_back({7, 0x07, 0, 0, 26.0f, "S6", 0x80308090, 0xD050C0D0});
|
|
}
|
|
|
|
void layout_buttons() {
|
|
const float W = float(screen_w_);
|
|
const float H = float(screen_h_);
|
|
for (auto& btn : buttons_) {
|
|
switch (btn.id) {
|
|
case 1:
|
|
btn.x = W - 75.0f;
|
|
btn.y = H - 85.0f;
|
|
btn.radius = std::min(46.0f, H * 0.12f);
|
|
break;
|
|
case 2:
|
|
btn.x = W - 360.0f;
|
|
btn.y = H - 75.0f;
|
|
btn.radius = std::min(28.0f, H * 0.08f);
|
|
break;
|
|
case 3:
|
|
btn.x = W - 295.0f;
|
|
btn.y = H - 75.0f;
|
|
btn.radius = std::min(28.0f, H * 0.08f);
|
|
break;
|
|
case 4:
|
|
btn.x = W - 230.0f;
|
|
btn.y = H - 75.0f;
|
|
btn.radius = std::min(28.0f, H * 0.08f);
|
|
break;
|
|
case 5:
|
|
btn.x = W - 165.0f;
|
|
btn.y = H - 85.0f;
|
|
btn.radius = std::min(28.0f, H * 0.08f);
|
|
break;
|
|
case 6:
|
|
btn.x = W - 125.0f;
|
|
btn.y = H - 155.0f;
|
|
btn.radius = std::min(28.0f, H * 0.08f);
|
|
break;
|
|
case 7:
|
|
btn.x = W - 75.0f;
|
|
btn.y = H - 225.0f;
|
|
btn.radius = std::min(28.0f, H * 0.08f);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int find_button(float x, float y) {
|
|
for (size_t i = 0; i < buttons_.size(); ++i) {
|
|
const auto& btn = buttons_[i];
|
|
const float dist = std::hypot(x - btn.x, y - btn.y);
|
|
if (dist <= btn.radius * 1.25f) {
|
|
return int(i);
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void trigger_button(int dik, bool pressed) {
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
if (dik == 0x39) {
|
|
PythonBoot::SetAttackKey(pressed);
|
|
}
|
|
if (dik >= 0x02 && dik <= 0x07) {
|
|
if (pressed)
|
|
PythonBoot::UseLocalQuickSlot(dik - 0x02);
|
|
return;
|
|
}
|
|
if (dik != 0) {
|
|
PythonBoot::UIKey(dik, pressed);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void update_joystick_motion(float px, float py) {
|
|
const float dx = px - joystick_base_x_;
|
|
const float dy = py - joystick_base_y_;
|
|
const float dist = std::hypot(dx, dy);
|
|
|
|
if (dist <= joystick_radius_) {
|
|
joystick_knob_x_ = px;
|
|
joystick_knob_y_ = py;
|
|
} else if (dist > 0.0f) {
|
|
joystick_knob_x_ = joystick_base_x_ + (dx / dist) * joystick_radius_;
|
|
joystick_knob_y_ = joystick_base_y_ + (dy / dist) * joystick_radius_;
|
|
}
|
|
|
|
if (dist > 8.0f) {
|
|
const float rad = std::atan2(-dx, -dy);
|
|
move_angle_ = rad * 180.0f / 3.14159265358979323846f;
|
|
if (move_angle_ < 0.0f) move_angle_ += 360.0f;
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::SetMoveDirection(move_angle_, true);
|
|
#endif
|
|
} else {
|
|
#ifdef MT_NATIVE_HAS_LIVE_CLIENT
|
|
PythonBoot::SetMoveDirection(0.0f, false);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static void draw_line(std::vector<UIRenderCommand>& commands,
|
|
float x1, float y1, float x2, float y2, uint32_t argb) {
|
|
UIRenderCommand cmd{};
|
|
cmd.kind = UIRenderCommand::Line;
|
|
cmd.x1 = x1; cmd.y1 = y1;
|
|
cmd.x2 = x2; cmd.y2 = y2;
|
|
cmd.argb = argb;
|
|
commands.push_back(cmd);
|
|
}
|
|
|
|
static void draw_rect_bar(std::vector<UIRenderCommand>& commands,
|
|
float x1, float y1, float x2, float y2, uint32_t argb) {
|
|
UIRenderCommand bar{};
|
|
bar.kind = UIRenderCommand::Bar;
|
|
bar.x1 = x1; bar.y1 = y1;
|
|
bar.x2 = x2; bar.y2 = y2;
|
|
bar.argb = argb;
|
|
commands.push_back(bar);
|
|
}
|
|
|
|
static void draw_rect_lines(std::vector<UIRenderCommand>& commands,
|
|
float x1, float y1, float x2, float y2, uint32_t argb) {
|
|
draw_line(commands, x1, y1, x2, y1, argb);
|
|
draw_line(commands, x2, y1, x2, y2, argb);
|
|
draw_line(commands, x2, y2, x1, y2, argb);
|
|
draw_line(commands, x1, y2, x1, y1, argb);
|
|
}
|
|
|
|
static void draw_circle(std::vector<UIRenderCommand>& commands,
|
|
float cx, float cy, float radius, uint32_t argb, int segments = 16) {
|
|
const float step = 2.0f * 3.14159265f / float(segments);
|
|
for (int i = 0; i < segments; ++i) {
|
|
const float a1 = float(i) * step;
|
|
const float a2 = float(i + 1) * step;
|
|
draw_line(commands,
|
|
cx + std::cos(a1) * radius, cy + std::sin(a1) * radius,
|
|
cx + std::cos(a2) * radius, cy + std::sin(a2) * radius,
|
|
argb);
|
|
}
|
|
}
|
|
|
|
static void draw_filled_disc(std::vector<UIRenderCommand>& commands,
|
|
float cx, float cy, float radius, uint32_t argb) {
|
|
// Base rectangular fill
|
|
draw_rect_bar(commands, cx - radius * 0.65f, cy - radius * 0.65f, cx + radius * 0.65f, cy + radius * 0.65f, (argb & 0x00FFFFFF) | 0x55000000);
|
|
// Cross fills for roundness
|
|
draw_rect_bar(commands, cx - radius * 0.85f, cy - radius * 0.35f, cx + radius * 0.85f, cy + radius * 0.35f, (argb & 0x00FFFFFF) | 0x55000000);
|
|
draw_rect_bar(commands, cx - radius * 0.35f, cy - radius * 0.85f, cx + radius * 0.35f, cy + radius * 0.85f, (argb & 0x00FFFFFF) | 0x55000000);
|
|
// Border rings
|
|
draw_circle(commands, cx, cy, radius, argb, 20);
|
|
draw_circle(commands, cx, cy, radius - 1.0f, (argb & 0x00FFFFFF) | 0x40000000, 20);
|
|
}
|
|
|
|
static double get_time_sec() {
|
|
using namespace std::chrono;
|
|
return duration_cast<duration<double>>(steady_clock::now().time_since_epoch()).count();
|
|
}
|
|
|
|
bool enabled_ = false;
|
|
int screen_w_ = 1280;
|
|
int screen_h_ = 720;
|
|
|
|
bool controls_were_visible_ = false;
|
|
int64_t ui_touch_finger_id_ = -1;
|
|
|
|
bool joystick_active_ = false;
|
|
int64_t joystick_finger_id_ = -1;
|
|
float joystick_base_x_ = 140.0f;
|
|
float joystick_base_y_ = 580.0f;
|
|
float joystick_knob_x_ = 140.0f;
|
|
float joystick_knob_y_ = 580.0f;
|
|
float joystick_radius_ = 65.0f;
|
|
float joystick_knob_radius_ = 28.0f;
|
|
float move_angle_ = 0.0f;
|
|
|
|
int64_t camera_finger_id_ = -1;
|
|
float camera_start_x_ = 0.0f;
|
|
float camera_start_y_ = 0.0f;
|
|
float camera_last_x_ = 0.0f;
|
|
float camera_last_y_ = 0.0f;
|
|
double camera_down_time_ = 0.0;
|
|
bool camera_dragged_ = false;
|
|
|
|
int64_t pinch_finger1_ = -1;
|
|
int64_t pinch_finger2_ = -1;
|
|
float pinch_last_dist_ = 0.0f;
|
|
|
|
std::vector<ButtonDef> buttons_;
|
|
};
|