Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Écoute des entrées du joueur

Pour continuer la leçon précédente Création de votre premier script, examinons une autre caractéristique importante de tout jeu : donner le contrôle au joueur. Pour cela, nous devons modifier le code de sprite_2d.gd.

../../_images/scripting_first_script_moving_with_input.gif

Vous disposez de deux outils principaux pour traiter les données du joueur dans Godot :

Les rappels d'entrée intégrés, principalement _unhandled_input(). Comme _process(), c'est une fonction virtuelle intégrée que Godot appelle chaque fois que le joueur appuie sur une touche. C'est l'outil que vous voulez utiliser pour réagir aux événements qui ne se produisent pas à chaque image, comme appuyer sur Space pour sauter. Pour en savoir plus sur les rappels d'entrée, consultez Utilisation d'InputEvent.
Le singleton Input. Un singleton est un objet accessible à tous. Godot donne accès à plusieurs d'entre eux dans les scripts. C'est le bon outil pour vérifier l'entrée à chaque image.

Nous allons utiliser le singleton Input ici car nous avons besoin de savoir si le joueur veut tourner ou bouger à chaque image.

Pour le tourner, nous devons utiliser une nouvelle variable : direction. Dans la fonction _process(), remplacez la ligne rotation += angular_speed * delta avec le code ci-dessous.

var direction = 0
if Input.is_action_pressed("ui_left"):
    direction = -1
if Input.is_action_pressed("ui_right"):
    direction = 1

rotation += angular_speed * direction * delta

var direction = 0;
if (Input.IsActionPressed("ui_left"))
{
    direction = -1;
}
if (Input.IsActionPressed("ui_right"))
{
    direction = 1;
}

Rotation += _angularSpeed * direction * (float)delta;

Notre variable locale direction est un multiplicateur représentant la direction dans laquelle le joueur veut tourner. Une valeur de 0 signifie que le joueur n'appuie pas sur la flèche gauche ou droite. Une valeur de 1 signifie que le joueur veut tourner à droite, et -1 signifie qu'il veut tourner à gauche.

Pour produire ces valeurs, nous introduisons les conditions et l'utilisation de Input. Une condition commence par le mot-clé if dans GDScript et se termine par deux points. La condition est l'expression entre le mot-clé et la fin de la ligne.

Pour vérifier si une touche a été enfoncée dans cette image, nous appelons Input.is_action_pressed(). Cette méthode prend une chaîne de texte représentant une action d'entrée et renvoie true si l'action est pressée, false sinon.

Les deux actions que nous utilisons ci-dessus, "ui_left" et "ui_right", sont prédéfinies dans chaque projet Godot. Elles se déclenchent respectivement lorsque le joueur appuie sur les flèches gauche et droite du clavier ou sur les flèches gauche et droite du D-pad d'une manette.

Note

Vous pouvez voir et modifier les actions d'entrée dans votre projet en allant dans Projet -> Paramètres du projet et en cliquant sur l'onglet Contrôle.

Enfin, nous utilisons le direction comme multiplicateur lorsque nous mettons à jour le nœud rotation : rotation += angular_speed * direction * delta.

Commentez les lignes var Velocity = Vector2.UP.rotated(rotation) * speed et position += Velocity * delta comme ceci :

#var velocity = Vector2.UP.rotated(rotation) * speed

#position += velocity * delta

//var velocity = Vector2.Up.Rotated(Rotation) * _speed;

//Position += velocity * (float)delta;

Cela ignorera le code qui a déplacé la position de l'icône dans un cercle sans intervention de l'utilisateur de l'exercice précédent.

Si vous exécutez la scène avec ce code, l'icône devrait tourner lorsque vous appuyez sur Left et Right.

Se Déplacer en appuyant sur "up"

Pour se déplacer uniquement en appuyant sur une touche, nous devons modifier le code qui calcule la vitesse. Décommentez le code et remplacez la ligne commençant par var Velocity par le code ci-dessous.

var velocity = Vector2.ZERO
if Input.is_action_pressed("ui_up"):
    velocity = Vector2.UP.rotated(rotation) * speed

var velocity = Vector2.Zero;
if (Input.IsActionPressed("ui_up"))
{
    velocity = Vector2.Up.Rotated(Rotation) * _speed;
}

Nous initialisons le velocity avec une valeur de Vector2.ZERO, une autre constante du type intégré Vector représentant un vecteur 2D de longueur 0.

Si le joueur appuie sur l'action "ui_up", nous mettons à jour la valeur de la vélocité, ce qui fait avancer le sprite.

Script en entier

Voici le fichier complet sprite_2d.gd pour référence.

extends Sprite2D

var speed = 400
var angular_speed = PI


func _process(delta):
    var direction = 0
    if Input.is_action_pressed("ui_left"):
        direction = -1
    if Input.is_action_pressed("ui_right"):
        direction = 1

    rotation += angular_speed * direction * delta

    var velocity = Vector2.ZERO
    if Input.is_action_pressed("ui_up"):
        velocity = Vector2.UP.rotated(rotation) * speed

    position += velocity * delta

using Godot;

public partial class MySprite2D : Sprite2D
{
    private float _speed = 400;
    private float _angularSpeed = Mathf.Pi;

    public override void _Process(double delta)
    {
        var direction = 0;
        if (Input.IsActionPressed("ui_left"))
        {
            direction = -1;
        }
        if (Input.IsActionPressed("ui_right"))
        {
            direction = 1;
        }

        Rotation += _angularSpeed * direction * (float)delta;

        var velocity = Vector2.Zero;
        if (Input.IsActionPressed("ui_up"))
        {
            velocity = Vector2.Up.Rotated(Rotation) * _speed;
        }

        Position += velocity * (float)delta;
    }
}

Si vous exécutez la scène, vous devriez maintenant être capable de tourner avec les touches fléchées gauche et droite et d'avancer en appuyant sur Up.

Résumé

En résumé, chaque script dans Godot représente une classe et étend l'une des classes intégrées du moteur. Les types de nœuds dont héritent vos classes vous donnent accès à des propriétés, telles que rotation et position dans le cas de notre sprite. Vous héritez également de nombreuses fonctions, que nous n'avons pas pu utiliser dans cet exemple.

Dans GDScript, les variables que vous placez en haut du fichier sont les propriétés de votre classe, également appelées variables membres. Outre les variables, vous pouvez définir des fonctions qui, pour la plupart, seront les méthodes de vos classes.

Godot fournit plusieurs fonctions virtuelles que vous pouvez définir pour connecter votre classe avec le moteur. Il s'agit notamment de _process(), pour appliquer des modifications au nœud à chaque image, et _unhandled_input(), pour recevoir des événements d'entrée comme des pressions de touches et de boutons de la part des utilisateurs. Il y en a beaucoup d'autres.

Le singleton Input vous permet de réagir aux entrées des joueurs n'importe où dans votre code. En particulier, vous pourrez l'utiliser dans la boucle _process().

Dans la prochaine leçon, Utiliser les signaux, nous développerons la relation entre les scripts et les nœuds en faisant en sorte que nos nœuds déclenchent du code dans les scripts.