+
+ touch_info[i].touched = TRUE;
+ touch_info[i].finger_id = event->fingerId;
+ touch_info[i].counter = Counter();
+ touch_info[i].key = key;
+ touch_info[i].action = grid_button_action;
+ }
+ else
+ {
+ if (touch_info[i].key != KSYM_UNDEFINED)
+ {
+ HandleKey(touch_info[i].key, KEY_RELEASED);
+
+ Error(ERR_DEBUG, "=> key == '%s', key_status == '%s' [slot %d] [4]",
+ getKeyNameFromKey(touch_info[i].key), "KEY_RELEASED", i);
+ }
+
+ touch_info[i].touched = FALSE;
+ touch_info[i].finger_id = 0;
+ touch_info[i].counter = 0;
+ touch_info[i].key = 0;
+ touch_info[i].action = JOY_NO_ACTION;
+ }
+ }
+}
+
+static void HandleFingerEvent_WipeGestures(FingerEvent *event)
+{
+ static Key motion_key_x = KSYM_UNDEFINED;
+ static Key motion_key_y = KSYM_UNDEFINED;
+ static Key button_key = KSYM_UNDEFINED;
+ static float motion_x1, motion_y1;
+ static float button_x1, button_y1;
+ static SDL_FingerID motion_id = -1;
+ static SDL_FingerID button_id = -1;
+ int move_trigger_distance_percent = setup.touch.move_distance;
+ int drop_trigger_distance_percent = setup.touch.drop_distance;
+ float move_trigger_distance = (float)move_trigger_distance_percent / 100;
+ float drop_trigger_distance = (float)drop_trigger_distance_percent / 100;
+ float event_x = event->x;
+ float event_y = event->y;
+
+ if (event->type == EVENT_FINGERPRESS)
+ {
+ if (event_x > 1.0 / 3.0)
+ {
+ // motion area
+
+ motion_id = event->fingerId;
+
+ motion_x1 = event_x;
+ motion_y1 = event_y;
+
+ motion_key_x = KSYM_UNDEFINED;
+ motion_key_y = KSYM_UNDEFINED;
+
+ Error(ERR_DEBUG, "---------- MOVE STARTED (WAIT) ----------");
+ }
+ else
+ {
+ // button area
+
+ button_id = event->fingerId;
+
+ button_x1 = event_x;
+ button_y1 = event_y;
+
+ button_key = setup.input[0].key.snap;
+
+ HandleKey(button_key, KEY_PRESSED);
+
+ Error(ERR_DEBUG, "---------- SNAP STARTED ----------");
+ }
+ }
+ else if (event->type == EVENT_FINGERRELEASE)
+ {
+ if (event->fingerId == motion_id)
+ {
+ motion_id = -1;
+
+ if (motion_key_x != KSYM_UNDEFINED)
+ HandleKey(motion_key_x, KEY_RELEASED);
+ if (motion_key_y != KSYM_UNDEFINED)
+ HandleKey(motion_key_y, KEY_RELEASED);
+
+ motion_key_x = KSYM_UNDEFINED;
+ motion_key_y = KSYM_UNDEFINED;
+
+ Error(ERR_DEBUG, "---------- MOVE STOPPED ----------");
+ }
+ else if (event->fingerId == button_id)
+ {
+ button_id = -1;
+
+ if (button_key != KSYM_UNDEFINED)
+ HandleKey(button_key, KEY_RELEASED);
+
+ button_key = KSYM_UNDEFINED;
+
+ Error(ERR_DEBUG, "---------- SNAP STOPPED ----------");
+ }
+ }
+ else if (event->type == EVENT_FINGERMOTION)
+ {
+ if (event->fingerId == motion_id)
+ {
+ float distance_x = ABS(event_x - motion_x1);
+ float distance_y = ABS(event_y - motion_y1);
+ Key new_motion_key_x = (event_x < motion_x1 ? setup.input[0].key.left :
+ event_x > motion_x1 ? setup.input[0].key.right :
+ KSYM_UNDEFINED);
+ Key new_motion_key_y = (event_y < motion_y1 ? setup.input[0].key.up :
+ event_y > motion_y1 ? setup.input[0].key.down :
+ KSYM_UNDEFINED);
+
+ if (distance_x < move_trigger_distance / 2 ||
+ distance_x < distance_y)
+ new_motion_key_x = KSYM_UNDEFINED;
+
+ if (distance_y < move_trigger_distance / 2 ||
+ distance_y < distance_x)
+ new_motion_key_y = KSYM_UNDEFINED;
+
+ if (distance_x > move_trigger_distance ||
+ distance_y > move_trigger_distance)
+ {
+ if (new_motion_key_x != motion_key_x)
+ {
+ if (motion_key_x != KSYM_UNDEFINED)
+ HandleKey(motion_key_x, KEY_RELEASED);
+ if (new_motion_key_x != KSYM_UNDEFINED)
+ HandleKey(new_motion_key_x, KEY_PRESSED);
+ }
+
+ if (new_motion_key_y != motion_key_y)
+ {
+ if (motion_key_y != KSYM_UNDEFINED)
+ HandleKey(motion_key_y, KEY_RELEASED);
+ if (new_motion_key_y != KSYM_UNDEFINED)
+ HandleKey(new_motion_key_y, KEY_PRESSED);
+ }
+
+ motion_x1 = event_x;
+ motion_y1 = event_y;
+
+ motion_key_x = new_motion_key_x;
+ motion_key_y = new_motion_key_y;
+
+ Error(ERR_DEBUG, "---------- MOVE STARTED (MOVE) ----------");
+ }
+ }
+ else if (event->fingerId == button_id)
+ {
+ float distance_x = ABS(event_x - button_x1);
+ float distance_y = ABS(event_y - button_y1);
+
+ if (distance_x < drop_trigger_distance / 2 &&
+ distance_y > drop_trigger_distance)
+ {
+ if (button_key == setup.input[0].key.snap)
+ HandleKey(button_key, KEY_RELEASED);
+
+ button_x1 = event_x;
+ button_y1 = event_y;
+
+ button_key = setup.input[0].key.drop;
+
+ HandleKey(button_key, KEY_PRESSED);
+
+ Error(ERR_DEBUG, "---------- DROP STARTED ----------");
+ }
+ }
+ }
+}
+
+void HandleFingerEvent(FingerEvent *event)
+{
+#if DEBUG_EVENTS_FINGER
+ Error(ERR_DEBUG, "FINGER EVENT: finger was %s, touch ID %lld, finger ID %lld, x/y %f/%f, dx/dy %f/%f, pressure %f",
+ event->type == EVENT_FINGERPRESS ? "pressed" :
+ event->type == EVENT_FINGERRELEASE ? "released" : "moved",
+ event->touchId,
+ event->fingerId,
+ event->x, event->y,
+ event->dx, event->dy,
+ event->pressure);
+#endif
+
+ runtime.uses_touch_device = TRUE;
+
+ if (game_status != GAME_MODE_PLAYING)
+ return;
+
+ if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ {
+ if (strEqual(setup.touch.control_type, TOUCH_CONTROL_OFF))
+ local_player->mouse_action.button_hint =
+ (event->type == EVENT_FINGERRELEASE ? MB_NOT_PRESSED :
+ event->x < 0.5 ? MB_LEFTBUTTON :
+ event->x > 0.5 ? MB_RIGHTBUTTON :
+ MB_NOT_PRESSED);
+
+ return;
+ }
+
+ if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
+ HandleFingerEvent_VirtualButtons(event);
+ else if (strEqual(setup.touch.control_type, TOUCH_CONTROL_WIPE_GESTURES))
+ HandleFingerEvent_WipeGestures(event);
+}
+
+static void HandleButtonOrFinger_WipeGestures_MM(int mx, int my, int button)
+{
+ static int old_mx = 0, old_my = 0;
+ static int last_button = MB_LEFTBUTTON;
+ static boolean touched = FALSE;
+ static boolean tapped = FALSE;
+
+ // screen tile was tapped (but finger not touching the screen anymore)
+ // (this point will also be reached without receiving a touch event)
+ if (tapped && !touched)
+ {
+ SetPlayerMouseAction(old_mx, old_my, MB_RELEASED);
+
+ tapped = FALSE;
+ }
+
+ // stop here if this function was not triggered by a touch event
+ if (button == -1)
+ return;
+
+ if (button == MB_PRESSED && IN_GFX_FIELD_PLAY(mx, my))
+ {
+ // finger started touching the screen
+
+ touched = TRUE;
+ tapped = TRUE;
+
+ if (!motion_status)
+ {
+ old_mx = mx;
+ old_my = my;
+
+ ClearPlayerMouseAction();
+
+ Error(ERR_DEBUG, "---------- TOUCH ACTION STARTED ----------");
+ }
+ }
+ else if (button == MB_RELEASED && touched)
+ {
+ // finger stopped touching the screen
+
+ touched = FALSE;
+
+ if (tapped)
+ SetPlayerMouseAction(old_mx, old_my, last_button);
+ else
+ SetPlayerMouseAction(old_mx, old_my, MB_RELEASED);
+
+ Error(ERR_DEBUG, "---------- TOUCH ACTION STOPPED ----------");
+ }
+
+ if (touched)
+ {
+ // finger moved while touching the screen
+
+ int old_x = getLevelFromScreenX(old_mx);
+ int old_y = getLevelFromScreenY(old_my);
+ int new_x = getLevelFromScreenX(mx);
+ int new_y = getLevelFromScreenY(my);
+
+ if (new_x != old_x || new_y != old_y)
+ tapped = FALSE;
+
+ if (new_x != old_x)
+ {
+ // finger moved left or right from (horizontal) starting position
+
+ int button_nr = (new_x < old_x ? MB_LEFTBUTTON : MB_RIGHTBUTTON);
+
+ SetPlayerMouseAction(old_mx, old_my, button_nr);
+
+ last_button = button_nr;
+
+ Error(ERR_DEBUG, "---------- TOUCH ACTION: ROTATING ----------");
+ }
+ else
+ {
+ // finger stays at or returned to (horizontal) starting position
+
+ SetPlayerMouseAction(old_mx, old_my, MB_RELEASED);
+
+ Error(ERR_DEBUG, "---------- TOUCH ACTION PAUSED ----------");
+ }
+ }
+}
+
+static void HandleButtonOrFinger_FollowFinger_MM(int mx, int my, int button)
+{
+ static int old_mx = 0, old_my = 0;
+ static int last_button = MB_LEFTBUTTON;
+ static boolean touched = FALSE;
+ static boolean tapped = FALSE;
+
+ // screen tile was tapped (but finger not touching the screen anymore)
+ // (this point will also be reached without receiving a touch event)
+ if (tapped && !touched)
+ {
+ SetPlayerMouseAction(old_mx, old_my, MB_RELEASED);
+
+ tapped = FALSE;
+ }
+
+ // stop here if this function was not triggered by a touch event
+ if (button == -1)
+ return;
+
+ if (button == MB_PRESSED && IN_GFX_FIELD_PLAY(mx, my))
+ {
+ // finger started touching the screen
+
+ touched = TRUE;
+ tapped = TRUE;
+
+ if (!motion_status)
+ {
+ old_mx = mx;
+ old_my = my;
+
+ ClearPlayerMouseAction();
+
+ Error(ERR_DEBUG, "---------- TOUCH ACTION STARTED ----------");
+ }
+ }
+ else if (button == MB_RELEASED && touched)
+ {
+ // finger stopped touching the screen
+
+ touched = FALSE;
+
+ if (tapped)
+ SetPlayerMouseAction(old_mx, old_my, last_button);
+ else
+ SetPlayerMouseAction(old_mx, old_my, MB_RELEASED);
+
+ Error(ERR_DEBUG, "---------- TOUCH ACTION STOPPED ----------");
+ }
+
+ if (touched)
+ {
+ // finger moved while touching the screen
+
+ int old_x = getLevelFromScreenX(old_mx);
+ int old_y = getLevelFromScreenY(old_my);
+ int new_x = getLevelFromScreenX(mx);
+ int new_y = getLevelFromScreenY(my);
+
+ if (new_x != old_x || new_y != old_y)
+ {
+ // finger moved away from starting position
+
+ int button_nr = getButtonFromTouchPosition(old_x, old_y, mx, my);
+
+ // quickly alternate between clicking and releasing for maximum speed
+ if (FrameCounter % 2 == 0)
+ button_nr = MB_RELEASED;
+
+ SetPlayerMouseAction(old_mx, old_my, button_nr);
+
+ if (button_nr)
+ last_button = button_nr;
+
+ tapped = FALSE;
+
+ Error(ERR_DEBUG, "---------- TOUCH ACTION: ROTATING ----------");
+ }
+ else
+ {
+ // finger stays at or returned to starting position
+
+ SetPlayerMouseAction(old_mx, old_my, MB_RELEASED);
+
+ Error(ERR_DEBUG, "---------- TOUCH ACTION PAUSED ----------");
+ }
+ }
+}
+
+static void HandleButtonOrFinger_FollowFinger(int mx, int my, int button)
+{
+ static int old_mx = 0, old_my = 0;
+ static Key motion_key_x = KSYM_UNDEFINED;
+ static Key motion_key_y = KSYM_UNDEFINED;
+ static boolean touched = FALSE;
+ static boolean started_on_player = FALSE;
+ static boolean player_is_dropping = FALSE;
+ static int player_drop_count = 0;
+ static int last_player_x = -1;
+ static int last_player_y = -1;
+
+ if (button == MB_PRESSED && IN_GFX_FIELD_PLAY(mx, my))
+ {
+ touched = TRUE;
+
+ old_mx = mx;
+ old_my = my;
+
+ if (!motion_status)
+ {
+ started_on_player = FALSE;
+ player_is_dropping = FALSE;
+ player_drop_count = 0;
+ last_player_x = -1;
+ last_player_y = -1;
+
+ motion_key_x = KSYM_UNDEFINED;
+ motion_key_y = KSYM_UNDEFINED;
+
+ Error(ERR_DEBUG, "---------- TOUCH ACTION STARTED ----------");
+ }
+ }
+ else if (button == MB_RELEASED && touched)
+ {
+ touched = FALSE;
+
+ old_mx = 0;
+ old_my = 0;
+
+ if (motion_key_x != KSYM_UNDEFINED)
+ HandleKey(motion_key_x, KEY_RELEASED);
+ if (motion_key_y != KSYM_UNDEFINED)
+ HandleKey(motion_key_y, KEY_RELEASED);
+
+ if (started_on_player)
+ {
+ if (player_is_dropping)
+ {
+ Error(ERR_DEBUG, "---------- DROP STOPPED ----------");
+
+ HandleKey(setup.input[0].key.drop, KEY_RELEASED);
+ }
+ else
+ {
+ Error(ERR_DEBUG, "---------- SNAP STOPPED ----------");
+
+ HandleKey(setup.input[0].key.snap, KEY_RELEASED);
+ }
+ }
+
+ motion_key_x = KSYM_UNDEFINED;
+ motion_key_y = KSYM_UNDEFINED;
+
+ Error(ERR_DEBUG, "---------- TOUCH ACTION STOPPED ----------");
+ }
+
+ if (touched)
+ {
+ int src_x = local_player->jx;
+ int src_y = local_player->jy;
+ int dst_x = getLevelFromScreenX(old_mx);
+ int dst_y = getLevelFromScreenY(old_my);
+ int dx = dst_x - src_x;
+ int dy = dst_y - src_y;
+ Key new_motion_key_x = (dx < 0 ? setup.input[0].key.left :
+ dx > 0 ? setup.input[0].key.right :
+ KSYM_UNDEFINED);
+ Key new_motion_key_y = (dy < 0 ? setup.input[0].key.up :
+ dy > 0 ? setup.input[0].key.down :
+ KSYM_UNDEFINED);
+
+ if (dx != 0 && dy != 0 && ABS(dx) != ABS(dy) &&
+ (last_player_x != local_player->jx ||
+ last_player_y != local_player->jy))
+ {
+ // in case of asymmetric diagonal movement, use "preferred" direction
+
+ int last_move_dir = (ABS(dx) > ABS(dy) ? MV_VERTICAL : MV_HORIZONTAL);
+
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ game_em.ply[0]->last_move_dir = last_move_dir;
+ else
+ local_player->last_move_dir = last_move_dir;
+
+ // (required to prevent accidentally forcing direction for next movement)
+ last_player_x = local_player->jx;
+ last_player_y = local_player->jy;
+ }
+
+ if (button == MB_PRESSED && !motion_status && dx == 0 && dy == 0)
+ {
+ started_on_player = TRUE;
+ player_drop_count = getPlayerInventorySize(0);
+ player_is_dropping = (player_drop_count > 0);
+
+ if (player_is_dropping)
+ {
+ Error(ERR_DEBUG, "---------- DROP STARTED ----------");
+
+ HandleKey(setup.input[0].key.drop, KEY_PRESSED);
+ }
+ else