Port the EterPythonLib CSlotWindow/CGridSlotWindow mouse handlers (select, drop, use, right click, tooltips, grid picking/CheckMoving) and CWindowManager IsDragging/right button, which were missing so item interaction did not work on desktop either. app.SetMouseHandler now renders the attached icon, app.IsPressed reads real key state, desktop double clicks reach the window manager. The touch router maps UI touches to the original mouse: tap = click at the touch-down point, drag = press-and-drag, double tap = double click, long press on an item slot = touch.SetLongPressEvent, which opens the ui_mobile_actions item sheet (use / split / quick slot via virtual Shift/Ctrl). New ava2.inventory_touch test drives uiinventory.py. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
270 lines
10 KiB
C++
270 lines
10 KiB
C++
// TouchRouter finger ownership: UI, joystick, attack, camera drag / pinch / tap, phases, cancel,
|
|
// and the UI gestures (tap, double tap, drag, long press).
|
|
#include "app/input/touch_router.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using namespace ava2::input;
|
|
|
|
namespace {
|
|
|
|
struct RecordingSink : TouchSink {
|
|
// One UI window: a 200x100 box at (500, 50).
|
|
bool IsUiAt(float x, float y) override { return x >= 500 && x < 700 && y >= 50 && y < 150; }
|
|
void UiMouseMove(float x, float y) override { log("move", x, y); }
|
|
void UiMouseDown(float x, float y) override { log("down", x, y); }
|
|
void UiMouseUp(float x, float y) override { log("up", x, y); }
|
|
void UiDoubleClick(float x, float y) override { log("dbl", x, y); }
|
|
bool UiLongPress(float x, float y) override { log("long", x, y); return take_long_press; }
|
|
void WorldTap(float x, float y) override { log("tap", x, y); }
|
|
void Joystick(bool active, float x, float y) override { joy_active = active; joy_x = x; joy_y = y; }
|
|
void Attack(bool pressed) override { attack = pressed; ++attack_calls; }
|
|
void CameraRotate(float dx, float dy) override { rot_x += dx; rot_y += dy; }
|
|
void CameraZoom(float ratio) override { zoom *= ratio; }
|
|
|
|
void log(const char* what, float x, float y) {
|
|
events.push_back(std::string(what) + " " + std::to_string(int(x)) + "," + std::to_string(int(y)));
|
|
}
|
|
std::vector<std::string> events;
|
|
bool joy_active = false, attack = false, take_long_press = true;
|
|
int attack_calls = 0;
|
|
float joy_x = 0, joy_y = 0, rot_x = 0, rot_y = 0, zoom = 1;
|
|
};
|
|
|
|
void expect(bool ok, const char* what) {
|
|
if (!ok) throw std::runtime_error(what);
|
|
}
|
|
bool near(float a, float b) { return std::fabs(a - b) < 0.01f; }
|
|
|
|
TouchLayout layout() {
|
|
TouchLayout l;
|
|
l.screen_w = 1280;
|
|
l.screen_h = 720;
|
|
l.joy_x = 0; l.joy_y = 360; l.joy_w = 500; l.joy_h = 360;
|
|
l.joy_radius = 100;
|
|
l.joy_dead_zone = 0.2f;
|
|
l.attack_x = 1180; l.attack_y = 620; l.attack_r = 80;
|
|
l.tap_slop = 10;
|
|
l.tap_ms = 300;
|
|
l.double_tap_ms = 300;
|
|
l.double_tap_slop = 30;
|
|
l.long_press_ms = 450;
|
|
return l;
|
|
}
|
|
|
|
void ui_outside_game() {
|
|
RecordingSink sink;
|
|
TouchRouter r;
|
|
r.SetSink(&sink);
|
|
r.SetLayout(layout());
|
|
// Not in game: a finger anywhere, even on the joystick area, is the UI pointer.
|
|
r.FingerDown(0, 100, 600, 0);
|
|
r.FingerDown(1, 900, 300, 0); // second finger ignored while the first holds the pointer
|
|
r.FingerMove(0, 110, 610, 10);
|
|
r.FingerUp(1, 900, 300, 20);
|
|
r.FingerUp(0, 120, 620, 30);
|
|
// The pointer hovers at once; moving past the slop presses the button where the finger landed.
|
|
const std::vector<std::string> want{"move 100,600", "move 100,600", "down 100,600", "move 110,610",
|
|
"move 120,620", "up 120,620"};
|
|
expect(sink.events == want, "ui_outside_game events");
|
|
expect(!sink.joy_active && sink.attack_calls == 0, "ui_outside_game world controls");
|
|
expect(r.FingerCount() == 0, "ui_outside_game fingers");
|
|
}
|
|
|
|
void joystick_attack_camera_together() {
|
|
RecordingSink sink;
|
|
TouchRouter r;
|
|
r.SetSink(&sink);
|
|
r.SetLayout(layout());
|
|
r.SetWorldEnabled(true);
|
|
|
|
r.FingerDown(0, 200, 500, 0); // joystick, base at the touch point
|
|
expect(sink.joy_active && near(sink.joy_x, 0) && near(sink.joy_y, 0), "joystick centred");
|
|
r.FingerMove(0, 210, 500, 5); // inside the dead zone
|
|
expect(near(sink.joy_x, 0), "joystick dead zone");
|
|
r.FingerMove(0, 400, 500, 10); // beyond the radius: clamped to full right
|
|
expect(near(sink.joy_x, 1) && near(sink.joy_y, 0), "joystick full right");
|
|
expect(near(r.GetJoystick().knob_x, 300), "joystick knob clamped");
|
|
|
|
r.FingerDown(1, 1180, 620, 12); // attack
|
|
expect(sink.attack && r.IsAttackPressed(), "attack pressed");
|
|
|
|
r.FingerDown(2, 900, 300, 15); // camera
|
|
r.FingerMove(2, 905, 300, 16); // within slop: nothing yet
|
|
expect(near(sink.rot_x, 0), "camera slop");
|
|
r.FingerMove(2, 930, 290, 17);
|
|
expect(near(sink.rot_x, 30) && near(sink.rot_y, -10), "camera drag includes slop");
|
|
r.FingerMove(2, 940, 290, 18);
|
|
expect(near(sink.rot_x, 40), "camera drag delta");
|
|
r.FingerUp(2, 940, 290, 19);
|
|
expect(sink.events.empty(), "dragged camera finger is not a tap");
|
|
|
|
r.FingerMove(0, 200, 400, 20); // joystick straight up
|
|
expect(near(sink.joy_x, 0) && near(sink.joy_y, -1), "joystick up");
|
|
r.FingerUp(1, 1180, 620, 25);
|
|
expect(!sink.attack, "attack released");
|
|
r.FingerUp(0, 200, 400, 30);
|
|
expect(!sink.joy_active && !r.GetJoystick().active, "joystick released");
|
|
}
|
|
|
|
void tap_pinch_and_ui_in_game() {
|
|
RecordingSink sink;
|
|
TouchRouter r;
|
|
r.SetSink(&sink);
|
|
r.SetLayout(layout());
|
|
r.SetWorldEnabled(true);
|
|
|
|
r.FingerDown(0, 800, 300, 0);
|
|
r.FingerMove(0, 804, 303, 50);
|
|
r.FingerUp(0, 804, 303, 100);
|
|
expect(sink.events.size() == 1 && sink.events[0] == "tap 804,303", "short tap clicks the world");
|
|
|
|
sink.events.clear();
|
|
r.FingerDown(0, 800, 300, 200);
|
|
r.FingerUp(0, 800, 300, 600); // held too long
|
|
expect(sink.events.empty(), "long press is not a tap");
|
|
|
|
r.FingerDown(0, 800, 300, 700);
|
|
r.FingerDown(1, 900, 300, 700); // pinch: distance 100 -> 200
|
|
r.FingerMove(1, 1000, 300, 710);
|
|
expect(near(sink.zoom, 2), "pinch zoom ratio");
|
|
r.FingerUp(1, 1000, 300, 720);
|
|
r.FingerUp(0, 800, 300, 730);
|
|
expect(sink.events.empty() && near(sink.rot_x, 0), "pinch fingers neither tap nor rotate");
|
|
|
|
// UI windows win over world controls, also inside the game.
|
|
r.FingerDown(3, 600, 100, 800);
|
|
r.FingerUp(3, 600, 100, 810);
|
|
const std::vector<std::string> want{"move 600,100", "move 600,100", "down 600,100", "up 600,100"};
|
|
expect(sink.events == want, "ui click in game");
|
|
}
|
|
|
|
void phase_change_and_cancel() {
|
|
RecordingSink sink;
|
|
TouchRouter r;
|
|
r.SetSink(&sink);
|
|
r.SetLayout(layout());
|
|
r.SetWorldEnabled(true);
|
|
r.FingerDown(0, 200, 500, 0);
|
|
r.FingerDown(1, 1180, 620, 0);
|
|
r.FingerDown(2, 600, 100, 0); // UI
|
|
r.FingerMove(2, 620, 100, 1); // dragging: the button is down
|
|
r.SetWorldEnabled(false); // leaving the game drops world fingers, keeps the UI finger
|
|
expect(!sink.joy_active && !sink.attack && r.FingerCount() == 1, "phase change releases world fingers");
|
|
r.FingerMove(0, 300, 500, 5); // a dropped finger is ignored
|
|
expect(!sink.joy_active, "dropped finger ignored");
|
|
sink.events.clear();
|
|
r.CancelAll();
|
|
expect(sink.events.size() == 1 && sink.events[0] == "up 620,100", "cancel releases the UI button");
|
|
expect(r.FingerCount() == 0, "cancel clears fingers");
|
|
|
|
r.SetWorldEnabled(true);
|
|
sink.events.clear();
|
|
r.FingerDown(5, 800, 300, 0);
|
|
r.CancelAll();
|
|
expect(sink.events.empty(), "cancelled camera finger does not tap");
|
|
|
|
// A UI finger that never pressed the button releases nothing.
|
|
r.FingerDown(6, 600, 100, 0);
|
|
sink.events.clear();
|
|
r.CancelAll();
|
|
expect(sink.events.empty(), "cancelled pending UI finger sends nothing");
|
|
}
|
|
|
|
void ui_gestures() {
|
|
RecordingSink sink;
|
|
TouchRouter r;
|
|
r.SetSink(&sink);
|
|
r.SetLayout(layout());
|
|
r.SetWorldEnabled(true);
|
|
using V = std::vector<std::string>;
|
|
|
|
// Double tap: the second tap is down + double click + up (the original mouse sequence).
|
|
r.FingerDown(0, 600, 100, 1000);
|
|
r.Update(1050);
|
|
r.FingerUp(0, 602, 101, 1080);
|
|
r.FingerDown(0, 610, 105, 1250);
|
|
r.FingerUp(0, 610, 105, 1300);
|
|
expect(sink.events == V{"move 600,100", "move 600,100", "down 600,100", "up 600,100",
|
|
"move 610,105", "move 610,105", "down 610,105", "dbl 610,105", "up 610,105"},
|
|
"double tap");
|
|
|
|
// A third tap starts a new pair.
|
|
sink.events.clear();
|
|
r.FingerDown(0, 610, 105, 1400);
|
|
r.FingerUp(0, 610, 105, 1450);
|
|
expect(sink.events == V{"move 610,105", "move 610,105", "down 610,105", "up 610,105"}, "third tap is single");
|
|
|
|
// Too late or too far: two single clicks.
|
|
sink.events.clear();
|
|
r.FingerDown(0, 620, 100, 1900); // 450 ms after the last tap
|
|
r.FingerUp(0, 620, 100, 1950);
|
|
r.FingerDown(0, 680, 100, 2000); // 60 px away
|
|
r.FingerUp(0, 680, 100, 2050);
|
|
expect(std::count(sink.events.begin(), sink.events.end(), std::string("dbl 620,100")) == 0 &&
|
|
std::count(sink.events.begin(), sink.events.end(), std::string("dbl 680,100")) == 0 && sink.events.size() == 8,
|
|
"late or distant taps do not pair");
|
|
|
|
// Long press taken by the host: nothing else happens, not even a button release.
|
|
sink.events.clear();
|
|
r.FingerDown(0, 600, 100, 3000);
|
|
r.Update(3400);
|
|
expect(sink.events == V{"move 600,100"}, "no long press before long_press_ms");
|
|
r.FingerMove(0, 603, 100, 3420);
|
|
r.Update(3460);
|
|
r.FingerMove(0, 660, 100, 3500);
|
|
r.FingerUp(0, 660, 100, 3600);
|
|
expect(sink.events == V{"move 600,100", "long 603,100"}, "taken long press swallows the touch");
|
|
|
|
// Long press the host declines: the button goes down and the touch continues as a press.
|
|
sink.events.clear();
|
|
sink.take_long_press = false;
|
|
r.FingerDown(0, 600, 100, 4000);
|
|
r.Update(4500);
|
|
r.FingerMove(0, 640, 100, 4600);
|
|
r.FingerUp(0, 640, 100, 4700);
|
|
expect(sink.events == V{"move 600,100", "long 600,100", "move 600,100", "down 600,100", "move 640,100",
|
|
"move 640,100", "up 640,100"},
|
|
"declined long press becomes a press");
|
|
|
|
// A drag never becomes a long press.
|
|
sink.events.clear();
|
|
r.FingerDown(0, 600, 100, 5000);
|
|
r.FingerMove(0, 650, 100, 5100);
|
|
r.Update(5600);
|
|
r.FingerUp(0, 650, 100, 5700);
|
|
expect(sink.events == V{"move 600,100", "move 600,100", "down 600,100", "move 650,100", "move 650,100",
|
|
"up 650,100"},
|
|
"drag");
|
|
}
|
|
|
|
void default_layout() {
|
|
const TouchLayout l = TouchLayout::ForScreen(1600, 720);
|
|
expect(l.joy_x == 0 && l.joy_w > 0 && l.joy_y + l.joy_h <= 720.5f, "default joystick area");
|
|
expect(l.attack_x + l.attack_r <= 1600 && l.attack_y + l.attack_r <= 720, "default attack on screen");
|
|
expect(l.attack_x - l.attack_r > l.joy_x + l.joy_w, "attack right of the joystick area");
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main() {
|
|
try {
|
|
ui_outside_game();
|
|
joystick_attack_camera_together();
|
|
tap_pinch_and_ui_in_game();
|
|
phase_change_and_cancel();
|
|
ui_gestures();
|
|
default_layout();
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "touch_router_test: " << e.what() << '\n';
|
|
return 1;
|
|
}
|
|
std::cout << "touch_router_test: ok\n";
|
|
return 0;
|
|
}
|