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 !
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 ?
Une fois maitrisés, vous allez pouvoir les utiliser pour des projets plus complexes et plus aboutis.
Et vous, qu'allez vous ramasser ?
Commentaires
Enregistrer un commentaire