Activité : MARIO RUN

Objectifs du module Mario Scratch

À partir d’un modèle de jeu Mario complet, l’objectif est d’apprendre à lire, comprendre et modifier un gros projet Scratch comme un vrai développeur de jeux vidéo.

• Comprendre le fonctionnement global du code du jeu (qui fait quoi, dans quel ordre).
• Être capable d’isoler les différentes fonctionnalités (déplacement, saut, collisions, score, niveaux…).
• Comprendre le rôle précis des variables importantes (vitesse, gravité, vies, niveau, terrain…).
• Comprendre le rôle des messages Scratch (broadcast) et identifier leurs émetteurs et récepteurs.
• Savoir tweaker (modifier) les comportements en jouant sur les variables (vitesse, hauteur de saut, difficulté…).
• Savoir nettoyer, organiser et simplifier le code pour le rendre plus lisible.
• Savoir modifier la logique de jeu (ajout de terrain, de niveaux, de règles, modification du comportement des ennemis…).

Projet de départ, à télécharger, enregistrer dans votre dossier de travail et ouvrir dans Scratch :

Mario run avec commentaires

 -----------------------------------------------------------------------------------------------------------------------------

0) Comprendre l’anatomie d’un jeu Mario Scratch

Les sprites = les “organes” du jeu

• Mario : le joueur, contrôle clavier, saut, collisions avec le monde.
• Goomba / Gomba : ennemi de base qui marche et peut tuer Mario.
• Koopa : ennemi qui a souvent plusieurs états (normal, dans sa carapace…).
• Balles / Bullets : projectiles qui sortent de canons ou d’ennemis.
• Coins / Pièces : objets à ramasser, qui font monter le score.
• Sprites de terrain : sol, plateformes, tuyaux, blocs, décor…
• HUD / Interface : score, nombre de vies, affichage “Game Over”, etc.

Dans Scratch, un bon réflexe est de parcourir les sprites un par un et de se demander :
– Quel est son rôle principal ?
– Combien de scripts contient-il ?
– Utilise-t-il des variables ou des messages importants ?

Les variables = la mémoire et le cerveau du jeu

• Variables de Mario : vitesse horizontale (par ex. vx), vitesse verticale / gravité (par ex. vy, gravite), état (par ex. sur_le_sol, direction, estMort…).
• Variables globales du jeu : score, coins, nb_vies, niveau ou level, etc.
• Variables de terrain : numéro de terrain (par ex. terrain), décalage du décor (par ex. offset_x), etc.
• Variables d’ennemis : direction, état (vivant, écrasé…), vitesse, etc.

Astuce simple : affiche quelques variables à l’écran, joue au jeu, et observe lesquelles bougent. C’est le moyen le plus rapide pour voir qui contrôle quoi.

Les messages Scratch = le système nerveux

Scratch ne possède pas de fonctions comme Python, mais il a les blocs :

• envoyer à tous [message]
• quand je reçois [message]

Ce sont des “signaux” que les sprites s’envoient entre eux. Exemple typique dans un Mario :

• mort_mario : prévient tous les sprites que Mario vient de mourir.
• next_level : signale qu’on passe au niveau suivant.
• game_over : informe le jeu que la partie est terminée.

Émetteur = sprite qui envoie le message. Récepteurs = tous les scripts qui commencent par “quand je reçois [ce message]”.

La logique générale du jeu

• Initialisation : mise à zéro des variables, placement de Mario au départ, chargement du niveau 1.
• Boucle de jeu : lecture des touches, déplacement de Mario, collisions, mise à jour du décor, du score, des vies…
• Transitions : passage au niveau suivant, perte d’une vie, game over, victoire, etc.

L’objectif final : être capable de regarder ce projet Mario et de dire :
« Je vois la structure, je sais où sont les variables importantes, je comprends qui envoie quels messages, et je peux modifier tout ça sans casser le jeu. »

 -----------------------------------------------------------------------------------------------------------------------------

1) Questions de lecture de code à se poser

> Quels sont les sprites/personnages nécessaires ?

1. Mario (le joueur).
2. Goomba / Gomba (ennemi simple).
3. Koopa (ennemi avec plusieurs états).
4. Balles (Bullets) et autres projectiles.
5. Coins (pièces) et bonus éventuels.
6. Sprites de terrain (sol, plateformes, tuyaux, décor…).
7. HUD (score, vies, messages de fin, etc.).

> Pour chaque sprite/personnage :

1. Comment le personnage réagit aux actions de l’utilisateur ?
   – Touche flèche droite
   – Touche flèche gauche
   – Touche flèche haut (saut, interaction…)
   
2. Comment le personnage interagit avec le monde ?
   – Contact avec le sol / plateformes
   – Contact avec les autres personnages (ennemis, pièces, projectiles…)
   – Gestion du déplacement vertical (saut, gravité) et horizontal (course / déplacement)
   
3. Comment s’organise la logique du jeu ?
   – Qu’est-ce qui nous fait gagner ?
   – Qu’est-ce qui nous fait perdre ?
   – Y a-t-il plusieurs niveaux ? Comment passe-t-on de l’un à l’autre ?
   

 -----------------------------------------------------------------------------------------------------------------------------

2) EXERCICES détaillés pour percer tous les secrets du code

EXERCICE 1 :

Identifier la variable qui gère le mouvement horizontal de Mario (souvent appelée vx, vitesse_x, etc.) et la désactiver.
Méthode : repérer dans les scripts de Mario les blocs changer x par ( ... ), voir quelle variable est utilisée, puis la forcer à 0 ou retirer ce changement dans la boucle de jeu.

EXERCICE 2 :

Modifier le jeu pour que Mario coure 2 fois plus vite.
Méthode : là où la variable de vitesse horizontale est utilisée, multiplier son effet par 2 (par exemple, changer x par (vitesse_x * 2), ou doubler la valeur de la vitesse au moment où elle est calculée).

EXERCICE 3 :

Identifier la variable qui gère la gravité ou la vitesse verticale (souvent vy ou gravite) et faire en sorte que Mario saute 2 fois plus haut.
Méthode : augmenter la force de saut (l’impulsion vers le haut) ou diminuer l’intensité de la gravité (par exemple passer d’une gravité de -1 à -0,5).

EXERCICE 4 :

Sur le sprite Mario, trouver 2 simplifications de code qui rendent le code plus lisible.
Exemples de simplifications :
– regrouper deux scripts qui font presque la même chose,
– remplacer deux variables booléennes par une seule variable direction qui vaut -1, 0 ou 1,
– éviter les blocs dupliqués en créant une seule logique plus générale.

EXERCICE 5 :

Déterminer la variable qui gère le nombre de vies (par exemple nb_vies) et faire en sorte que Mario n’ait plus que 2 vies.
Méthode : trouver l’initialisation (souvent dans un script quand le drapeau vert est cliqué) et remplacer mettre [nb_vies] à [3] par mettre [nb_vies] à [2].

EXERCICE 6 :

Quelle variable sert à gérer les niveaux ?
Méthode : jouer un peu en affichant les variables visibles, repérer celle qui change de 1 à 2 à 3 (souvent appelée niveau, level ou world). Noter où elle est utilisée pour charger les décors et les ennemis.

EXERCICE 7 :

Dans quel sprite le changement de niveau a-t-il lieu ?
Méthode : chercher les blocs changer [niveau] par (1) ou les messages envoyer à tous [next_level]. Le sprite qui déclenche ce changement (Mario, un drapeau, un “LevelManager”…) est celui qui décide du passage de niveau.

EXERCICE 8 :

Comprendre comment est géré le déplacement du terrain. Combien de terrains existe-t-il par niveau ?
Méthode : regarder les scripts des sprites de terrain. Soit c’est Mario qui bouge et le terrain reste fixe, soit Mario reste presque au centre et c’est le terrain qui défile en sens inverse (runner). Compter le nombre de costumes / sprites de terrain différents ou les valeurs possibles de la variable terrain.

EXERCICE 9 :

Modifier le code pour que l’on passe directement du terrain 6 au terrain 8 (c’est-à-dire désactiver le terrain 7).
Méthode : repérer la logique qui fait passer le terrain de 6 à 7 (par exemple changer [terrain] par (1) ou mettre [terrain] à [7]) et la remplacer par un passage direct à 8 (par exemple mettre [terrain] à [8] ou un si [terrain = 7] alors mettre [terrain] à [8]).

 -----------------------------------------------------------------------------------------------------------------------------

3) Super QCM Mario Scratch

Ce QCM permet de vérifier que vous avez bien compris la logique interne du jeu et pas seulement les mots-clés.

1. Dans un jeu Mario Scratch, quelle variable a le plus de chances de représenter le mouvement horizontal de Mario ?
   A. niveau
   B. gravite
   C. vx_mario
   D. nb_vies
2. Si vous voulez désactiver complètement le mouvement horizontal de Mario sans supprimer de blocs, que pouvez-vous faire ?
   A. Mettre la variable de vitesse horizontale à 0 en permanence.
   B. Supprimer tous les blocs changer x par.
   C. Changer la couleur du fond.
   D. Remplacer la gravité par 0.
3. Quelle combinaison de paramètres rendra probablement le jeu le plus difficile ?
   A. Vitesse horizontale très faible, gravité faible.
   B. Vitesse horizontale élevée, gravité élevée.
   C. Vitesse horizontale faible, gravité normale.
   D. Vitesse horizontale élevée, gravité faible.
4. La variable nb_vies est généralement décrémentée (−1) quand :
   A. Mario saute.
   B. Mario ramasse une pièce.
   C. Mario tombe dans un trou ou touche un ennemi par le côté.
   D. On presse la touche “espace”.
5. Le message game_over a le rôle suivant :
   A. Déplacer Mario vers la droite.
   B. Informer tous les sprites que la partie est terminée.
   C. Augmenter le score.
   D. Démarrer un nouveau niveau.
6. Pour changer de niveau, le jeu utilise le plus souvent :
   A. Une variable qui compte le nombre de sauts.
   B. Une variable niveau ou level.
   C. Une variable vx_mario.
   D. Une variable gravite.
7. Si vous voulez que Mario saute deux fois plus haut, la première chose à tester est :
   A. Diviser par 2 la variable de gravité (la rendre moins négative).
   B. Multiplier par 2 la variable de gravité (la rendre plus négative).
   C. Supprimer tous les blocs qui touchent le sol.
   D. Changer la taille du costume de Mario.
8. Le déplacement du terrain dans un “Mario run” est souvent implémenté comme :
   A. Terrain immobile et Mario qui change son x.
   B. Mario presque immobile et terrain qui bouge en sens inverse.
   C. Les deux bougent au hasard.
   D. Aucun des deux ne bouge, c’est l’écran qui se déplace.
9. Pour “sauter” le terrain 7 et passer directement de 6 à 8, que faut-il modifier ?
   A. La variable nb_vies.
   B. La variable terrain ou la logique qui teste le passage entre terrains.
   C. Le costume de Mario.
   D. Le message game_over.
10. Dans Scratch, pour mieux organiser le code de Mario, la bonne pratique est :
    A. Mettre tout le code dans un seul gros script quand le drapeau vert est cliqué.
    B. Créer plusieurs scripts mais les nommer n’importe comment.
    C. Regrouper les parties qui font la même chose (par exemple, toute la physique dans un script, l’interface dans un autre).
    D. Dupliquer les scripts pour être sûr qu’ils s’exécutent.

Correction :
1) C  – 2) A  – 3) B  – 4) C  – 5) B  – 6) B  – 7) A  – 8) B  – 9) B  – 10) C