Les événements de la catégorie Gesture Event sont déclenchés lorsque GameMaker Studio 2 détecte un «geste» de la souris ou un événement tactile (alors que ces événements gestuels sont conçus spécifiquement pour une utilisation mobile, ils peuvent également être utilisés sur d'autres cibles pour détecter la souris, bien qu'ils ne détectent pas de multiples touches dans ce cas). Le but du système gestuel est d'essayer de reconnaître les entrées à un niveau plus élevé que les fonctions directes de lecture tactile de la souris, et il est conçu pour simplifier la mise en œuvre des entrées couramment utilisées sur les dispositifs tactiles.
Vous pouvez choisir de détecter des gestes d' instance ou des gestes globaux, où les événements gestuels d'instance ne seront déclenchés que lorsque le premier contact / clic est sur une instance dans la pièce. Notez que l'instance doit avoir un masque de collision valide (voir les sections Éditeur de sprite - Masque de collision et Éditeur d'objet - Masque de collision pour plus de détails) pour que cet événement soit déclenché. Les événements globaux, cependant, seront déclenchés en touchant / cliquant n'importe où dans la salle de jeu, et pour toutes les instances qui ont l'événement.
Lorsqu'un événement gestuel est reconnu, il déclenche un ou plusieurs des sous-événements disponibles et le sous-événement déclenché dépend du type de geste détecté. Dans tous les cas, cependant, une carte DS sera générée pour vous et stockée dans la variable intégrée event_data. Les clés disponibles dépendent du type d'événement créé et sont présentés dans chacune des sous-sections ci-dessous.
Il est à noter que si vous avez plusieurs occurrences sous la position touchée et qu'elles ont toutes un événement gestuel, elles se déclencheront toutes, pas seulement l'instance "la plus haute". Notez également que lorsque vous utilisez plusieurs vues et que vous faites glisser une occurrence, les valeurs renvoyées seront basées sur la vue dans laquelle vous étiez lorsque le premier contact / clic a été reçu. Cela est vrai pour tous les événements suivants de cette occurrence. Ainsi, en touchant et en faisant glisser une occurrence dans une vue, puis en relâchant la touche dans une autre vue, vous obtiendrez des valeurs relatives à la vue initiale où le geste a été détecté pour la première fois.
Les événements "Tap", "Drag" et "Flick" sont tous basés sur une simple pression ou un clic de souris sur l'écran et le event_data DS Map contiendra les clés suivantes:
Clé Valeur Description "gesture"
C'est une valeur d'ID unique au geste en cours. Cela vous permet de relier les différentes parties des gestes en plusieurs parties (telles que le début, le glisser et la fin)."touch"
C'est l'index du toucher qui est utilisé pour le geste. En général, cela commence à 0 et augmente pour chaque doigt maintenu, puis revient à 0 lorsque tous les doigts sont retirés, mais si l'utilisateur touche l'écran n'importe où ailleurs lorsque cet événement est déclenché par un autre toucher, alors la valeur sera supérieur à 0."posX"
C'est la position X du room-space."posY"
C'est la position Y de l'espace de la pièce."rawposX"
Ceci est la position brute X de l'espace de la fenêtre (équivalent à l'obtention de la position de la souris en utilisant device_mouse_raw_x() )."rawposY"
Ceci est la position brute Y de l'espace de la fenêtre du toucher (équivalent à l'obtention de la position de la souris en utilisant device_mouse_raw_y() )."guiposX"
Ceci est la position gui-space X du toucher (équivalent à l'obtention de la position de la souris en utilisant device_mouse_x_to_gui() )."guiposY"
Ceci est la position gui-space Y du toucher (équivalent à l'obtention de la position de la souris en utilisant device_mouse_y_to_gui() )."diffX"
C'est la différence entre l'espace et la pièce X entre la position du contact en cours et la position du dernier contact dans ce geste."diffY"
C'est la différence Y entre la position du toucher actuel et la position du dernier contact dans ce geste."rawdiffX"
C'est la différence brute entre la position du toucher actuel et la position du dernier contact dans ce geste."rawdiffY"
C'est la différence Y brut entre la position du toucher actuel et la position du dernier contact dans ce geste."guidiffX"
C'est la différence gui-espace X entre la position du toucher actuel et la position du dernier contact dans ce geste."guidiffY"
C'est la différence entre la position du toucher actuel et la position du dernier contact dans ce geste."isflick"
Uniquement disponible dans l'événement Drag End. Ceci est mis à 1 si la fin de la traînée est détectée comme un film, ce qui signifie que vous n'avez pas besoin d'un événement Flick séparé si vous gérez le glisser de toute façon.L'événement Tap sera déclenché lorsqu'une occurrence a été touchée ou cliquée ou, s'il s'agit d'un événement global, lorsque le jeu enregistre une touche ou un clic n'importe où dans la pièce. Un tap est considéré comme un toucher rapide et un relâchement, et si le toucher dure trop longtemps, il sera considéré comme un Drag (et déclenchera les événements Drag gesture au lieu de l'événement Tap). Cet événement va générer un event_data DS carte que vous pouvez ensuite utiliser pour obtenir des informations sur l'événement. Par exemple:
Créer un évènement
x_goto = x;
y_goto = y;Appuyez sur événement
x_goto = event_data[? "posX"];
y_goto = event_data[? "posY"];Étape
var _pd = point_distance(x, y, x_goto, y_goto);
move_towards_point(x_goto, y_goto, clamp(_pd, 0, 5);
Le code ci-dessus détectera un tap sur l'écran, puis obtiendra la position du tap pour déplacer l'instance vers cette position. Notez que si vous voulez avoir un temps de détection de prise plus long ou plus court, vous pouvez le définir avec la fonction gesture_drag_time. Cela définit le temps entre la détection initiale et le robinet devenant un glissement, alors réglez-le sur une valeur plus élevée pour que la détection du robinet soit plus longue ou une valeur plus faible pour la raccourcir (la valeur est en secondes et 0,16 par défaut).
L'événement Double Tap sera déclenché lorsqu'une instance a été touchée ou cliquée deux fois de suite (ou - s'il s'agit d'un événement global - lorsque le jeu enregistre deux touches rapides ou des clics n'importe où dans la pièce). Un double appui est considéré comme deux touches et relâchements rapides, mais si l'une des touches dure trop longtemps, elle sera considérée comme un Drag (et déclenchera les événements Drag gesture au lieu de l'événement Double Tap). Cet événement va générer un event_data DS carte que vous pouvez ensuite utiliser pour obtenir des informations sur l'événement. Par exemple:
Créer un évènement
x_goto = x;
y_goto = y;Double Tap Event
instance_destroy();
Le code ci-dessus détecte simplement un double appui puis détruit l'instance. Notez que vous pouvez régler l'intervalle entre les prises pour déclencher un double appui en utilisant la fonction gesture_double_tap_time (qui a une valeur par défaut - en secondes - de 0.16) et vous pouvez également définir la distance pour la détection entre les robinets avec la fonction gesture_double_tap_distance (Si un second tap est détecté en dehors de cette distance, il sera considéré comme un événement de tapement régulier).
L'événement Drag Start sera déclenché lorsque l'utilisateur maintient un contact ou un clic sans le relâcher. Il sera déclenché une fois quand un temps défini est passé après la touche initiale, qui est de 0,16 secondes par défaut (bien que vous puissiez définir cette valeur sur n'importe quelle autre valeur en secondes en utilisant la fonction gesture_drag_time ). Une fois que cet événement a été déclenché, et tant que l'utilisateur maintient un toucher / un clic enfoncé, l'événement de glissement sera déclenché à chaque étape jusqu'à ce que le contact / clic ait été libéré. Cet événement va générer un event_data DS carte que vous pouvez ensuite utiliser pour obtenir des informations sur l'événement. Par exemple:
Créer un évènement
drag_offsetX = 0;
drag_offsetY = 0;Faites glisser l'événement de départ
drag_offsetX = x - event_data[?"posX"];
drag_offsetY = y - event_data[?"posY"];
Le code ci-dessus utilise l'événement Drag Start pour obtenir la position du bouton tactile et l'utiliser pour définir une valeur de décalage pour les axes x et y. Cela peut ensuite être utilisé lorsque vous faites glisser l'instance pour vous assurer qu'elle ne "saute" pas à la position à laquelle le contact / clic a été détecté (voir l'événement Dragging ci-dessous pour une continuation de cet exemple).
L'événement Dragging est déclenché après l'événement Drag Start et sera déclenché pour chaque étape que l'utilisateur maintient le contact / clic sur l'instance (ou l'écran, s'il s'agit d'un événement global) et se déplace plus que le seuil de déplacement défini. Cette distance est de 0,1 pouce par défaut mais peut être réglée en utilisant la fonction gesture_drag_distance. S'il n'y a pas de mouvement ou si le mouvement est sous le seuil défini, l'événement ne sera pas déclenché. Cet événement va générer un event_data DS carte que vous pouvez ensuite utiliser pour obtenir des informations sur l'événement. Par exemple:
Créer un évènement
drag_offsetX = 0;
drag_offsetY = 0;Faites glisser l'événement de départ
drag_offsetX = x - event_data[?"posX"];
drag_offsetY = y - event_data[?"posY"];Faire glisser l'événement
x = event_data[?"posX"] + drag_offsetX;
y = event_data[?"posY"] + drag_offsetY;
L'exemple de code ci-dessus utilise les variables de décalage définies dans l'événement Drag Start pour déplacer l'instance lorsque l'événement Dragging est déclenché.
L'événement Drag End est déclenché lorsque l'utilisateur relâche le bouton tactile / cliquer sur l'instance (ou l'écran si l'événement est global). Cet événement va générer un event_data Carte DS que vous pouvez ensuite utiliser pour obtenir des informations sur l'événement, mais dans ce cas, la carte aura une clé supplémentaire: " isflick "Flick est calculé comme la distance par seconde sur laquelle la traînée s'est produite, et la valeur pour le" isflick "La clé sera true si elle est supérieure à la distance définie par seconde, ou false autrement. Notez que la valeur par défaut est 2 pouces par seconde, mais vous pouvez le définir à une autre valeur en utilisant la fonction gesture_flick_speed. Notez également qu'il existe un événement Flick dédié qui sera également déclenché si le " isflick "variable est true. Un exemple d'utilisation serait:
Créer un évènement
flickVelX = 0.0;
flickVelY = 0.0;Faire glisser l'événement de fin
isFlick = event_data[?"isflick"];
if (isFlick)
{
flickVelX = event_data[?"diffX"];
flickVelY = event_data[?"diffY"];
}
else
{
flickVelX = 0;
flickVelY = 0;
}Étape
x += flickVelX;
y += flickVelY;
flickVelX *= 0.7;
flickVelY *= 0.7;
Le code ci-dessus obtient simplement la différence entre la position x et y du dernier événement Dragging et l'événement Drag End actuel, et si le mouvement a été supérieur au seuil de flick, il définit certaines variables utilisées pour déplacer l'instance dans le événement d'étape.
L'événement Flick est uniquement déclenché lorsqu'un contact / clic a été maintenu, déplacé puis relâché et que la distance entre la dernière position de glissement et la position de libération est supérieure à 2 pouces par seconde (paramètre par défaut, bien que cela puisse être modifié en utilisant la fonction gesture_flick_speed ). Cet événement va générer un event_data DS carte que vous pouvez ensuite utiliser pour obtenir des informations sur l'événement. Par exemple:
Créer un évènement
flickVelX = 0.0;
flickVelY = 0.0;Evénement Flick
flickVelX = event_data[?"diffX"];
flickVelY = event_data[?"diffY"];Étape
x += flickVelX;
y += flickVelY;
flickVelX *= 0.7;
flickVelY *= 0.7;
Le code ci-dessus obtient simplement la différence en position x et y du dernier événement Dragging et l'événement Flick en cours, et si le mouvement a été supérieur au seuil de flick, il définit certaines variables utilisées pour déplacer l'instance dans l'étape un événement.Les événements "Pinch" sont basés sur deux touches à l'écran des appareils qui sont reconnues à la fois, où l'un (ou les deux) ont bougé sur plus d'une certaine distance. L'angle de mouvement des touches avec le mouvement de chaque touche est ce qui déterminera la détection d'un événement Pincer ou Pivoter, où (dans le cas du type Pincement ):
- Si l'une des touches ne bouge pas, l'autre doit se déplacer vers elle ou s'éloigner dans un angle de seuil (qui peut être réglé en utilisant les fonctions gesture_pinch_angle_towards() et - gesture_pinch_angle_away() ).
- Si les deux touches bougent, leurs vitesses doivent être dans des directions approximativement opposées et la même vérification du seuil angulaire est également effectuée pour s'assurer que les touches bougent dans un alignement approximatif.
Lorsque deux touches et un mouvement sont détectés avec les critères ci-dessus, un événement de pincement sera déclenché, et dans chacun des événements, le event_data DS Map sera rempli avec les clés suivantes:
Clé Valeur Description "gesture"
C'est une valeur d'ID unique au geste en cours. Cela vous permet de relier les différentes parties des gestes en plusieurs parties (telles que le début, le glisser et la fin)."touch1"
C'est l'index du premier contact qui est utilisé dans le cadre du geste de pincement. En général, ce sera 0, mais si l'utilisateur touche l'écran n'importe où ailleurs lorsque cet événement est déclenché par une autre touche, alors la valeur sera supérieure à 0."touch2"
C'est l'index de la deuxième touche qui est utilisée dans le cadre du geste de pincement. En général, cela sera 1 de plus que la valeur de touch1, mais peut être une autre valeur en fonction du nombre de touches détectées ailleurs."posX1"
C'est la position X du premier contact."posY1"
C'est la position Y dans l'espace de la pièce du premier contact."rawposX1"
Ceci est la position brute de l'espace de fenêtre X du premier contact (ce qui équivaut à obtenir la position de la souris en utilisant device_mouse_raw_x() )."rawposY1"
Ceci est la position brute de l'espace de fenêtre du premier contact (équivalent à l'obtention de la position de la souris en utilisant device_mouse_raw_y() )."guiposX1"
Ceci est la position gui-espace X du premier contact (équivalent à l'obtention de la position de la souris en utilisant device_mouse_x_to_gui() )."guiposY1"
Ceci est la position gui-space Y du second contact (équivalent à l'obtention de la position de la souris en utilisant device_mouse_y_to_gui() )."posX2"
C'est la position X de l'espace-pièce du second contact."posY2"
C'est la position Y dans l'espace de la pièce du second contact."rawposX2"
Ceci est la position brute de l'espace de fenêtre X du premier contact."rawposY2"
C'est la position brute Y de l'espace fenêtre du second contact."guiposX2"
C'est la position gui-espace X du second contact."guiposY2"
C'est la position gui-espace Y du second contact."midpointX"
La position X du point médian entre les deux touches dans l'espace de la pièce."midpointY"
La position Y du point médian entre les deux touches dans l'espace de la pièce."rawmidpointX"
Ceci est la position X de la fenêtre brute du point médian."rawmidpointY"
C'est la position brute Y de l'espace de fenêtre du point médian."guimidpointX"
C'est la position gui-espace X du point médian."guimidpointY"
C'est la position gui-espace Y du point médian."relativescale"
Il s'agit d'une différence d'échelle par rapport au dernier événement de ce geste (donc pour les événements Pinch In, il sera toujours inférieur à 1.0, alors que pour les événements Pinch Out, il sera toujours supérieur à 1.0)"absolutescale"
C'est l'échelle comparée à l'endroit où les doigts se trouvaient lorsque le geste a commencé (donc si la distance entre les doigts a été réduite de moitié, cela sera de 0,5 alors que si la distance a doublé, elle sera de 2,0).L'événement Pinch Start sera déclenché lorsqu'une instance (ou l'écran si l'événement est global) a été touchée par deux «doigts» (et le toucher est maintenu), puis un ou les deux «doigts» sont déplacés. Si les touches s'éloignent l'une de l'autre ou l'une de l'autre plus que la distance de vérification minimale (qui est de 0,1 pouce par défaut, mais il peut être réglé en utilisant la fonction gesture_pinch_distance ), et l'angle entre eux est dans la valeur définie (par défaut, 45 °, mais peut être réglé en utilisant gesture_pinch_angle_towards() et - gesture_pinch_angle_away() ), un événement Pinch Start sera déclenché. Dans cet événement, vous pouvez définir des variables ou stocker la date de position pour une utilisation ultérieure. Par exemple:
Pinch Start Événement
pinching = true;
pinch_x = event_data[? "midpointX"]; pinch_y = event_data[? "midpointY"];
Le code ci-dessus détectera un pincement et mémorisera la position du point médian pour cette pincée.
Pinch In et Pincer événements seront déclenchés à chaque étape que la distance entre les deux touches qui composent les changements de pincement sur le seuil minimal (fixé à +/- 0,1 pouces par défaut, mais vous pouvez le modifier en utilisant la fonction gesture_pinch_distance ). S'il n'y a pas de mouvement de pincement, ces événements ne se déclencheront pas. Ces événements généreront un event_data DS carte que vous pouvez ensuite utiliser pour obtenir des informations sur l'événement. Par exemple:
Événement Global Pinch In / Pinch Out
var _scale = event_data[? "relativescale"];
var _w = camera_get_view_width(view_camera[0]);
var _h = camera_get_view_height(view_camera[0]);
var _x = camera_get_view_x(view_camera[0]) + (_w / 2);
var _y = camera_get_view_y(view_camera[0]) + (_h / 2);
_w *= _scale;
_h = _w * (room_height / room_width);
_x -= _w / 2;
_y -= _h / 2;
camera_set_view_pos(view_camera[0], _x, _y);
camera_set_view_size(view_camera[0], _w, _h);
Le code ci-dessus met à l'échelle la vue en fonction de l'échelle relative des pincements.
L'événement Pinch End sera déclenché lorsque l'utilisateur relâchera une (ou les deux) touches de l'appareil. Ces événements généreront une event_data DS carte que vous pouvez ensuite utiliser pour obtenir des informations sur l'événement. Par exemple:
Pinch End Event
var _pinchx = event_data[? "midpointX"]; var _pinchy = event_data[? "midpointY"]; var _w = camera_get_view_width(view_camera[0]);
var _h = camera_get_view_height(view_camera[0]);
var _x = _pinchx - (_w / 2);
var _y = _pinchy - (_h / 2);
camera_set_view_pos(view_camera[0], _x, _y);
Le code ci-dessus définira la position de la vue à centrer sur le milieu des deux touches qui composent le pincement lorsque les touches sont relâchées.Les événements "Rotation" sont basés sur deux touches à l'écran des périphériques qui sont reconnues à la fois, et où il y a eu une rotation angulaire cohérente entre les deux dans un temps spécifique. L'angle de mouvement des touches avec le mouvement de chaque touche est ce qui déterminera la détection d'un événement Pincer ou Pivoter, où (dans le cas du type Rotation d'événement ):
- Deux touches doivent être maintenues enfoncées pendant une durée minimale spécifiée (la durée par défaut est 0,16 secondes, mais vous pouvez la modifier en utilisant la fonction gesture_rotate_time() ).
- Au cours de cette période minimale, ils doivent tourner dans une direction cohérente (si le sens de rotation change pendant cette période, aucune rotation n'est lancée).
- La quantité de rotation doit dépasser l'angle de seuil minimum (qui est réglé sur 5 ° par défaut, mais cela peut être changé en utilisant la fonction gesture_rotate_angle() ).
Lorsque deux touches et un mouvement sont détectés avec les critères ci-dessus, un événement de rotation sera déclenché, et dans chacun des événements, le event_data DS Map sera rempli avec les clés suivantes:
Clé Valeur Description "gesture"
C'est une valeur d'ID unique au geste en cours. Cela vous permet de relier les différentes parties des gestes en plusieurs parties (telles que le début, le glisser et la fin)."touch1"
C'est l'index du premier contact qui est utilisé dans le cadre du geste de pincement. En général, ce sera 0, mais si l'utilisateur touche l'écran n'importe où ailleurs lorsque cet événement est déclenché par une autre touche, alors la valeur sera supérieure à 0."touch2"
C'est l'index de la deuxième touche qui est utilisée dans le cadre du geste de pincement. En général, cela sera 1 de plus que la valeur de touch1, mais peut être une autre valeur en fonction du nombre de touches détectées ailleurs."posX1"
C'est la position X du premier contact."posY1"
C'est la position Y dans l'espace de la pièce du premier contact."rawposX1"
Ceci est la position brute de l'espace de fenêtre X du premier contact (ce qui équivaut à obtenir la position de la souris en utilisant device_mouse_raw_x() )."rawposY1"
Ceci est la position brute de l'espace de fenêtre du premier contact (équivalent à l'obtention de la position de la souris en utilisant device_mouse_raw_y() )."guiposX1"
Ceci est la position gui-espace X du premier contact (équivalent à l'obtention de la position de la souris en utilisant device_mouse_x_to_gui() )."guiposY1"
Ceci est la position gui-space Y du second contact (équivalent à l'obtention de la position de la souris en utilisant device_mouse_y_to_gui() )."posX2"
C'est la position X dans l'espace de la seconde touche."posY2"
C'est la position Y dans l'espace de la pièce du second contact."rawposX2"
Ceci est la position brute de l'espace de fenêtre X du premier contact."rawposY2"
C'est la position brute Y de l'espace fenêtre du second contact."guiposX2"
C'est la position gui-espace X du second contact."guiposY2"
C'est la position gui-espace Y du second contact."pivotX"
La position X du point de pivotement de rotation dans l'espace de la pièce."pivotY"
La position Y du point de pivotement de rotation dans l'espace de la pièce."rawpivotX"
Ceci est la position brute de l'espace de fenêtre X du point de rotation."rawpivotY"
Ceci est la position brute Y de l'espace fenêtre du point de rotation."guipivotX"
C'est la position X-espace X du point de rotation."guipivotY"
Ceci est la position gui-espace Y du point de rotation."relativeangle"
C'est la différence de rotation par rapport au dernier événement de ce geste, mesuré en degrés
"absoluteangle"
C'est la différence d'angle par rapport à l'endroit où se trouvaient les doigts lorsque le geste a commencé, mesuré en degrés. Ainsi, par exemple, si les doigts ont tourné d'un quart de cercle depuis le début du geste, cette valeur sera de 90 ° ou -90 °, selon le sens de rotation.L'événement Rotate Start sera déclenché lorsqu'une instance (ou l'écran si l'événement est global) a été touchée par deux "doigts" (et le contact est maintenu) et que l'un ou les deux "doigts" sont tournés depuis le début position. La rotation des touches doit avoir démarré dans un court laps de temps (0,16 secondes par défaut, mais elle peut être définie à l'aide de la fonction gesture_rotate_time() ) et être supérieur au seuil angulaire minimum (par défaut 5 °, mais cela peut être modifié en utilisant la fonction gesture_rotate_angle() ). Si ces vérifications sont vraies, un événement Rotate Start sera déclenché et vous pourrez l'utiliser pour stocker des valeurs ou définir des variables à utiliser avec les autres événements de rotation. Par exemple:
Créer un évènement
rotating = false;
view_a = camera_get_view_angle(view_camera[0]);Faire pivoter l'événement de départ
rotating = true;
Le code ci-dessus définit simplement certaines variables pour faire pivoter la caméra de vue, puis dans l'événement Rotate Start, il définit l'un d'eux pour true.
L'événement de rotation sera déclenché à chaque pas que les touches sur l'écran tournent l'une autour de l'autre, tant que le mouvement est supérieur au seuil angulaire minimum (par défaut 5 °, mais, cela peut être changé en utilisant la fonction gesture_rotate_angle() ). Cet événement peut être utilisé pour définir des variables et manipuler des instances, par exemple:
Événement tournant
var _relangle = event_data[?"relativeangle"];
var _a = camera_get_view_angle(view_camera[0]);
_a += _relangle;
camera_set_view_angle(view_camera[0], _a);
Le code ci-dessus fait pivoter la vue de la caméra en fonction du mouvement de rotation des touches dans l'événement.
L'événement Rotate End sera déclenché lorsque l'un (ou les deux) touchers qui composent le geste sont libérés de l'écran de l'appareil. Cet événement peut être utilisé pour définir des variables et manipuler des instances, par exemple:
Faire pivoter l'événement de fin
rotating = false;
Étape
if !rotating
{
var _a = camera_get_view_angle(view_camera[0]);
var _adif = angle_difference(view_a, _a);
_a += median(-5, _adif, 5);
camera_set_view_angle(view_camera[0], _a);
}
Le code ci-dessus utilise l'événement Rotate End pour détecter quand l'utilisateur arrête le mouvement et définit ensuite une variable. Cette variable est ensuite utilisée dans l'événement d'étape pour ramener la caméra de vue dans sa position d'origine.
