• 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 clavier et souris

Il y a beaucoup de moyens de récupérer les input (pression d’une touche) sur Godot engine, mais chacune d’entres elle proviennent de la même source, l’évènement input. Dans ce chapitre, nous allons voir la base de l’utilisation des inputs dans votre jeu et leurs diverses alternatives.

Récupérer les évènements d’input

Les évènements d’input sont un moyen d’obtenir les inputs pour n’importe quelle OS et n’importe quelle plateforme. À chaque modification du périphérique d’entrée, on reçoit un évènement décrivant ce changement. Evidemment, chaque OS et chaque plateforme a différentes manières de récupérer ces changements et c’est le travail du moteur de standardiser la structure.

Chaque Node dans la scène peut recevoir les évènements d’entrée qui arrivent dans le jeu :

• Pour commencer, on initialise _input(event) :

func _input(event): 
 if (event.type == InputEvent.MOUSE_BUTTON): 
 # do something here with the mouse button

• Ensuite, lorsque vous voulez commencer à utiliser la fonction processing, utilisez cette méthode :

set_process_input(true)

Certains Nodes vont avoir besoin de recevoir les inputs à chaque instant, certains auront besoin de les activer et de les désactiver. C’est à vous de décider, mais retenez bien que les autres Nodes vont également recevoir ces évènements au même moment, vous devez donc décider si un évènement est utile pour votre Node ou pas.

Consultez la référence de la classe InputEvent pour obtenir une description de tous les évènements que vous pouvez recevoir.

Vérification de l’état des périphériques d’entrée

Récupérer l’état des évènements d’entrée est une bonne chose, mais parfois nous ne voulons pas garder trace de ces évènements, nous voulons simplement savoir l’état d’un bouton ou la position de la souris à un moment précis. Pour cela, nous utilisons l’aide de la classe nommée Input (disposée dans core/os/input.h). La classe Input est un singleton global dans GDScript et peut être utilisée à de nombreux endroits dans votre script, mais elle est généralement utilisée dans _process(), par exemple :

export var char_speed = 100 # pixels/second 

func _process(delta): 
 var character_walk = Vector2(0, 0) 
 if (Input.is_joy_button_pressed(0, JOY_DPAD_LEFT)): 
 character_move.x = -(char_speed*delta) 
 elif (Input.is_joy_button_pressed(0, JOY_DPAD_RIGHT)): 
 character_move.x = char_speed*delta 
 else: 
 character_move.x = 0

Consultez la référence de la classe Input pour l’API complète.

Les actions d’Input

Lorsqu’on fait un jeu avec de multiples dispositifs d’input (comme les manettes et les claviers), il faut éviter de coder la détection de touche du clavier spécifiques car cela devient trop complexe à modifier au final, surtout si on veut les personnaliser. Pour cela, on utilise les actions. Une action représente un évènement abstrait, on peut alors interroger n’importe quel évènement d’Input pour vérifier s’il représente cette action. Pour créer cette action :

1. Dans l’éditeur, allez dans Projet > Paramètre du projet.

2. En haut, allez dans Contrôles, vous verrez alors la liste des actions.

3. Ajoutez une action : saisissez jump pour le nom de l’action dans la zone de texte puis cliquez sur ajouter.

4. Pour votre nouvelle action, cliquez sur ajouter évènement. Ajoutez une clef d’entrée en cliquant dessus. Dans notre cas, nous allons utiliser la touche espace. Répétez cette opération pour ajouter une action restart.
   

Vous pouvez alors utilisez ces actions d’input directement dans le script attaché au Node Chauve_souris.

Export var gravity = 10 
var speed = 300 
var impulse_cur = 0 

func _input(event): 
 if (event.is_action("jump") and event.is_pressed() and !event.is_echo()): 
 impulse() 

func impulse(): 
 impulse_cur = impulse_force

func _process(delta): 
 var dir = Vector2() 
 dir.x = speed*delta 
 dir.y = -(impulse_cur - gravity)*delta 
 if (impulse_cur > 0): 
 impulse_cur -= gravity*delta 
 set_position(get_position() + dir)

Maintenant que la chauve-souris peut sauter lorsque vous utilisez l’action jump (mais pas lorsque vous lâchez la touche).De plus, vous pouvez interroger le stade d’une action dans la fonction _process(). Par exemple, imaginez que vous avez les actions marche_droite et marche_gauche pour le joueur qui sont assignée aux flèches droite et gauche :

export var char_speed = 100 
# pixels/second 

func _process(delta): 
 var character_walk = Vector2(0, 0) 
 if Input.is_action_pressed("walk_left"): 
 character_move.x = -(char_speed*delta) 
 elif Input.is_action_pressed("walk_right"): 
 character_move.x = char_speed*delta 
 else: 
 character_move.x = 0

Saisir les événements d’entrée et interroger les états d’entrée

On pourrait également se servir de cet outil pour recharger le jeu après la mort via le script du niveau :

func _input(event): 
 if event.is_action("restart") && event.is_pressed() && !event.is_echo(): 
 if game_runing == false: 
 get_tree().reload_current_scene()

Vous devez maintenant vous demander, quelle méthode d’Input dois-je utiliser ? Les deux ont des avantages et des inconvénients ! Une réponse rapide : utilisez les deux ! Comme nous l’avons vue dans l’exemple, les deux méthodes sont utiles dans certains cas et inutiles dans d’autres. Par exemple, pour tirer, vous voulez savoir lorsque le bouton est pressé et ignorer tout le reste. Cependant pour marcher, il vous faut savoir l’état de la clef. Quelques conseils :

• Les évènements d’Input sont la façon dont nous obtenons des informations du système d’exploitation sur toutes les plates-formes. La classe d’entrée est un assistant implémenté au-dessus des évènements. Donc, si vous avez besoin de données brutes sur l’entrée, vérifiez les évènements.

• Parfois, une touche peut être pressée et relâchée dans le même cadre. Dans ce cas, l’Input ne vous informera pas des changements d’état mais du lancement d’une action.

• Si vous avez besoin de lancer du code qui répond aux évènements et aux états des clefs en même temps. Vous pouvez mettre votre évènement d’input dans une file d’attente et traiter celle-ci dans votre méthode _process. Il est cependant déconseillé de tenter de discerner les évènements à partir des informations fournies par Input.