• Introduction
• A propos de ce livre
• Qu'est ce que Godot ?
• Exemples de jeux
• Les composants de Godot
• L'architecture de Godot
• Les variantes et les objets
• Les nodes et les scènes
• Les ressources
• Créer un jeu
• Définir le projet
• Structurer le jeu
• Définir les scènes
• Ajouter des mécaniques en GDScript
• Gérer les input clavier et souris
• Gérer les input Manette
• Exporter son jeu
• Internationalisation du jeu
• Enrichir son jeu avec des effets
• Animation
• Les particules
• Le son

Gérer les Input Manette

Gérer les entrées des manettes

Il est possible de vérifier la présence d’une manette ainsi que son état et d’en être informé en jeu. Cette étape n’est pas

On commence par connecter le signal de la connexion de la manette nommé joy_connection_changed (détection d’un changement dans le branchement d’une manette (connexion, déconnexion)) à la fonction joy_con_changed dans le self (le Node actuel du Script) :

 

Input.connect("joy_connection_changed",self,"joy_con_changed")

 

On créer alors la fonction de réception joy_con_changed plus bas dans le Script :

 

func joy_con_changed(deviceid,isConnected):

                if isConnected:

                               print("Joystick " + str(deviceid) + " connected")

                if Input.is_joy_known(0):

                               print("Recognized and compatible joystick")

                               print(Input.get_joy_name(0) + " device connected")

                else:

                               print("Joystick " + str(deviceid) + " disconnected")

Voila ! Les différents print permettent d’être informé sur plusieurs aspects de la manette (type (Ps4, Xbox, etc.), reconnaissance et compatibilité (prise en charge ou non par le moteur de jeu) et l’ID (utilisable pour assigner une manette à un personnage)). Avec toutes ces informations, il est déjà possible de mettre en place une attribution de manette à un Script précis :

 

enum NamedEnum {Player_01 = 0, Player_02 = 1, Player_03 = 2, Player_04 = 3}

export (NamedEnum) var nb_P

 

Il suffit à présent de saisir nb_P pour chaque paramètre Controler Devise des méthodes. Pour rappel, les exports variables permettent de modifier une variable d’un Script directement depuis l’éditeur, elles permettent également que plusieurs Nodes qui partagent un Script similaire soit dotée de paramètres différents. Pour le Node de votre premier joueur, indiquez Player_01, pour le second, Player_02.

Lorsqu’une manette est débranchée puis rebranchée, il est possible que son ID soit modifié !

 

Gérer les input boutons

On peut trouver la liste des méthodes d’appels des Input de la manette (et notamment ceux des boutons) dans l’aide Godot présent dans l’éditeur de Script. Il suffit d’y saisir le mot clef « joy » dans la barre de recherche pour limiter l’affichage aux éléments relatifs des JoyPad, on descend en suite jusqu’à la catégorie méthode. On peut cliquer sur la méthode de notre choix pour retrouver sa description et l’intégrer à notre projet. Prenons par exemple la méthode is_joy_button_pressed :

 

If Input.is_joy_button_pressed(Param1, Param2) :

 

Il faut ensuite renseigner les deux paramètres (Param1 et Param2) 

1. Param1 : Il est écrit dans la documentation que ce paramètre correspond au device et que sa valeur doit être de type int. Pour rappel, le devine correspond à l’ID de la manette concernée. Il y a ici deux cas de figures :
   1.  On peut saisir manuellement la valeur du paramètre, par exemple 0 (pour la première manette, celle par défaut) ou bien n’importe quel autre numéro, pourvus qu’il soit entier. La première manette branchée sera Device 0, la suivante 1, etc.
   2. Si vous avez suivis la démarche d’attribution de manette à un Script précis initiée dans la gestion de entrées des manettes, vous avez déjà mis en place une sélection automatique du Device (via une export variable). Il vous suffit de saisir nb_P chaque fois que le paramètre Device est demandé.
2. Param2 : Il est écrit dans la documentation que ce paramètre correspond au Buttons et que sa valeur doit être de type int. Pour trouver la liste des boutons, on se rend une nouvelle fois dans la documentation interne au Game Engine et plus précisément sur la page descriptive du @GlobalScope (ou bien sur la page de n’importe quel Joy_Button). On peut alors retrouver la valeur constante associée à n’importe quel bouton. Il est possible de renseigner le Param2 en saisissant manuellement la valeur d’un bouton (un numéro int) ou en se servant du mot clef de l’enum JoystickList (JOY_BUTTON_0, par exemple, est une constante valide). Il est aussi possible de donner un retour sur l’Input utilisée :

for i in range(16):

  if Input.is_joy_button_pressed(0,i):

    print("Button at " + str(i) + " pressed, should be button: " + Input.get_joy_button_string(i))

On se retrouve donc avec plusieurs possibilités. On peut par exemple opter pour l’appel de mots clef :

 
if Input.is_joy_button_pressed(nb_P, JOY_BUTTON_0)

 

Ou bien saisir directement les valeurs :

 

if Input.is_joy_button_pressed(0, 0)

 

Une fois la vérification passée, on peut lancer les instructions de son choix.

 

Gérer les inputs analogiques

Il est possible de récupérer la valeur d’un joystick analogique via la méthode :

 

 Input.get_joy_axis(Param1, Param2)

 

Le premier paramètre correspond une nouvelle fois au Device et peut être renseigné de manière identique à la méthode employer pour les boutons. Le second paramètre correspond à l’axis (l’axe du joystick), il est possible de retrouver tous les axis dans la documentation. Godot scinde la valeur de chaque Joystick en deux, une pour sa position horizontale et une seconde pour sa position verticale. Chacune de ses valeurs varie entre 1 et -1 (0 étant le centre) à chaque extrémité de son axe. On peut donc utiliser la méthode suivante :

 

Input.get_joy_axis(0, JOY_AXIS_0)

 

Cela renvoi la position du Joystick gauche sur l’axe horizontale (JOY_AXIS_1 renvoi sa position sur l’axe verticale). Pour obtenir sa position globale, il est possible de regrouper ses deux valeurs en une variable :

 

var left_analog_axis = Vector2(Input.get_joy_axis(nb_P, JOY_AXIS_0), Input.get_joy_axis(nb_P, JOY_AXIS_1))

 

left_analog_axis peut donc être utilisé pour connaître la position du Joystick sur ses deux axes (x et y). On peut à présent déplacer le personnage selon la puissance de déplacement du joystick dans une direction, essayons avec l’axe horizontale :

 

position.x += 100 * delta * ( 3 * clamp(left_analog_axis.x,-1, 1))

Le personnage se déplace sur l’axe horizontale à une vitesse maximum de 3 multipliée par la puissance de pression, qui rappelons le, varie entre 1 et -1 (0 étant le centre, il ne bouge pas). La méthode clamp() permet de restreindre la valeur de l’analogue à un float entre -1 et 1 (car il est parfois possible que la valeur excède un tout petit peu 1 ou -1). Si on test cette configuration, on se rend rapidement compte d’un problème : Le centre au 0 parfait n’est presque jamais atteint et le personnage ne s’arrête jamais ! Cela est logique, puisque la variation entre les deux valeurs maximales atteint le millionième de décimale… Il va donc falloir restreindre la zone de lancement de notre fonction, on peut alors se servir de la variable créer plus haut :

 

Var deadZone = 0.2

if abs(left_analog_axis.length()) >= deadZone :

 

En créant la variable deadZone au préalable, il est possible de préciser la puissance de pression à dépasser pour lancer la fonction de déplacement. La méthode abs() appelée ici permet de renvoyer la valeur positive d’un nombre pour vérifier la limite des deux côtés de l’axe. En réalisant un nouveau test, on remarque que le personnage ne commence son déplacement qu’après une certaine pression atteinte, la condition fonctionne ! On peut alors répéter l’action avec l’autre axe :

 

Var deadZone = 0.2

var left_analog_axis = Vector2(Input.get_joy_axis(nb_P, JOY_AXIS_0), Input.get_joy_axis(nb_P, JOY_AXIS_1))

                if abs(left_analog_axis.length()) >= deadZone :

                               position.x += 100 * delta * ( 3 * clamp(left_analog_axis.x,-1, 1))

                               position.y += 100 * delta * ( 3 * clamp(left_analog_axis.y,-1, 1))

 

Voila, notre personnage se déplace selon l’orientation des Joystick ! On peut réaliser le même genre d’action pour qu’un objet regarde dans la direction du joystick :

 

var joy_rot = atan2(right_analog_axis.y, right_analog_axis.x)

if right_analog_axis.length() >= deadZone:

                               rotation = joy_rot

 

Il est également possible de vérifier la puissance de pression des gâchettes arrière :

 

var trigger_left_axis = Input.get_joy_axis(0, JOY_AXIS_6)

if Input.is_joy_button_pressed(0, JOY_AXIS_6) :

                if trigger_left_axis >= deadZone :

                               print(« hello »)

 

Gérer la vibration

 

Dans une manette, un moteur est disposé de chaque côté, à l’intérieur des manches. L’un permet une vibration rapide et relativement douce, le second est plus puissant et on remarque un décalage plus important entre chaque coup de vibration. Avec Godot il est possible de gérer la vibration des manettes avec la méthode suivante :

 

Input.start_joy_vibration(Param1, Param2, Param3, Param4)

 

1. Param1 correspond au Device, comme vue plus haut.
2. Param2 correspond à la puissance d’utilisation du premier moteur de vibration, le plus léger. La valeur de son intensité varie entre 0 et 1.
3. Param3 correspond à la puissance d’utilisation du second moteur de vibration, le plus lourd. La valeur de son intensité varie entre 0 et 1.
4. Param4 correspond à la durée d’activation du moteur. Sa valeur s’exprime en seconde, 3.5 se traduit donc en 3 secondes et demis (3s et 500 millisecondes).

 Il est alors possible de faire varier la puissance d’un moteur de vibration selon la puissance de poussée d’un Joystick :

 

var trigger_left_axis = Input.get_joy_axis(0, JOY_AXIS_6)

Input.start_joy_vibration(0, clamp(trigger_left_axis,0,1), 0.0, 0.1)

 

L’utilisation du clamp est très importante, en effet, il est parfois possible que la valeur de la puissance du Trigger soit supérieure à 1, ce qui à pour effet de couper la vibration, on la limite donc à 1.

Pour la vibration des manettes autres que Xbox (qui sont naturellement adaptées au support PC), il est impératif de télécharger un logiciel tiers, pour les manettes P par exemple, il existe le soft Ds4Windows qui se charge de la gestion des périphériques Ps4. Cependant attention :

• Il est possible que ce logiciel émule, en plus du périphérique Hardware, une manette virtuelle. Cela aura pour conséquence la reconnaissance de deux manettes distinctes par le logiciel Godot.
• Il est également possible que la gestion des Input de deux périphériques sur un matériel Hardware unique entraine l’arrêt brusque de certaines fonctionnalités (comme l’arrêt des vibrations après quelques secondes, par exemple.).

Il faut se renseigner pour tout autre périphérique.