L’enseignant, après avoir fait le point sur l’avancement des différents groupes, rappelle que le jeu nécessite d’avoir plusieurs astéroïdes, et non pas un seul. Il demande aux élèves comment faire. Certains peuvent proposer de créer autant de lutins que d’astéroïdes possibles. C’est une solution, mais elle est peu élégante :

•  D’une part, cela peut devenir très fastidieux si le nombre d’astéroïdes devient grand (on ne va pas créer 50 lutins identiques !)
•  D’autre part, cela oblige à dupliquer le même programme de nombreuses fois. Si l’on souhaite modifier ces programmes (pour corriger un bug ou ajouter une fonctionnalité), il faudra le faire partout, ce qui risque d’être pénible et sera assurément source d’erreurs.

L’enseignant explique que Scratch possède une fonctionnalité qui peut être très utile dans ce cas : on peut « cloner » les lutins. Un lutin peut exister en un nombre de clones aussi grand qu’on le souhaite, chacun étant piloté par le même programme.
Pour une meilleure lisibilité, on peut découper la tâche 4 en différentes « sous-tâches » (que l’on va nommer 4.1, 4.2, etc.).

Tâche 4.1 : créer plusieurs clones de l’astéroïde (20 minutes)

La création d’un clone se fait via la commande  disponible dans l’onglet « contrôle ». Cette instruction peut être exécutée autant de fois que nécessaire (dans une boucle par exemple), ce qui peut donc donner lieu à un nombre de clones aussi grand que souhaité.
Outre la création de clones, on souhaite que chacun se comporte comme l’astéroïde unique programmée à la séance précédente : position initiale aléatoire, déplacement vers le bas.
Pour déclencher toute cette séquence d’instructions dès qu’un clone est créé, il faut utiliser l’événement  (également situé dans l’onglet « contrôle »).
Une façon possible de programmer la création de 3 astéroïdes, avec le comportement souhaité pour chacun est par exemple :

Notes pédagogiques :

•  On remarque, sur la capture d’écran ci-dessus, que notre  programme est désormais composé de plusieurs « branches » [d4][d5](qu’on appellera « sous-programmes »). Chaque sous-programme est déclenché par un événement particulier (ici, le clic sur le drapeau vert ou la création d’un clone).
•  Avec certains élèves en difficulté, on peut procéder comme lors de la Séance 3 : leur donner un programme qui contient déjà toutes les instructions, dans le désordre. C’est l’objet du programme Arcade_V02

Tâche 4.2 : faire disparaître les clones quand ils arrivent en bas de l’écran (10 minutes)

Cette tâche ne présente en général pas de difficulté. Si certains élèves ont du mal à manipuler les abscisses et ordonnées, ne pas hésiter à faire une activité débranchée. Des questions simples comme À quel mouvement correspond l’instruction « ajouter 10 à x », « ajouter -10 à y » ? ou Quelles sont les coordonnées d’un lutin lorsqu’il est sur les bords de l’écran ? les aideront à se familiariser avec ces notions.
On peut imaginer 2 méthodes différentes pour la réaliser la tâche souhaitée (faire disparaître les clones quand ils arrivent en bas de l’écran) :

•  A chaque étape de la boucle « répéter indéfiniment » régissant la descente de l’astéroïde, on peut insérer un test : SI (y < -180) ALORS (supprimer ce clone)
•  On peut aussi remplacer cette boucle indéfiniment par une boucle « répéter jusqu’à (y < -170) » et mettre l’instruction « supprimer ce clone » après la boucle.

Ces 2 possibilités sont illustrées ici :

ou

Note scientifique :
 Plutôt que de supprimer le clone, on pourrait choisir de simplement le cacher  (instruction « masquer »). Mais pourquoi encombrer la mémoire de l’ordinateur par des objets qui ne servent plus à rien ?

Tâche 4.3 : créer un nombre aléatoire de clones (10 minutes)

Aucune difficulté non plus pour cette tâche : il suffit de remplacer le nombre « 3 » par un nombre aléatoire (compris par exemple entre 1 et 10) dans la boucle du sous-programme déclenchant la création des clones.
Ce sous-programme devient :

Tâche 4.4 : faire en sorte que ces clones tombent avec des temps d’attente aléatoires (10 minutes)

La tâche 4.3 crée un nombre aléatoire de clones, mais une seule fois : dès que ces clones disparaissent en bas de l’écran, il ne se passe plus rien. Si l’on souhaite que des clones apparaissent en permanence, de façon aléatoire, il faut modifier le programme précédent :

•  Remplacer la boucle « répéter (un nombre aléatoire de fois) » par une boucle « répéter indéfiniment »
•  Introduire une pause d’une durée aléatoire à l’intérieur de la boucle. Pour cela, une petite astuce est nécessaire. Imaginons que l’on souhaite une pause aléatoire durant entre 0 et 1 seconde.
  o L’instruction   semble répondre à notre besoin. En réalité, le résultat obtenu est une attente aléatoire dont la durée vaut soit 0, soit 1 seconde (mais rien entre ces 2 valeurs).
  o Pour faire une attente aléatoire entre 0 et 1 seconde, on peut par exemple tirer un nombre entre 1 et 10, et diviser le résultat par 10 (ainsi, on tirera au hasard des valeurs parmi {0 ; 0,1 ; 0,2 ; 0,3 … 0,9 ; 1}.
  

Le sous-programme devient donc, par exemple :

Conclusion

L’enseignant guide les élèves vers la formulation d’une conclusion :

•  En Scratch, il est possible de dupliquer un lutin en autant de clones que souhaité. Chacun est « piloté » à l’aide du même programme.