⚾ Rolling ball p.1

🎯 Contexte

Pour ce premier exercice, nous allons nous amuser avec la physique de Godot.

Le projet est un petit jeu physique dans lequel une balle roule sur des plateformes.

Il est basé sur les assets libres de droit Rolling Ball Assets de Kenney.

Le projet de départ contient déjà :

• Les assets du pack.
• Une scène balle (ball.tscn), dont le noeud racine est un RigidBody2D.
• Une scène de plateforme en pente (corner_block.tscn), dont le noeud racine est un StaticBody2D.
• Une scène World (world.tscn), qui contient une balle et deux plateformes.

🔍 Découverte du projet

Avant de commencer à pratiquer, prenez le temps de regarder ce qui existe :

• Ouvrez la scène world.tscn et regardez ce qu’elle contient.
• Ouvrez la scène ball.tscn et regardez de quoi elle est composée.
• Ouvrez la scène corner_block.tscn et regardez de quoi elle est composée.
• Enfin, lancez le jeu (raccourci clavier F5) et regardez ce qui se passe.

🛠️ Exercices

A. Corriger les problèmes

1. Ajouter la collision à la balle

La balle n’a pas de collision, c’est pour ça qu’elle traverse tout ce qu’elle rencontre.

• Ouvrez la scène de la balle.
• Ajoutez un CollisionShape2D en enfant du noeud racine.
• Dans l’inspecteur, créez une nouvelle forme CircleShape2D et ajustez son rayon pour qu’elle recouvre la balle.

Relancez le jeu : la balle ne devrait plus traverser les plateformes.

2. Ajouter une caméra

À présent, il faut que la vue suive la balle quand elle sort de l’écran.

• Ajoutez un noeud Camera2D en enfant de la balle.
• Relancez le jeu et vérifiez que la caméra suit bien la balle.
• Réglez le zoom en modifiant la propriété zoom.

Pour aller plus loin, vous pouvez activer Position Smoothing sur la caméra pour adoucir ses mouvements.

B. Plateforme tournante

1. Création de la scène

Créez une nouvelle scène (prefab) pour un bloc qui tourne sur lui-même.

Ajoutez ensuite :

• Un Sprite2D en enfant, avec la texture de la plateforme tournante (block_rotate*.png).

  

• Un CollisionPolygon2D en enfant, dont vous créerez le polygone en passant par la barre d’outils.

  

2. Script de rotation

À présent, on veut faire tourner la plateforme. Pour cela, nous allons ajouter ce comportement via un script.

• Ajoutez un script au noeud racine.
• Dans ce script, ajoutez la fonction _physics_process, puis modifiez-y la propriété rotation à chaque frame.

extends AnimatableBody2D

func _physics_process(delta):
    rotation += 1.0 * delta

3. Utilisation dans le monde

Normalement, tout est bon : vous pouvez tester la plateforme.

• Ajoutez une ou plusieurs instances de votre plateforme dans la scène principale (World).
• Placez-les à différents endroits du niveau.
• Lancez le jeu et testez ce que ça donne.

4. Contrôler la vitesse

Pour le moment, toutes les plateformes tournent à la même vitesse, et changer cette vitesse oblige à modifier le script.

Nous allons donc exposer la vitesse dans l’inspecteur, grâce à une variable marquée @export.

• Dans votre script, créez une variable rotation_speed précédée de @export.
• Utilisez-la à la place de la valeur fixe dans _physics_process.
• Revenez dans World et donnez une vitesse différente à chaque instance, directement depuis l’inspecteur.

@export var <nom_de_la_variable>: <type_de_la_variable> = <valeur_par_défaut>

5. Inverser le sens du visuel

L’image de la plateforme comporte des flèches qui indiquent son sens de rotation.
Mais à l’heure actuelle, elle n’est pas cohérente avec le mouvement.

Pour corriger ça, il faut retourner l’image (flip) :

• Ouvrez la scène de la plateforme tournante.
• Sélectionnez le Sprite2D et utilisez la propriété flip_h pour corriger ça.
  Quand flip_h est activé, l’image est affichée en miroir.

On veut à présent que ce paramètre change en fonction du sens de rotation de la plateforme :

• Quand la vitesse de rotation est  ≥ 0, on veut que flip_h = true.
• Quand la vitesse de rotation est  < 0, on veut que flip_h = false.

On va donc ajouter ce comportement dans le script.

Tout d’abord, il faut que le script puisse accéder au sprite.
Nous allons utiliser une variable exposée avec @export pour référencer le noeud directement depuis l’inspecteur.

Voici les étapes à suivre :

• Dans votre script, déclarez en haut une variable exportée de type Sprite2D.
• Retournez dans l’éditeur de scène et sélectionnez le noeud racine : la variable apparaît dans l’inspecteur avec un emplacement vide.
• Glissez-déposez le noeud Sprite2D depuis l’arbre de la scène vers cet emplacement.
• Dans la méthode _ready, modifiez la propriété flip_h du sprite en fonction du signe de rotation_speed.

@export var sprite: Sprite2D

Pour tester, placez deux plateformes dans la scène World et donnez une vitesse positive à l’une d’elles et négative à l’autre.
Vérifiez ensuite que le visuel est bien retourné en fonction de la vitesse de rotation.

C. Contrôle de la balle

Pour le moment, la balle tombe toute seule dès le lancement du jeu. Nous allons rendre le jeu interactif : la balle reste immobile au départ, on vise avec la souris en maintenant le clic, et on la lance en relâchant.

1. Geler la balle

Pour que la balle ne bouge pas au lancement, il faut la geler.

• Sélectionnez le noeud racine de la balle (le RigidBody2D).
• Dans l’inspecteur, activez la propriété freeze.
• Lancez le jeu et vérifiez que la balle ne tombe plus.

2. Créer l’action de visée

Plutôt que de tester directement un bouton de la souris dans le code, Godot propose un système d’actions : un nom (par exemple aim) auquel on associe une ou plusieurs touches ou boutons.

• Dans le menu en haut à gauche de l’éditeur, allez dans Project > Project Settings, puis dans l’onglet Input Map.
• Ajoutez une nouvelle action nommée aim.
• Associez-lui le clic gauche de la souris (bouton + à droite de l’action).

3. Construire le visuel de visée

Nous allons afficher une ligne pour visualiser l’impulsion qui sera appliquée à la balle.

• Ajoutez un noeud Node2D en enfant de la balle, que vous nommerez Aim.
• Ajoutez un noeud Line2D en enfant de Aim.
• Sélectionnez ce dernier et, dans l’inspecteur, ajoutez deux points dans la propriété points. Leur position n’a pas d’importance, on va la gérer dans le code.

4. Script de visée

Ajoutez un script au noeud Aim. Il doit réaliser les choses suivantes :

• Exposer des références vers le Line2D et le RigidBody2D de la balle, avec @export (comme dans l’exercice précédent), puis les assigner dans l’inspecteur.
• À chaque frame, dans _process :
  • Afficher le noeud uniquement pendant que l’action aim est maintenue (Input.is_action_pressed, propriété visible).
  • Faire en sorte que la ligne aille de la balle à la souris (set_point_position de Line2D, et get_local_mouse_position).

Lancez le jeu : en maintenant le clic, la ligne doit relier la balle à la souris.

5. Lancer la balle

Dernière étape : quand on relâche le clic, la balle doit partir.

• Détectez le relâchement de l’action aim avec Input.is_action_just_released, dans _process.
• Appelez alors une fonction throw() que vous créez.
• Dans throw() :
  • Dégelez la balle (propriété freeze).
  • Appliquez-lui une impulsion avec apply_central_impulse. La direction et la force correspondent au vecteur qui va de la balle jusqu’à la souris.

Pour aller plus loin, essayez d’ajuster la puissance du lancer, par exemple avec une variable @export qui multiplie l’impulsion.

D. Construisez un niveau

Vous avez maintenant tous les ingrédients : des plateformes statiques, des plateformes tournantes réglables, et une balle que l’on peut lancer à la souris.

À vous de les assembler pour construire votre propre niveau !

Objectif

Créez un niveau où la balle, lancée depuis un point de départ, doit rejoindre une zone d’arrivée.

Pour le moment, l’arrivée est purement visuelle. Nous verrons plus tard comment détecter ça automatiquement.

Conseils

• Pour dupliquer une plateforme déjà placée, sélectionnez-la dans l’arbre de la scène et utilisez Ctrl + D. Pensez à ajuster ensuite sa position, et sa vitesse si c’est une plateforme tournante.

• Pour garder une scène lisible, regroupez vos éléments sous des noeuds Node2D bien nommés (par exemple Platforms). Un arbre organisé est beaucoup plus simple à parcourir quand le niveau grandit.

🎁 Pour aller plus loin

• Touche de réinitialisation : faites en sorte qu’appuyer sur R recommence le niveau.
  • Créez une nouvelle action reset dans l’Input Map et associez-lui la touche R.
  • Ajoutez un script au noeud racine de World.
  • Détectez l’appui sur l’action avec Input.is_action_just_pressed.
  • Rechargez la scène avec get_tree().reload_current_scene().
• Créez une nouvelle scène de plateforme statique (autre forme ou autre texture du pack) et utilisez-la dans votre niveau.
• Ajoutez du décor avec les assets du pack, pour donner une ambiance à votre niveau.
• Fabriquez un trampoline : sur une plateforme statique, ajoutez un PhysicsMaterial avec une valeur de Bounce élevée, et observez l’effet sur la balle.
• Customisez la balle : jouez avec sa masse, son frottement, son rebond et notez comment chaque réglage change son comportement.