Séquence Programmation avec Scratch

Plan de séquence
Objectif de la séquence : Comprendre les concepts et notions de base de la programmation en utilisant le logiciel
Scratch dans le but de programmer un petit “jeu vidéo”

Programmes
 Se repérer et se déplacer dans l’espace en utilisant ou en élaborant des représentations
o Divers modes de représentation de l’espace
o Vocabulaire permettant de définir des positions et des déplacements.

 S’approprier un environnement informatique de travail.

 Savoir coder ou décoder pour prévoir ou représenter des déplacements
 Programmer les déplacements d’un personnage à l’écran

Socle commun
 Domaine 1 - Les langages pour penser et communiquer :
Comprendre, s'exprimer en utilisant les langages mathématiques, scientifiques et informatiques
[L’élève] sait que des langages informatiques sont utilisés pour programmer des outils numériques et réaliser
des traitements automatiques de données. Il connaît les principes de base de l'algorithmique et de la conception
des programmes informatiques. Il les met en œuvre pour créer des applications simples.
 Domaine 2 - Les méthodes et outils pour apprendre
Coopération et réalisation de projets
L'élève travaille en équipe, partage des tâches, s'engage dans un dialogue constructif, accepte la contradiction
tout en défendant son point de vue, fait preuve de diplomatie, négocie et recherche un consensus
 Domaine 4 - Les systèmes naturels et les systèmes techniques
Démarches scientifiques
L'élève sait mener une démarche d'investigation. Pour cela, il décrit et questionne ses observations ; il prélève,
organise et traite l'information utile ; il formule des hypothèses, les teste et les éprouve ; il manipule, explore
plusieurs pistes, procède par essais et erreurs

Séance Durée Objectifs Matériel

1 55 min Découvrir l’environnement de programmation Scratch : les Pour la classe :

différentes zones de travail du logiciel, menus et fonctions  1 VPI/TNI
principales  1 PC avec le
logiciel Scratch
2 55 min Modifier la scène  Documents
Sauvegarder son travail annexes
Se familiariser avec le système de coordonnées  Affiche commune
Réaliser un premier programme
Pour chaque binôme :
3 1h Compléter le programme  1 PC avec le
Créer des boucles logiciel Scratch
Programmer des instructions conditionnelles  Capsules vidéo
 Fiche élève
4 50 min Compléter le programme en réinvestissant les notions de test, de
boucle et de variable abordées précédemment, et en
Pour chaque élève :
approfondissant la notion d’événement.
 Fiche bilan
5 30 min Finaliser le jeu

6 100 min Séances optionnelles : “Peaufiner son jeu”

 Fiche de préparation
Séquence - Programmation avec Scratch
Séance 1 : Découvrir l’environnement de programmation Scratch
Niveaux : CM1/CM2
Durée : 55 min.

Phase Durée Objectifs - Déroulement Matériel

Présentation objectifs et produit final

L’enseignant présente l’œuvre final (le jeu vidéo) que les élèves vont programmer dans cette séquence.  PC enseignant avec
Il s’agit d’un jeu qui va simuler l’exploration d’une planète à travers le déplacement d’un robot que l’on appellera Rover. logiciel Scratch
Pour survivre, le robot doit ramasser pour la base des ressources : de l’eau (sous la forme d’une vignette glace) et de la
 Vidéoprojecteur / VPI /
nourriture (sous la forme de buisson) en évitant les dangers naturels (tornades, lave, dune).
1 5’ TNI
 Fichier final Scratch du
Cette phase de découverte peut s’effectuer en classe entière, soit par démonstration par l’enseignant en lançant le produit
jeu
fin. Il peut être intéressant de ne présenter au départ que la “scène”, pour ensuite arriver à la présentation du l’ensemble
du logiciel qui va permettre de créer ce jeu.
Cette phase d’enrôlement est très importante car elle suscite une forte motivation chez les élèves. Conclure en expliquant
aux élèves que pour programmer un tel jeu, plusieurs séances seront nécessaires.

Découverte de l’interface
 PC (1 par binôme)
avec logiciel Scratch
2 10’ Phase de découverte de manière magistrale, l’enseignant présente l’interface et réalise une petite démonstration face aux
élèves, complétée par une fiche permettant aux élèves de retenir les points importants.
 Fiche élève (1 par
binôme)
Retour rapide de l’enseignant pour fixer les découvertes des élèves et formaliser les premiers apprentissages.
 Exploration libre du logiciel

3 10’
Pendant 10 minutes, les élèves explorent librement Scratch. Pour le moment, ils ne doivent pas chercher à modifier la scène  PC (1 par binôme)
ou le lutin (phase suivante) mais l’enseignant les encourage plutôt à s’intéresser à des instructions simples, à les manipuler avec logiciel Scratch
et à les tester pour observer ce qu’il se passe. Mettre l’accent notamment sur les catégories Mouvement (bleu foncé),
Apparence (violet), Événement (marron) et Contrôle (orange)

Mise en commun

Après la phase d’exploration, l’enseignant effectue un rapide retour collectif sur les essais des élèves (reprendre les 4
catégories de blocs-instruction) et propose de réaliser en commun les 3 premiers petits exercices suivants :
 PC enseignant avec
logiciel Scratch
4 10’  Exercice 1 : Faire avancer le chat de 10 pas (1 seule solution possible - avancer de 10 )  Vidéoprojecteur / VPI /
 Exercice 2 : Faire avancer le chat de 20 pas (2 solutions possibles : 2 blocs-instruction avancer de 10 ou la solution TNI
plus élégante 1 bloc-instruction avancer de 20 )
 Exercice 3 : Remettre le chat au centre de la scène (1 seule solution possible : aller à x:0 y:0 ).Il est indispensable que
tous les élèves voient cette instruction car ils seront vite confrontés au fait que leur lutin va sortir de la scène au
bout d’un certain nombre de manipulation.

Exercices

Les élèves réalisent les exercices 4,5,6 et 7 en autonomie par binôme :

 Exercice 4 : Faire avancer le chat de 20 pas et lui faire dire bonjour (2 solutions possibles : 2 blocs-instruction : avancer
de 20 ; dire bonjour pendant 2 secondes ou 3 blocs instruction : 2 blocs-instruction : avancer de 10 (X2) ; dire
bonjour pendant 2 secondes ). Attention : bien préciser que l’instruction “dire” bonjour correspond à l’apparition
d’une bulle de texte avec le mot “bonjour”.  PC (1 par binôme)
5 10’  Exercice 5 : Répéter 3 fois : faire avancer le chat de 20 pas et lui faire dire bonjour (mêmes solutions en ajoutant le  Fiche élève
bloc-instruction boucle répéter 3 fois ). Préciser si besoin que la boucle enserre les instructions que l’on souhaite
voir se répéter.
 Exercice 6 : Répéter indéfiniment : faire avancer le chat de 20 pas et lui faire dire bonjour (mêmes solutions en ajoutant
le bloc-instruction boucle répéter indéfiniment ). Sur le même principe que l’exercice précédent mais avec un autre
type de boucle.
 Exercice 7 : même chose quand on clique sur le drapeau vert (rajouter le bloc-instruction quand le drapeau vert
pressé de la catégorie événement). Lors de la correction, montrer qu’il est encore mieux de faire revenir le chat au
centre de la scène avant avec le bloc-instruction aller à x:0 y.
 Correction / Trace écrite

Correction et mise en commun des exercices réalisés lors de la phase précédente. L’enseignant prend le temps de vérifier
les procédures des élèves.
 Fiche bilan : 1/élève
6 10’  Affiche fiche bilan
Enfin la classe synthétise collectivement ce qui a été appris aujourd’hui et notamment les instructions découvertes : avancer  Crayons de couleur
de 10, aller à (0,0), dire “bonjour” pendant 2 secondes, répéter 10 fois, répéter indéfiniment, quand le drapeau vert est pressé.
Pour trace écrite, les élèves peuvent colorier sur la fiche bilan les instructions découvertes lors de cette séance. Cette fiche
bilan peut faire l’objet aussi d’un affichage de classe une fois agrandie. Cette fiche bilan sera complétée lors des différentes
séances, et permettra aux élèves de voir l’évolution de leurs connaissances.

Observations
 Séance 1 – Fiche élève

1. Découverte de l’interface de Scratch

Après avoir regardé la capsule vidéo, complète les cadres sous l’image en notant le nom des différentes
zones du logiciel :

A : ____________________________________________________

C’est là que se déroule le « jeu » ou plus généralement le programme dans Scratch.

B : ____________________________________________________

C’est ici que se trouvent les personnages ou les objets qui seront manipulés dans le programme.

C : ____________________________________________________

Cette zone correspond à l’image derrière le lutin. Par défaut, c’est un fond blanc.

D : ____________________________________________________

C’est ici que l’on trouve l’ensemble des instructions (ou blocs) que l’on va utiliser dans le programme ;
ces instructions sont regroupées par couleurs.

E : ____________________________________________________

Espace dans lequel on écrit le programme.

 2. Exercices

Pour chacun des exercices ci-dessous, trouve les bonnes instructions dans la zone « script » et écris le
programme correspondant dans Scratch pour réaliser la tâche demandée.

Une fois que tu as trouvé le bon programme, écris dans les cadres les blocs que tu as utilisés :

 Exercice 1 : Faire avancer le chat de 20 pas et lui faire dire bonjour

 Exercice 2 : Répéter 3 fois : faire avancer le chat de 20 pas et lui faire dire bonjour

 Exercice 3 : Répéter indéfiniment : faire avancer le chat de 20 pas et lui faire dire bonjour

 Exercice 4 : même chose quand on clique sur le drapeau vert

 Fiche bilan - Scratch : les blocs-instruction

Je colorie, au crayon de couleur, les blocs que je connais dans le logiciel Scratch.
 Fiche de préparation
Séquence - Programmation avec Scratch
Séance 2 : Réalisation d’un premier programme
Niveaux : CM1/CM2
Durée : 65 min.

Phase Durée Objectifs - Déroulement Matériel

Présentation objectifs de la séance  PC enseignant avec

logiciel Scratch
1 5’ L’enseignant présente les objectifs de la séance : les élèves vont apprendre aujourd’hui à personnaliser la scène dans Scratch  Vidéoprojecteur /
(lutin et arrière-plan), enregistrer leur travail pour le réutiliser plus tard, se familiariser avec le système de coordonnées et VPI / TNI
réaliser un premier programme leur permettant de piloter le rover avec les flèches du clavier.  Capsule vidéo 1

Expérimentation : personnalisation de la scène et sauvegarde

1 – Changer le lutin
L’enseignant explique qu’il est possible de de supprimer le lutin « chat » et d’en
créer un autre à la place, plus en phase avec le projet de mission spatiale : un
rover (expliquez si nécessaire). Pour supprimer le lutin « chat », il faut cliquer
(bouton droit) sur son icone, dans la zone des lutins (voir séance 1), et choisir
« supprimer ».  PC (1 par binôme)
2 15’ avec logiciel Scratch
Pour information, il existe 4 façons différentes de créer un nouveau lutin, accessibles depuis la barre d’outils « nouveau lutin »
en bas à droite de la scène :
 Choisir un lutin dans la bibliothèque (Scratch est livré avec une centaine de lutins prédéfinis dans la bibliothèque)
 Dessiner un nouveau lutin (outil intégré de dessin permettant aux élèves de créer « à la main » leur propre rover)
 Importer un lutin depuis un fichier
 Nouveau lutin depuis une webcam (pratique pour des projets personnels -on peut ajouter son propre visage comme
nouveau lutin- mais n’a pas d’intérêt dans le cadre de ce projet-ci).
L’option en gras sera utilisée dans cette séance, l’objectif n’étant pas ici d’apprendre à dessiner.
 Exercice élève : changer le lutin en important le fichier rover_carré.png à partir du répertoire où seront déposés les fichiers
liés à la séquence (disque dur réseau de l’école, disque dur de l’ordinateur). Cet exercice présuppose que les élèves sachent
comment naviguer dans l’explorateur de fichier de Windows pour accéder à un fichier.

2 – Changer l’arrière-plan
De la même façon que précédemment, il est possible de changer l’arrière-plan de la scène, soit à partir d’une image issue de
la bibliothèque, soit à partir d’un fichier fourni par l’utilisateur, soit encore en le dessinant soi-même.
Exercice élève : changer l’arrière-plan en important le fichier sol_martien.png à partir du répertoire où seront déposés les
fichiers liés à la séquence

3 – Sauvegarder son travail

L’enregistrement se fait en cliquant sur le menu « fichier » puis l’option « sauvegarder ». Il faut ensuite se déplacer dans le
répertoire dédié au projet et la classe (un raccourci depuis le bureau est, encore une fois, fortement conseillé), puis choisir un
nom de fichier.

Ce nom de fichier peut, par exemple, comporter les prénoms des élèves, de façon à ce qu’ils puissent facilement retrouver
leur propre programme plus tard. L’import se fera soit en double-cliquant directement sur le fichier sauvegardé (ce qui lance
le logiciel Scratch), soit en lançant Scratch puis en cliquant sur le menu « fichier » et l’option « ouvrir ».

Mise en commun

La classe revient sur ce qu’elle a appris à faire dans Scratch : importer un lutin ou un arrière-plan ; sauvegarder et reprendre
son travail.

L’enseignant peut montrer à nouveau la démonstration du jeu « final », afin de faire expliciter par les élèves les tâches qui
restent à faire. Par exemple :
 PC enseignant avec
 Piloter le rover à l’aide des flèches (objet de la suite de la séance)
logiciel Scratch
3 5’  Importer d’autres lutins pour gérer les ressources et les obstacles
 Faire en sorte qu’on gagne un point quand on récolte une ressource, et qu’on perde une vie quand on touche un
 Vidéoprojecteur /
obstacle VPI / TNI
 Faire en sorte qu’une ressource disparaisse lorsqu’elle est ramassée, et réapparaisse ailleurs sur la scène (à un endroit
aléatoire)
 Faire en sorte que la tornade se promène au hasard sur la scène
 Faire en sorte que le jeu prenne fin lorsqu’on n’a plus de vie (avec « Game over » qui apparait, et tout le reste qui
disparait).
 Expérimentation

Les élèves savent déjà comment faire avancer le rover vers la droite… il suffit de lui dire d’avancer, puisque, par défaut, il est
déjà orienté vers la droite. Le faire avancer vers la gauche est une tâche un peu plus difficile, car les élèves doivent d’abord
demander au rover de s’orienter vers la gauche, avant d’avancer.

1 – Faire avancer le rover à gauche (puis dans n’importe quelle direction)

Ils travaillent en autonomie et tâtonnent, l’enseignant passant régulièrement dans les groupes
pour s’assurer que personne n’est bloqué. Il peut les guider en les incitant à chercher une
instruction « s’orienter ». Dans cette séquence, on privilégiera la commande « s’orienter à… »
pour réaliser cette tâche. Lorsque l’on clique sur le nombre présent dans l’instruction (en général,
ce nombre par défaut est « 90 »), une bulle d’aide nous explique que l’angle 0° désigne le haut
de l’écran ; 90° désigne la droite, etc.
Les élèves doivent maintenant être capables de faire avancer le rover dans n’importe quelle direction (droite, gauche, haut et
bas), en reprenant exactement la même méthode que précédemment.
 PC (1 par binôme)
2 – Piloter le rover à l’aide des flèches avec logiciel Scratch
 PC enseignant avec
4 25’
Les élèves doivent maintenant faire en sorte que le rover se déplace quand ils pressent les flèches du clavier. Ils cherchent en logiciel Scratch
autonomie comment faire. Certains se rappellent la commande « quand drapeau vert pressé » vue lors de la toute première  Vidéoprojecteur /
séance Scratch. C’est un événement qui permet de déclencher une action. Ici aussi, on cherche un événement : l’action se VPI / TNI
déclenche quand une touche du clavier est pressée.

La commande « quand (espace) est pressé » nous intéresse, sauf qu’il faut changer « espace » par
une des flèches (flèche droite pour aller à droite). Cela se fait de la même manière que
précédemment :

Finalement, la zone du programme du rover comporte 4

sous-programmes, chacun décrivant le déplacement dans
une direction particulière. Voici à quoi peut ressembler le
programme :
 3 – Rebondir sur les bords

Les élèves cherchent comment faire en sorte que le rover rebondisse sur les bords. Par
exemple, si on le dirige vers la droite et qu’il atteint l’extrémité droite de l’écran, le rover
doit rebondir afin de ne pas sortir de l’écran.

Cela se fait très simplement en ajoutant l’instruction « rebondir si le bord est atteint » en bas
de chacun des sous-programmes faits précédemment.

4 – Initialiser la position du rover

L’enseignant rappelle que, lorsqu’on lance le programme (drapeau vert), le rover doit se situer au
centre de l’écran. Les élèves reprennent sans difficulté les instructions qu’ils avaient vues lors de la
première séance Scratch.

Expérimentation

La tâche précédente a mis en évidence les coordonnées X et Y du rover, à travers l’instruction « aller à (X = 0, Y = 0) ». Les
étapes suivantes (ressources, pièges…) nécessiteront de manipuler ces coordonnées ; il importe donc de comprendre
comment cela fonctionne.

L’enseignant demande aux élèves de visualiser les coordonnées X et Y qui s’affiche en bas
à droite de la scène. Ceux-ci remarquent que les coordonnées affichées changent en
 PC (1 par binôme)
fonction de la position de la souris.
avec logiciel Scratch
 PC enseignant avec
 Que valent X et Y quand la souris est au centre de la scène ? (Réponse : X = 0, Y = 0)
5 15’ logiciel Scratch
 Et quand la souris est tout à droite ? (Réponse : X = 240, Y peut prendre n’importe quelle valeur selon la position de la
 Vidéoprojecteur /
souris)
VPI / TNI
 Et quand la souris est tout à gauche ? (X = -240)
 Fiche élève
 Et quand la souris est tout en haut ? (Y = 180) ou tout en bas ? (Y = -180)
La classe conclut collectivement que X indique la position selon l’axe horizontal (axe imaginaire, non tracé) et Y indique la
position selon l’axe vertical (lui aussi imaginaire).

Les élèves peuvent remarquer que, dans la catégorie « mouvement » de la palette d’instructions, de nombreuses instructions
font intervenir les variables X et Y. Ici, il ne s’agit plus de la position de la souris, mais de celle du lutin sélectionné. Le rover
possède son propre jeu de variables X et Y.
 L’enseignant peut distribuer la fiche annexe élève et leur proposer des petits exercices :
 Place le lutin sur la scène, aux coordonnées X = -100, Y = 100
 Que se passe-t-il si on ajoute 50 à X ? Où est désormais le lutin ?
 Que se passe-t-il si maintenant on met Y à 0 ? Où est le lutin ?

Conclusion / Trace écrite

Correction et mise en commun des notions abordées lors de cette séance.

À la fin de cette séance, il importe de faire le point sur les nouvelles commandes Scratch que les élèves ont appris à utiliser :  Fiche bilan
6 10’  S’orienter à (90)  Affiche fiche bilan
 Quand (espace) est pressé  Crayons de couleur
 Quand (drapeau vert) est pressé
 Aller à (X =…, Y = …)
Les élèves colorient ces commandes sur la fiche bilan qu’ils avaient déjà utilisée.

Observations
 Séance 2 – Fiche élève
Les coordonnées X et Y dans Scratch

-----------------------------------------------------------------------------------------------------------------------------------------------

Les coordonnées X et Y dans Scratch

 Fiche de préparation
Séquence - Programmation avec Scratch
Séance 3 : Compléter le programme (boucles & instructions conditionnelles)
Niveaux : CM1/CM2
Durée : 60 min.

Phase Durée Objectifs - Déroulement Matériel

Présentation objectifs de la séance

L’enseignant présente les objectifs de la séance : les élèves complètent leur programme en ajoutant des ressources à aller
chercher (nouveaux lutins) et en créant une variable pour leur score (ce score augmente lorsqu’on récolte des ressources). Ils
apprennent à programmer des instructions conditionnelles (si… alors) et à utiliser des capteurs.

 Il s’agit de l’étape centrale du projet car, pour gérer les ressources, les élèves vont devoir découvrir et mobiliser de  PC enseignant
nombreuses notions nouvelles : tests, variables, capteurs, opérateurs. avec logiciel
 À partir de maintenant, il est illusoire de chercher à ce que tous les élèves avancent au même rythme (sinon, les groupes Scratch
1 5’
ayant le plus de facilité vont très vite s’ennuyer et se dissiper). Le découpage en étapes et tâches permet de faciliter la  Vidéoprojecteur /
gestion de classe: chacun, où qu’il en soit, a quelque chose à faire. VPI / TNI
 Il est préférable de former des binômes relativement homogènes plutôt que des binômes associant un élève en difficulté
et un élève plus avancé dans la programmation.

L’enseignant explique que l’équipage doit s’approvisionner en diverses ressources pour survivre, notamment en eau (sous
forme de glace, sur cette planète) et en nourriture (sous forme de végétaux). Le rover va devoir les récupérer, et un « score
» permettra de compter le nombre de ressources récoltées.
 Expérimentation

1 – Importer une ressource (la glace) sous la forme d’un nouveau lutin

Les élèves reprennent leur programme enregistré à la séance

précédente et importent un nouveau lutin : la glace (image
disponible dans le sous-répertoire « Lutins » du dossier mis à
disposition, comme précédemment).

L’enseignant veille à ce qu’ils pensent à initialiser manuellement

la position de cette ressource, comme ils l’avaient fait à la séance
précédente pour le rover. Ils peuvent positionner la glace
n’importe où sur l’écran, pourvu que les lutins (glace et rover) ne
se chevauchent pas.

Cela donne, par exemple :

On remarque ici que chaque lutin possède sa propre zone de programme (on passe du programme du rover à celui de la glace en  PC (1 par binôme)
cliquant sur le lutin voulu). Il y a potentiellement autant de programmes que de lutins : tous ces programmes s’exécutent en avec logiciel
2 15’
parallèle. Scratch

2 – Faire dire « bravo » à la ressource lorsqu’elle est touchée par le rover

Les binômes doivent modifier le programme de la glace pour que celle-ci dise « bravo » lorsqu’elle est touchée par le rover.
L’enseignant les laisse tâtonner, puis passe dans les groupes pour les guider en cas de blocage.
Cette tâche suppose :

 De savoir faire dire « bravo » au lutin (tous les élèves savent le faire à ce stade)

 De savoir déclencher une instruction uniquement lorsqu’une certaine condition est remplie.
Cela se fait via la catégorie « contrôle », dans lequel on trouve l’instruction « si… alors… »

 De savoir détecter quand un lutin en touche un autre. Cela se fait via la catégorie « capteurs »
de la palette d’instructions (instruction « … touché ? »). Une fois qu’on l’a sélectionné, un clic
sur la petite flèche permet de faire défiler les lutins déjà créés. Ici, on est dans le programme de
la glace et on veut tester si ce lutin touche le rover, on clique donc sur « rover ».
Le programme du lutin « glace » devient alors :

Malheureusement, lorsque l’on lance le programme et que l’on dirige le rover vers la glace, cela ne fonctionne pas. Pourquoi?
La classe peut discuter collectivement de ce que fait ce programme, pas à pas :

 La glace est placée dans la position que l’on a choisie

 Un test est effectué : si la glace touche le rover, alors elle dit « bravo »
 Puis… plus rien.

On remarque, en lisant ce programme, que le test n’est effectué qu’une seule fois, au lancement du programme (juste après
qu’on a initialisé la position de la glace). Or, à ce moment-là, les 2 lutins ne se touchent pas. Donc, le message « bravo » ne
s’affiche pas. C’est normal.

Pour que le programme fonctionne correctement, il faut que le test « si la glace touche le rover » soit effectué en permanence,
de façon à pouvoir déclencher l’action voulue dès que la condition sera remplie. Pour cela, il suffit de placer ce test dans une
boucle « répéter indéfiniment », que l’on trouve dans la catégorie « contrôle ». Le programme de la glace devient :
3 – Faire disparaître la ressource quand elle est touchée

Cette tâche très facile nécessite simplement de remplacer, dans le programme de la glace, l’instruction « dire Bravo » par une
instruction faisant disparaître ce lutin. Il s’agit de l’instruction « cacher » que l’on trouve dans la catégorie « apparence ».
Attention, une fois qu’on exécute le programme, la ressource est désormais toujours cachée (car on ne lui a jamais dit de se
montrer à nouveau !). Il faut donc ajouter l’instruction « montrer » juste après l’instruction « quand drapeau vert pressé ».
Le programme de la glace devient donc :

4 – Créer une variable « score »

L’enseignant rappelle aux élèves qu’ils doivent créer un score et l’augmenter à chaque fois
que la ressource est touchée. Les élèves peuvent explorer les différentes catégories
d’instructions : la réponse se trouve dans la catégorie orange intitulée « Données », via la
commande « créer une variable ».

Ici, il s’agit de compter un score. Cette variable pourra sans doute être manipulée par
plusieurs lutins (les différentes ressources…) : on doit donc la rendre accessible à tous les
lutins.
L’enseignant fait remarquer aux élèves qu’ils ont déjà manipulé des variables dans les
séances précédentes (l’abscisse X et l’ordonnée Y, qui donnent la position d’un lutin à
l’écran). Ces variables étaient déjà disponibles et les élèves ont pu les manipuler (faire des
tests, leur affecter des valeurs…) sans avoir besoin de les créer.
5 – Augmenter le score lorsqu’on récolte une ressource
Les élèves décident de la façon dont le score doit être augmenté (par exemple, on l’augmente de 1 à chaque fois que le rover
touche une ressource). Dans un second temps, les élèves cherchent l’instruction permettant d’augmenter le score de 1 :

Il suffit de la placer dans le programme de la glace, à l’intérieur du test « si rover touché », juste en-dessous ou au-dessus de
l’instruction « cacher ».

6 – Initialiser le score à zéro

Les élèves testent à plusieurs reprises ce qui se passe quand le rover touche la glace. Le
programme semble bien fonctionner (la glace est présente, le rover la touche, elle disparait et le
score est augmenté de 1). Cependant, si on arrête le programme et qu’on le relance, le score
n’est pas remis à zéro.

Pour initialiser la variable à zéro, il suffit d’ajouter l’instruction « mettre score à 0 » en début de
programme.

 A priori, cette initialisation peut être faite dans le programme de n’importe quel lutin : l’important étant qu’elle soit faite
une fois, et une seule. Mais le score est une variable qui sera sans doute manipulée par d’autres lutins (la végétation,
quand on l’aura importée). Il n’y a pas de raison de privilégier la glace par rapport à la végétation. Pour cette raison, nous
conseillons de le faire dans le programme du rover (qui est notre programme « principal »), juste en dessous de
l’initialisation de sa position.
 On peut aussi décider que notre programme principal est celui de l’arrière-plan plutôt que celui d’un lutin. Dans ce cas,
on mettra toutes les initialisations dans l’arrière-plan, sous une commande « quand drapeau vert pressé ».
7 – Faire réapparaître une ressource à une position aléatoire

Le jeu peut être rendu plus amusant si les ressources réapparaissent, après avoir été récoltées, mais pas toujours au même
endroit. Une position aléatoire est préférable. Pour cela, il faut, utiliser l’instruction « aller à… », que les élèves connaissent déjà,
ainsi qu’une nouvelle instruction disponible dans la catégorie verte « opérateurs ». Cette nouvelle commande s’appelle « nombre
aléatoire entre … et … ».

Puisque, dans l’écran de Scratch, l’abscisse X varie entre -240 à +240 et l’ordonnée Y varie entre -180 à +180, le positionnement
du lutin n’importe où sur la scène est donc donné par la commande :

Il n’est plus utile de cacher le lutin, puisqu’il est simplement déplacé. Le programme, pour la glace, devient donc :

On peut également faire en sorte que la position initiale de la ressource soit elle-même aléatoire plutôt que fixée (à X=126 et
Y=87 dans notre exemple).

8 – Importer une nouvelle ressource (la végétation) et refaire le même travail que pour la glace

Les élèves doivent maintenant introduire une seconde ressource (la végétation) et refaire tout le travail effectué avec la glace :
 Importer le lutin « végétation »
 Tester indéfiniment si ce lutin touche le rover et, si c’est le cas :
 - augmenter le score de 1
- faire réapparaître le lutin ailleurs sur la carte (position aléatoire).

Cette tâche est très utile aux élèves car elle leur permet de reprendre et consolider les différentes notions abordées
précédemment. Cette partie peut d’ailleurs faire l’objet d’un temps de travail sur une autre séance en fonction du temps
disponible.

Conclusion

Mise en commun des notions abordées lors de cette séance.

À la fin de cette séance, il importe de faire le point sur les nouvelles commandes Scratch que les élèves ont appris à utiliser :  Fiche bilan
 Si… alors…
 Affiche fiche bilan
3 10’  Capteurs « …touché »
 Crayons de
 Données : « créer une variable »
couleur
 Données : « mettre … à … »
 Données : « ajouter à … … »
 Nombre aléatoire entre … et …

Les élèves colorient ces commandes sur la fiche bilan qu’ils avaient déjà utilisée.

Observations
 Fiche de préparation
Séquence - Programmation avec Scratch
Séance 4 : Eviter des obstacles, gérer son nombre de vies
Niveaux : CM1/CM2
Durée : 50 min.

Phase Durée Objectifs - Déroulement Matériel

Présentation objectifs  PC enseignant

avec logiciel
1 5’ Pour pimenter le jeu simulant la mission spatiale, l’enseignant explique qu’il va falloir introduire des obstacles (un lac Scratch
de lave, une dune de sable), et une nouvelle variable : le nombre de « vies ». Le rover démarre le jeu avec 3 vies et perd  Vidéoprojecteur
une vie, en revenant à la base, chaque fois qu’il touche un obstacle. Le jeu s’arrête lorsque le nombre de vies atteint 0. / VPI / TNI

Recherche

1 - Ajout de nouveaux lutins

Se référant à ce qu’ils ont appris lors des précédentes séances, les élèves importent sans difficulté les 3 nouveaux lutins
(la base, la dune et la lave) et les initialisent en fixant leur position en un endroit précis de l’écran. Ils peuvent décider,
 PC (1 par
par exemple, de placer la base au centre, ce qui nécessite de décaler la position initiale du rover (puisqu’on l’avait placé binôme) avec
2 40’ au centre). logiciel Scratch
Cela n’est pas indispensable, mais on peut vouloir préciser la « profondeur » des différents lutins (rover, base, lave,
dune, végétation, glace). Décider quel lutin sera au premier plan se fait via l’instruction « envoyer au premier plan »
disponible dans la catégorie « apparence » des instructions.
2 - Création et initialisation d’une variable « nombre de vies »

De même, ils créent facilement une nouvelle variable « vies » qu’ils initialisent à la valeur 3 (au même endroit que
l’initialisation du score, par exemple dans le programme du rover). Le programme du rover contient donc, désormais
(en plus des sous-programmes permettant de le diriger) :

3 - Perdre une vie quand le rover touche la lave

À la séance précédente, toucher une ressource permettait d’augmenter de 1 la valeur de la variable « score ». De même,
ici, toucher la lave ou la dune doit faire diminuer de 1 la valeur de la variable « vie ». Nous conseillons de résoudre
d’abord la tâche pour un des obstacles (la lave), puis de recommencer pour l’autre (la dune).

Comment soustraire, dans Scratch ?

Les élèves cherchent comment contrôler / programmer cette diminution. Il n’y a pas de commande « soustraire », mais
seulement « ajouter ». Au besoin, discuter collectivement du fait qu’il faut ajouter la valeur -1 pour soustraire 1.

Pour la lave, le programme est :

 Programme provisoire pour la lave

Ce programme a cependant un défaut : lorsque le rover entre en contact avec un obstacle, il le touche pendant un
certain temps (quelques dixièmes de secondes, quelques secondes si on ne bouge plus) : pendant tout ce temps, la
variable « vie » décroit. Au bout de quelques secondes, on se retrouve avec des valeurs négatives très grandes (-
4000…). La seule façon d’éviter cela est de rompre immédiatement le contact entre le rover et l’obstacle.
Puisque l’obstacle est fixe, c’est donc le rover qui doit se déplacer. Or, cela ne peut pas être fait dans le programme de
la lave ou de la dune : il faut être dans le programme du rover pour commander la position du rover.

Comment déplacer le rover ?

Il y a (au moins) deux solutions possibles à ce problème :

 Solution 1

Supprimer le programme que l’on a fait pour la lave (sauf l’initialisation de sa position) et en faire un similaire dans
le programme du rover. Dans le programme du rover, on ajoute une commande disant, par exemple, de rentrer à
la base.
Notons, en passant, que pour rentrer à la base, on peut soit dire au rover d’aller en (X=0, Y=0), soit dire au rover
d’aller à la position du lutin « base ». Cette dernière solution est meilleure car elle marchera même si on décide de
placer la base ailleurs.
 Programme de la lave

Programme du rover

 Solution 2 (plus élégante… et plus pratique pour la suite)

Une solution plus élaborée consiste à garder le programme que l’on a fait pour la lave, en y ajoutant une nouvelle
instruction qui va envoyer un message aux autres programmes (celui du rover en particulier). Ce message, dans le
programme du rover, déclenchera une action (retourner à la base). Tout comme les noms de variables, les intitulés
des messages doivent être explicites. Ici, notre message est par exemple « obstacle touché ».

Programme du rover

Programme de la lave
 Le programme de la lave envoie un message aux autres programmes (celui du rover en particulier).
Dans le programme du rover, la réception du message est un événement qui déclenche une action (aller à la base).
Les commandes permettant d’envoyer un message ou de déclencher une action lorsqu’un message est reçu se situent
dans la catégorie « événements ».

4 - Refaire la même chose avec la dune

Maintenant que les élèves ont réussi à gérer un des obstacles (la lave), ils doivent refaire la même chose pour l’autre (la
dune). Ce petit exercice permet de mieux s’approprier ce qui a été fait précédemment, en particulier l’envoi et la
réception de message.

 Fiche bilan :
1/élève
Correction / Trace écrite
 Affiche fiche
6 5’
bilan
Les élèves mettent à jour la liste des instructions Scratch qu’ils connaissent.
 Crayons de
couleur

Observations
 Fiche de préparation
Séquence - Programmation avec Scratch
Séance 5 : Mettre fin au jeu : « game over »
Niveaux : CM1/CM2
Durée : 35 min.

Phase Durée Objectifs - Déroulement Matériel

Présentation objectifs
 PC enseignant
avec logiciel
Les élèves doivent maintenant faire en sorte que le jeu s’arrête lorsque le nombre de vies restantes vaut zéro.
1 5’ Scratch
Cela suppose plusieurs choses :
 Vidéoprojecteur
 Faire apparaître « game over »
/ VPI / TNI
 Faire en sorte qu’on ne puisse plus jouer (sauf en relançant le programme)

Recherche

1 - Faire apparaître « game over » quand le nombre de vies vaut 0

 PC (1 par
Faire apparaître « game over » peut se faire de plusieurs façons. La plus simple consiste à importer un lutin binôme) avec
2 30’ dont l’apparence est « game over » (lutin fourni). Ce lutin doit apparaître lorsque le nombre de vies vaut zéro. logiciel Scratch

Cela se fait très facilement, à l’aide de l’instruction « montrer » dans la catégorie « apparence ». Note : il ne
faut pas oublier, au lancement du programme, de cacher le lutin « game over » !
Le programme de ce lutin « game over » est :
2 - Arrêter le jeu quand apparaît « game over »
En l’état actuel, on peut continuer à jouer lorsque « game over » s’affiche, ce qui n’est pas satisfaisant. Pour
mettre fin au jeu, il y a plusieurs stratégies possibles :

Méthode 1
Déclencher l’arrêt de tous les programmes quand le nombre de vies vaut zéro. Cela se fait via la commande
« Stop tout » de la catégorie « contrôle ».

Programme du rover

En théorie, cela suffit à stopper le jeu. Malheureusement, en pratique, un bug de Scratch (présent à l’heure
où nous écrivons ces lignes) fait que, malgré l’instruction « stop tout », certains programmes s’arrêtent et
d’autres pas (il est encore possible de bouger le rover). Pour cette raison (et aussi car elle est visuellement
plus satisfaisante), on préfère la seconde méthode, ci-après.
Méthode 2
Faire en sorte que tous les autres lutins disparaissent lorsque le nombre de vies vaut zéro. Ainsi, le seul lutin
encore à l’écran est « game over », et le jeu est bel et bien terminé. Cette méthode suppose qu’un des
programmes (par exemple celui du rover) envoie un message. Ce message s’intitule tout simplement « game
over ».

Tous les lutins (à l’exception du lutin « game over », bien sûr), se cachent lorsqu’ils reçoivent ce message.
Puisqu’on leur demande de se cacher à la fin… il faut penser à leur demander de se montrer au lancement
du programme !

Programme du lutin « game over »

Programme du rover.
La dernière instruction du programme du rover (se cacher quand on reçoit « game over ») est également
présente dans les programmes des autres lutins (sauf le lutin « game over » qui, lui, se montre à ce moment-
là).

Notes pédagogiques
 On peut faire une variante simplifiée (et moins élégante) de la méthode 2 si l’on ne souhaite pas utiliser
l’envoi ou la réception de messages. Cette variante consiste demander à chaque lutin de se cacher
lorsque le nombre de vies atteint zéro.
 La pause d’1 seconde permet de s’assurer que la variable « vies » a eu le temps, dans le programme
du rover, d’être initialisée à 3. Sinon, comme elle vaut 0 au lancement du programme, les lutins se
cachent immédiatement.

 Introduire une pause, même d’une fraction de seconde, peut permettre de résoudre des bugs assez
subtils liés à des problèmes de synchronisation entre les différents programmes. Scratch donne
l’illusion qu’il exécute tous les programmes en parallèle, mais en réalité il les exécute les uns après les
autres (très rapidement… d’où l’illusion de la simultanéité). Introduire une pause ou envoyer/recevoir
un message est une manière de forcer l’exécution d’un programme avant un autre.

 Fiche bilan :
1/élève
Correction / Trace écrite
 Affiche fiche
6 5’
bilan
Les élèves mettent à jour la liste des instructions Scratch qu’ils connaissent.
 Crayons de
couleur

Observations
 Fiche de préparation
Séquence - Programmation avec Scratch
Séance 6 : Peaufiner le jeu
Niveaux : CM1/CM2
Durée : 100 min (à découper en plusieurs séances)

Phase Durée Objectifs - Déroulement Matériel

Présentation objectifs

Les élèves auront sans doute remarqué que leur jeu est jouable mais qu’il manque d’intérêt car il ne présente pas de
difficulté majeure. Si l’on fait attention aux obstacles, le jeu peut ne jamais s’arrêter.
La classe réfléchit collectivement à une façon de mettre fin au jeu et d’introduire de la difficulté. Plusieurs options sont
possibles :

 option 1 : ajouter un compte à rebours. Quand le temps imparti est écoulé, le jeu s’arrête. La performance du
joueur s’apprécie au nombre de « vies » qu’il lui reste et au nombre de ressources qu’il a récoltées (son « score  PC enseignant
»). avec logiciel
1 10’  option 2 : ajouter un nouvel élément qui va rendre le jeu de plus en plus difficile, et y mettre fin à un moment Scratch
donné. Par exemple, on peut introduire un nouveau piège (une tornade). La tornade se déplace de plus en plus  Vidéoprojecteur
vite, et on ne peut pas prévoir sa direction. À un moment ou un autre, on ne pourra plus l’éviter et le jeu prendra / VPI / TNI
alors fin.

Notes pédagogiques :
 Il est très probable que les élèves imaginent d’autres façons de faire. Nous conseillons à l’enseignant d’engager
un débat dans la classe afin de choisir la ou les options qui seront suivies (rien n’impose que tous les groupes
choisissent la même option !).
 L’enseignant veillera cependant à ce que les élèves aient une idée de la façon dont ils vont procéder. Si une option
semble séduisante mais irréaliste, mieux vaut sans doute opter pour une autre qui soit faisable !
 Nous décrivons ci-dessous ces 2 options citées, ainsi que quelques autres qui ne sont pas forcément une manière de
pimenter le jeu, mais de le rendre plus présentable ou d’éviter quelques bugs.
Les tâches ci-dessous sont de difficulté très variables, et toutes indépendantes les unes des autres.
Notre conseil : faire au moins la tâche 1 ou la tâche 2 pour que le jeu présente un intérêt.

Recherche

1 - Limiter la durée du jeu

Limiter la durée du jeu est une façon très simple de le rendre plus intéressant. Il suffit de créer une variable « durée du
jeu », de lui donner une valeur initiale et de la diminuer au fur et à mesure, en introduisant une temporisation afin de
pouvoir contrôler la vitesse du processus.

Le programme s’arrête (message « game over ») soit lorsque le compte à rebours est arrivé à 0, soit quand le nombre
de vies est arrivé à 0.

Le programme du rover doit être modifié pour comporter :

 PC (1 par
binôme) avec
2 80’
logiciel Scratch

Dans cet exemple, on initialise « durée du jeu » à 60 et on lui retire 1 toutes les secondes.
On peut bien sûr changer ces valeurs pour obtenir une longévité plus ou moins grande.
2 - Ajouter une tornade qui se déplace aléatoirement
La création du lutin à partir d’une image et à l’initialisation de sa position sont désormais connues des élèves. On peut,
par exemple, faire partir la tornade du coin inférieur gauche (X = -230 et Y = -170).
Il faut ensuite trouver une façon de la déplacer vers un endroit aléatoire. Si l’on souhaite que ce mouvement soit
instantané, il suffit de changer les valeurs de X et de Y… mais il serait préférable de voir la tornade de déplacer. La
commande adéquate est « glisser en … secondes à x=… et y=… », disponible dans la catégorie « mouvement ».
Puisque l’on souhaite que la tornade se dirige vers un endroit quelconque de la carte, il suffit d’écrire l’instruction
suivante :

Les élèves, en cliquant plusieurs fois sur cette instruction, confirment que la tornade se déplace dans une direction
aléatoire à chaque fois. Ce déplacement se fait toujours en 1 seconde… donc si le point d’arrivée est proche, le
déplacement est très lent, et s’il est éloigné, plus rapide.

Reste maintenant à connecter cette instruction au reste du programme de la tornade (on a changé le temps en « 2
secondes » de façon à ralentir un peu la tornade).

Il ne faut pas oublier l’essentiel : si le rover touche la tornade, la partie prend fin. On ajoute donc l’instruction suivante
au programme de la tornade :
3 - Faire grossir la tornade
Pour corser encore un peu le jeu, on peut faire en sorte que la tornade grossisse au fur et à mesure que des ressources
sont récoltées. À ce stade du projet, une telle tâche ne présente pas de difficulté majeure.

 Dans les programmes des ressources (glace et végétation), faire envoyer un message à chaque fois qu’une
ressource est récoltée.

 Dans le programme de la tornade, augmenter la taille de celle-ci à chaque fois que le message « ressource
récoltée » est reçu. On utilise pour cela la commande « ajouter… à la taille » disponible dans la catégorie «
apparence ».

 Puisque, désormais, on modifie la taille de la tornade dans le programme, alors il faut penser à initialiser cette
taille au lancement du programme, grâce à la commande « mettre à 100% de la taille initiale » de la catégorie «
apparence ».
4 - Faire accélérer la tornade au fur et à mesure
Cette tâche, très difficile, est plutôt réservée à des élèves de collège (cycle 4). Néanmoins, il est possible que certains
élèves de cycle 3 très en avance puissent avoir besoin d’un challenge. Voilà de quoi les occuper !
Il s’agit de faire en sorte que la tornade accélère à chaque fois que l’on a récolté une ressource (glace ou végétation).
Pour faire accélérer la tornade, il faut créer une variable « vitesse_tornade » (initialisée à 1, dans le même programme
que pour les autres variables) et l’augmenter, par exemple de 10% à chaque événement (astuce : augmenter de 10% la
vitesse revient à la multiplier par 1,1).

Le programme de la tornade est donc modifié :

Attention, il faut tenir compte de la valeur de « vitesse_tornade » dans le programme qui commande son mouvement
(instruction « glisser »). Cela se fait par exemple en incluant « vitesse_tornade » dans le calcul du temps de glissement,
comme ceci :

Ainsi, plus « vitesse_tornade » est grande, plus le temps mis pour effectuer un mouvement donné est court : la tornade
est de plus en plus rapide, c’est bien ce que l’on cherche.
5 - Simuler un monde torique (joindre les côtés de la scène)
Le jeu serait plus amusant si le rover n’était pas bloqué par les bords de la scène. Il faudrait faire en sorte que, lorsqu’il
atteint le bord droit de la scène, il continue sa course et réapparaisse sur le bord gauche, et inversement. Même chose
avec les bords haut et bas.
Il laisse les élèves tâtonner et les guide en cas de difficulté, tout d’abord en explicitant leur algorithme : si l’abscisse X
du rover dépasse 240 (extrémité droite), alors elle doit passer à -240 (extrémité gauche). Ensuite, il peut montrer les
différents blocs nécessaires à la construction du programme : une boucle « répéter indéfiniment », une structure de
contrôle « si … alors », un opérateur « supérieur à », la valeur de la variable X (bloc bleu « abscisse X »), et l’instruction
permettant de changer cette valeur (bloc bleu « donner la valeur … à X »). Les blocs s’emboitent de la façon suivante :

Note pédagogique
Il est possible, selon la forme des lutins, qu’il soit nécessaire d’introduire une petite marge (au lieu de prendre 240
comme valeur d’extrémité de l’écran, prendre 235).
Une fois que chacun a compris comment programmer le passage du bord droit au bord gauche, il est facile de
programmer le passage du bord gauche au bord droit puis, verticalement (variable Y), du bord haut au bord bas, et du
bord bas au bord haut.
Finalement, le sous-programme du rover permettant de simuler un monde torique est :
Notes pédagogiques
 La capture d’écran ci-dessus montre qu’il est possible d’ajouter des commentaires à un programme. C’est une
très bonne habitude à prendre, de manière à rendre le programme plus clair pour soi, et surtout pour les autres
qui vont le lire !
 À ce stade, il devient nécessaire de supprimer l’instruction « rebondir si le bord est atteint » dans les sous-
programmes permettant de piloter le rover à l’aide des flèches.
6 - Eviter que les ressources et les pièges ne se superposent

Cette tâche cible les élèves de cycle 4 ou les élèves de cycle 3 qui seraient très en avance sur le reste de la classe.
Lorsque les ressources (glace, végétation) sont récoltées, elles réapparaissent aléatoirement sur la scène. Il est
parfaitement possible qu’une ressource réapparaisse à l’endroit où un piège (dune ou lave) se trouve déjà, ce qu’il faut
éviter car on ne peut pas avoir 2 objectifs contradictoires : récolter la ressource et éviter l’obstacle.

Comment faire en sorte que ce cas de figure ne puisse pas se produire ? Il faut tirer au hasard une nouvelle position tant
que la ressource touche un piège. Mais, comme initialement la ressource ne touche pas un piège, la boucle ne va pas
s’exécuter. L’astuce consiste alors à introduire une étape préalable, pour forcer la boucle à s’exécuter une première fois.
L’algorithme devient :

 1/ Placer la ressource n’importe où par tirage aléatoire de ses coordonnées (ou bien, si on préfère, la placer sur
un piège)
 2/ Puis, effectuer la boucle suivante : tant que la ressource n’est pas à un emplacement libre de tout piège, lui
donner une nouvelle position aléatoire.

Les élèves devront être guidés, soit en leur donnant l’astuce ci-dessus (après les avoir laissé chercher un peu), soit en
leur fournissant le programme final et en leur demandant de l’analyser pour comprendre ce qu’il fait, et pourquoi.
Le programme final de la glace ou de la végétation devient donc :
 Correction / Trace écrite

Le jeu vidéo est désormais suffisamment intéressant pour permettre aux élèves d’y jouer en se lançant des défis.
Les élèves mettent à jour la liste des instructions Scratch qu’ils connaissent.
 Fiche bilan :
L’enseignant anime un bilan collectif permettant aux élèves d’exprimer ce qu’ils ont appris au cours de ce projet, les difficultés
1/élève
qu’ils ont eues, les désirs éventuels que cela a fait naître (certains ont sans doute déjà commencé à faire d’autres
 Affiche fiche
6 10’ programmes Scratch à la maison), etc.
bilan
 Crayons de
Notes pédagogiques :
couleur
 Cette activité de programmation a probablement été nouvelle pour la plupart des élèves. Afin qu’ils n’oublient pas comment
utiliser Scratch, mais aussi afin de libérer leur créativité, nous conseillons de leur proposer, plus tard dans l’année, de créer
un projet personnel. Il peut s’agir d’un jeu vidéo (projet assez complexe comme on l’a vu), ou plus simplement d’une carte
animée (pour Halloween, Noël…), ou encore des questionnaires interactifs… les possibilités sont immenses.