Apprendre à coder avec Scratch : un jeu video "Mission fraises"


Utiliser un chronomètre avec Scratch ? Comptabiliser des éléments ? Créer des clones ? ce projet qui consiste à ramasser des fraises, mais j’aurai pu mettre des framboises, propose de découvrir ces différentes fonctionnalités.

Au niveau du graphisme, je me suis amusée à créer des sprites et un arrière-plan « pixélisés ». Le décor, assez simple, fait référence à Zelda. 
Pour la présentation des consignes ? Je vous laisse découvrir ma version sur mon compte Scratch. Mettez le son !

Dans cet article je ne vais pas détailler la création des éléments graphiques. Vous pouvez dessiner vos propres sprites et arrière-plan. Ou utiliser directement les éléments disponibles dans les bibliothèques intégrées à Scratch.

Les sprites

Ce projet utilise trois sprites :
  • Consignes qui s’affiche au démarrage du jeu
  • Joueur
  • Fraise



Programme Consignes

Le sprite Consignes apparait sur la scène en préambule du jeu, et ce pendant 5 secondes. Le lancement de la partie est actionné par l’envoi du message Jeu.

quand drapeau vert est cliqué // lancement de la lecture et de l’exécution du programme.

montrer // le sprite est visible sur la scène.

attendre 5 secondes // temps d’affichage pour permettre au joueur de lire les consignes.

envoyer à tous Jeu // ce message lance l’éxécution des programmes situés sur les autres sprites.

cacher // la partie commence. Les consignes disparaissent de la scène.




Programme Joueur


Le programme du sprite Joueur est constitué de trois piles de blocs qui représentent :
  • l’initialisation ;
  • la phase de jeu ;
  • la fin du jeu et l’affichage du résultat de la cueillette.




La première pile de blocs intègre les différents éléments d’initialisation et les paramètres graphiques du sprite Joueur.
  • La taille du sprite sur la scène.
  • Les modalités de déplacement du Joueur : de rotation et touches du clavier. 


quand drapeau vert est cliqué

mettre la taille à 50% de la taille initiale

fixer le sens de rotation gauche-droite // pour éviter que le sprite se retrouve la tête en bas lors des changements de direction.

cacher // pendant la phase de présentation des consignes les éléments du jeu ne sont pas visibles sur la scène.

répéter indéfiniment // cette boucle de répétition contient les quatre instructions utilisées pour déplacer le joueur dans les quatre directions.

si touche flèche droite pressée ? alors // instruction qui prend la forme d’une condition pour programmer la flèche directionnelle droite.

s’orienter à 90 // le joueur s’oriente vers la droite de la scène.

avancer de 5 pas // cette valeur peut être modifiée en fonction de la vitesse avec laquelle vous souhaitez que votre joueur se déplace. 

si touche flèche gauche pressée ? alors // instruction qui prend la forme d’une condition pour programmer la flèche directionnelle gauche.

s’orienter à -90 // le joueur s’oriente vers la gauche de la scène. S’il était positionné précédemment vers la droite, il pivote.

avancer de 5 pas

si touche flèche haut pressée ? alors // instruction qui prend la forme d’une condition pour programmer la flèche directionnelle haut.

s’orienter à 0 // la position du joueur ne change pas. Mais lorsqu’il se déplacera, il se dirigera vers le haut de scène.

avancer de 5 pas

si touche flèche bas pressée ? alors // instruction qui prend la forme d’une condition pour programmer la flèche directionnelle bas.

s’orienter à 180 // la position du joueur ne change pas. Mais lorsqu’il se déplacera, il se dirigera vers le bas de scène.

avancer de 5 pas

La deuxième pile de blocs contient des instructions qui s’exécutent pendant la phase de jeu quand je reçois Jeu.


Une partie dure 30 secondes. Pour chronomètrer le temps écouler, nous allons utiliser la fonction chronomètre de Scratch (blocs Capteurs). D’autres techniques existent pour chronométrer le temps.

quand je reçois Jeu // ce message, envoyé par le sprite Consignes lance l’exécution des programmes liés à la phase de jeu.

réinitialiser le chronomètre // le chronomètre se remet à 0.

aller à x : 0 y :  0 // le joueur est se place au centre de la scène.

montrer // il est visible.

répéter indéfiniment // cette boucle de répétition contient l’instruction qui teste en permanence le temps écoulé pour déterminer la fin de la partie.

si chronomètre > 30 alors

envoyer à tous Fin // la partie est terminée lorsque 30 secondes se sont écoulées. Cette durée peut être modifiée.


La troisième pile de blocs contient l’instruction de fin de partie qui affiche sur la scène le résultat de la cueillette des fraises. Le résultat est dit par le joueur dans une bulle de parole.

quand je reçois Fin

aller à x : 0 y : 0 // le joueur se positionne au centre de la scène.

mettre la taille à 100% de la taille initiale // le joueur sprite Joueur est plus grand que lors de la phase de jeu. Il reprend sa 
taille réelle

dire regrouper j’ai ramassé et regrouper nombre de fraises et fraises // la valeur de la variable nombre de fraises est incorporée dans la phrase.





Programme Fraises

Le programme du sprite Fraise est constitué de cinq piles de blocs qui représentent :
  • l’initialisation ;
  • la création des clones et leurs paramètres ;
  • l’interaction avec le sprite du joueur.

La première pile de blocs correspond à l’initialisation, avec notamment la mise à zéro de la variable score.

quand drapeau vert est cliqué

mettre nombre de fraises à 0 // la variable nombre de fraises sert, comme son nom l’indique, à comptabiliser les fraises cueillies par le joueur.

mettre la taille à 50% de la taille initiale // la taille des fraises est définie.


cacher // au lancement du programme aucune fraise n’est visible, le jeu n’ayant pas encore commencé.









La deuxième pile de blocs correspond à la phase de jeu et aux éléments pour cloner des fraises.

quand je reçois Jeu

montrer // une fraise est visible.

répéter indéfiniment // ce sprite est cloné indéfiniment avec les caractéristiques définies dans cette boucle de répétition.

aller à x : nombre aléatoire entre -230 et 230 y : nombre aléatoire entre -130 et 130 // les dimensions de la scène sont comprises entre -240 et 240 en x (horizontalement) et -140 et 140 en y (verticalement). J’ai volontairement spécifié des valeurs moindres pour éviter d’avoir une fraise qui apparaisse à moitié cachée. Les clones apparaissent aléatoirement sur la scène dans ce périmètre.  

attendre nombre aléatoire entre 1 et 3 secondes // les clones ne sont pas créés d’une manière régulière dans le temps

créer un clone de moi-même





Les piles de blocs trois et quatre gèrent les clones :
  • durée d’affichage ;
  • interaction avec le joueur.

quand je commence comme un clone

montrer // quand un clone est créé une nouvelle fraise est visible sur la scène.

attendre nombre aléatoire entre 2 et 5 secondes // le nouveau clone sera créé et visible pour une durée déterminée, mais aléatoire.

cacher // cacher.

supprimer ce clone

quand je commence comme un clone

répéter indéfiniment // cette boucle de répétition contient l’instruction qui permet de créer une inter action avec le joueur

si touche le joueur ? alors // si le clone de la fraise est touché par le joueur.

cacher // la fraise disparait de la scène pour signifier qu’elle a été cueillie.

ajouter 1 à nombre de fraises // chaque fois qu’une fraise est touchée par le joueur, la variable nombre de fraises est incrémentée de 1

supprimer ce clone





quand je reçois Fin // la fin de la partie est signifiée par la réception du message Fin.

cacher // le sprite disparait de la scène.

stop autres scripts dans sprite // l’exécution des autres programmes du sprite Fraise est stoppée. Les clones ne sont plus créés.




Au niveau de sa jouabilité, ce jeu est simple. Il s'agit d'un outil pour découvrir en s'amusant des éléments de programmation. 
Une fois maitrisés, vous allez pouvoir les utiliser pour des projets plus complexes et plus aboutis.

Et vous, qu'allez vous ramasser ? 




Commentaires

Posts les plus consultés de ce blog

Scratch - Dessiner dans un repère orthonormé

Apprendre à programmer avec Arduino - le chenillard

Fabriquer une main articulée