Activité MARIO RUN 2 : construction du jeu

Objectif général :

À partir d’un modèle de jeu de type Mario Run, l’objectif est de comprendre en profondeur comment fonctionne un jeu de plateforme :

• Créer et utiliser des variables de jeu (score, gravité, vies, défilement…).
• Programmer un écran de démarrage (“Start screen”).
• Programmer le comportement de Mario : course, saut, chute, gestion des vies.
• Gérer le défilement du décor avec une variable de scroll.
• Programmer les terrains, le château de fin de niveau et l’affichage des vies.

---

0) Fichier de départ

Télécharger le fichier de base :
Base MARIO RUN

Ouvrir ce fichier dans Scratch, le sauvegarder dans le dossier de travail, puis suivre les étapes ci-dessous.

---

1) Création des variables : le cerveau du jeu

Les variables sont la mémoire du jeu. Elles conservent les informations importantes d’un instant à l’autre. Voici les variables à créer :

• Coins – le nombre de pièces collectées par Mario.
• gravity – force qui tire Mario vers le bas (la “gravité”).
• Lifes – le nombre de vies du joueur.
• Jump – état du saut (0 = ne saute pas, 1 = en train de sauter, etc.).
• Scrollx – défilement horizontal du décor (plus cette valeur change, plus le monde défile).

À faire dans Scratch :

• Menu “Variables” → “Créer une variable”.
• Créer Coins, gravity, Lifes, Jump, Scrollx.
• Pour le moment, les laisser visibles à l’écran : cela aide à comprendre ce qui se passe pendant le jeu.

---

2) Écran de démarrage – Sprite “Start screen”

Avant le jeu, il est souvent utile d’avoir un écran de démarrage qui affiche un logo, un titre et un message du type “Appuyez sur espace pour commencer”.

Idée générale :

• Au lancement du projet : afficher l’écran de démarrage, cacher le reste.
• Attendre que le joueur appuie sur une touche (par exemple espace).
• Cacher l’écran de démarrage et envoyer un message du type “start Game” à tous les autres sprites.

Structure recommandée pour “Start screen” :

• Bloc “quand drapeau vert cliqué” :
  • Afficher le sprite “Start screen”.
  • Afficher un texte / costume “Appuie sur espace pour jouer”.
  • Répéter jusqu’à ce que la touche espace soit pressée.
  • Quand espace est pressée : cacher “Start screen” et envoyer le message start Game.

Ce message start Game sera le point de départ de tout le reste du jeu.

---

3) Sprite Mario – le cœur du gameplay

Le sprite Mario est celui qui concentre le plus de logique. Pour ne pas se perdre, on respecte l’ordre conseillé :

1. Initialisation (Scroll, gravity, visibilité…)
2. Course (mouvement horizontal tant qu’il ne saute pas et que le sol est correct)
3. Mise à jour de Scrollx (défilement du décor)
4. Test du bas de l’écran (tomber dans le vide → perdre une vie)
5. Comportement de saut (“Jump”)
6. Gestion des variables Jump (initiation et fin de saut)
7. Gestion de la vie et “Game Over”

Important : NE PAS copier / écrire pour l’instant les boucles “touche le Goomba”, “touche le Koopa” ni “touche la Bullet”.

3.1 – Initialisation de Mario

• Quand le drapeau vert est cliqué, mettre Mario dans son costume de départ, sur sa position de départ.
• Initialiser les variables globales, par exemple :
  • Lifes = 3 (ou 5, selon le choix).
  • Coins = 0.
  • gravity = une valeur de base (par ex. -2 ou -3 selon le projet).
  • Jump = 0 (Mario ne saute pas au début).
  • Scrollx = 0 (aucun défilement au lancement).
• Cacher Mario tant que le jeu n’a pas commencé, puis le montrer quand le message start Game est reçu.

3.2 – Course de Mario

Ici, on gère la course quand Mario ne saute pas et que le terrain est “sain”.

• Dans une boucle “répéter indéfiniment”, tant que Jump == 0, Mario avance :
  • Si la touche flèche droite est pressée → Mario avance vers la droite.
  • En même temps, on pourra modifier Scrollx pour que le décor se déplace.
  • On peut vérifier aussi que Mario ne touche pas une couleur interdite (par ex. un vert “mortel” ou un bloc spécial).

La phrase clé donnée : “Course si la touche flèche haut n’est pas pressée et la couleur verte n’est pas touchée.” Cela signifie : pas de saut + terrain normal → Mario court.

3.3 – Boucle de mise à jour de la variable Scrollx

La variable Scrollx permet de simuler que Mario avance dans un grand niveau, même si en réalité Mario peut rester presque au centre de l’écran tandis que le décor bouge.

• Quand Mario avance, Scrollx augmente (ou diminue) selon la direction.
• Les terrains lisent ensuite Scrollx et mettent à jour leur position pour donner l’illusion du mouvement.

Idée : dans la grande boucle de Mario, chaque fois qu’il avance, modifier Scrollx d’un petit pas (par ex. ajouter 3 à Scrollx).

3.4 – Test si Mario touche le bas de l’écran

Si Mario tombe dans un trou, ou sort par le bas de l’écran, le joueur doit perdre une vie.

• Dans la boucle principale, vérifier la position y de Mario.
• Si y est inférieur à une certaine valeur (par ex. en dessous du sol) :
  • Réduire Lifes de 1.
  • Remettre Mario à une position de départ (respawn).
  • Éventuellement jouer un son ou afficher un effet visuel.

3.5 – Boucle comportement “Jump”

Le saut de Mario est géré par un ensemble de blocs utilisant la variable Jump et la variable gravity.

• Quand la touche flèche haut est pressée et que Mario a le droit de sauter → mettre Jump = 1.
• Pendant que Jump == 1, modifier la position y de Mario en fonction de gravity :
  • Au début du saut, gravity est positive (Mario monte).
  • Puis gravity diminue progressivement jusqu’à devenir négative (Mario redescend).
• Quand Mario retouche le sol, remettre Jump = 0 et réinitialiser gravity.

3.6 – Gestion des variables Jump

Ici, l’objectif est d’avoir une logique claire :

• Jump = 0 → Mario est au sol.
• Jump = 1 → Mario est en train de sauter.

On peut également gérer des variantes (double saut, saut long, etc.), mais dans une première version, le simple 0 / 1 suffit.

3.7 – Gestion de la vie et message “Game Over”

• Dans une boucle, surveiller la variable Lifes.
• Si Lifes tombe à 0 :
  • Afficher un message “Game Over”.
  • Arrêter tous les scripts, ou envoyer un message Game Over que les autres sprites peuvent écouter.

---

4) Code des terrains – faire défiler le monde

Les terrains sont les blocs de décor sur lesquels Mario court. Ils ne décident pas de tout : ils réagissent à la variable Scrollx.

Consigne : ne pas écrire pour l’instant le code qui concerne les “Levels” (changement de niveau complet).

4.1 – Réponse à l’événement “start Game”

• Pour chaque sprite de terrain :
  • Utiliser un bloc “quand je reçois [start Game]”.
  • À ce moment-là, afficher le sprite et le placer à sa position de départ.

4.2 – Boucle de mise à jour de la position avec Scrollx

Chaque terrain doit actualiser sa position en fonction de Scrollx.

• Dans une boucle “répéter indéfiniment” :
  • Mettre la position x du terrain en fonction de sa position initiale et de Scrollx.
  • Par exemple : position x = position de base – Scrollx.
  • Résultat : plus Scrollx augmente, plus le terrain “glisse” vers la gauche, donnant l’illusion que Mario avance.

---

5) Sprite “castle1” – le château de fin de niveau

Le sprite castle1 représente le château de fin de niveau. Quand Mario l’atteint, le niveau est terminé.

Idées de comportement :

• Réagir au message start Game : se placer au bon endroit et se montrer.
• Dans une boucle, surveiller :
  • Si Mario touche castle1 → envoyer un message Level Complete ou Win.
  • Arrêter le défilement (ne plus modifier Scrollx).
  • Afficher un écran de fin (score, pièces, temps, etc.).

---

6) Sprite “Vie” – afficher les cœurs du joueur

Le sprite “Vie” sert à montrer visuellement le nombre de vies restantes. On peut afficher un cœur, plusieurs cœurs, ou un chiffre stylisé.

6.1 – Initialisation

• Au démarrage du jeu (message start Game) :
  • Positionner le sprite “Vie” dans un coin de l’écran (par exemple en haut à gauche).
  • Choisir le costume correspondant au nombre de vies initial (Lifes).

6.2 – Mise à jour en fonction de Lifes

• Dans une boucle, surveiller la variable Lifes :
  • Si Lifes == 3 → costume “3 cœurs”.
  • Si Lifes == 2 → costume “2 cœurs”.
  • Si Lifes == 1 → costume “1 cœur”.
  • Si Lifes == 0 → soit cacher le sprite, soit afficher un symbole spécial (crâne, cœur brisé…).

---

7) Mini QCM – Comprendre la logique de Mario Run

1. 1. À quoi sert principalement la variable Scrollx ?

   • A. À compter les pièces.
   • B. À gérer la gravité.
   • C. À faire défiler les terrains pour simuler le mouvement.
   • D. À choisir le costume de Mario.

2. 2. Quelle variable indique que Mario est en train de sauter ?

   • A. Lifes
   • B. Coins
   • C. Jump
   • D. gravity

3. 3. Quel élément déclenche réellement le début du jeu pour tous les sprites ?

   • A. Le drapeau vert.
   • B. Le message start Game envoyé par “Start screen”.
   • C. Le premier saut de Mario.
   • D. Le contact avec le château.

4. 4. Quand Mario tombe sous le bas de l’écran, que doit faire normalement le code ?

   • A. Augmenter Lifes de 1.
   • B. Réduire Lifes de 1 et remettre Mario à un point de départ.
   • C. Remettre Scrollx à 0 mais ne rien changer aux vies.
   • D. Fermer Scratch.

5. 5. Le sprite “Vie” sert principalement à…

   • A. Gérer les collisions avec les ennemis.
   • B. Afficher le nombre de vies en fonction de la variable Lifes.
   • C. Modifier la vitesse de Mario.
   • D. Faire défiler le décor.

Corrigé :
1) C – Scrollx sert à faire défiler les terrains.
2) C – Jump indique l’état du saut.
3) B – Le message start Game lance le jeu pour tous.
4) B – On perd une vie et Mario est replacé.
5) B – “Vie” affiche le nombre de vies à partir de Lifes.