Scratch : déplacements, boucles et conditions

L'essentiel avant le contrôle

Contrôle demain et Scratch te semble encore flou ? Voici le strict nécessaire.

Ce qu'il faut déjà savoir :

• multiplier deux nombres (pour compter un déplacement) ;
• qu'un angle se mesure en degrés et qu'un tour complet vaut $360^\circ$ ;
• lire une liste de haut en bas, dans l'ordre.

L'essentiel en une phrase : un programme Scratch est une suite d'instructions (les blocs colorés) qu'un personnage, le lutin, exécute dans l'ordre, de haut en bas. Cette suite s'appelle un script, et il démarre quand on clique sur le drapeau vert.

Il y a trois familles de blocs à connaître :

• Déplacements : faire bouger le lutin sur la scène.
• Boucles : répéter des instructions sans les réécrire.
• Conditions : faire quelque chose seulement si quelque chose est vrai.

Les deux formules qui sauvent :

• déplacement total $=$ nombre de répétitions $\times$ pas par répétition $= n \times d$ ;
• un tour complet $= 360^\circ$.

Exemple traité : tracer un carré

Le grand classique du contrôle : « que dessine ce script ? ». On le fait en entier.

Le script :

Quand le drapeau vert est cliqué
répéter 4 fois
  — avancer de 100 pas
  — tourner de 90 degrés

On le suit pas à pas :

1. Le script démarre au clic sur le drapeau vert.

2. On voit une boucle « répéter 4 fois » : tout ce qui est emboîté dedans sera fait 4 fois.

3. Dedans : « avancer de 100 pas », puis « tourner de 90 degrés ».

4. Passage 1 : le lutin trace un côté de 100 pas, puis pivote de $90^\circ$.

5. Il refait exactement ça aux passages 2, 3 et 4 : quatre côtés et quatre virages.

6. Distance parcourue : $4 \times 100 = 400$ pas.

7. Rotation totale : $4 \times 90 = 360^\circ$, soit un tour complet — le lutin repart dans sa direction de départ, la figure est fermée.

Résultat : un carré de côté 100 pas.

Vocabulaire et déplacements

On reprend le vocabulaire au propre, une bonne fois.

• Lutin : le personnage qui agit sur la scène.
• Instruction : un bloc.
• Script : la suite de blocs, exécutée de haut en bas, qui démarre au drapeau vert.

La scène est repérée : son centre est le point $(0\,;\,0)$. Les blocs de déplacement (catégorie bleue) bougent et orientent le lutin :

• aller à x: a y: b — place le lutin au point $(a\,;\,b)$.
• avancer de n pas — déplace le lutin de $n$ pas dans sa direction.
• tourner de n degrés — fait pivoter le lutin de $n$ degrés, sans avancer.

Les boucles

Une boucle sert à répéter des instructions sans les recopier dix fois.

• répéter n fois { … } — exécute les blocs intérieurs exactement $n$ fois, puis passe à la suite.
• répéter indéfiniment { … } — exécute les blocs en boucle, sans jamais s'arrêter tout seul.

À retenir absolument : si le bloc « avancer de $d$ pas » est placé dans une boucle « répéter $n$ fois », alors le déplacement total vaut :

$n \times d$   (répétitions $\times$ pas par répétition).

Exemple éclair : « répéter 5 fois : avancer de 20 pas » donne $5 \times 20 = 100$ pas.

Les instructions conditionnelles

Une instruction conditionnelle n'exécute ses blocs intérieurs que si une condition est vraie.

• si (condition) alors { … } — si la condition est vraie, les blocs s'exécutent ; sinon, on saute directement à la suite.
• si (condition) alors { … } sinon { … } — deux chemins : la branche « alors » si c'est vrai, la branche « sinon » si c'est faux.

Une condition est une question à laquelle on répond par vrai ou faux, par exemple : « touche un bord ? », « appuie sur espace ? », « touche la couleur rouge ? ».

On refait le carré, ligne par ligne

On reprend le carré, mais cette fois je commente chaque ligne. Suis avec moi.

Le script :

Quand le drapeau vert est cliqué
répéter 4 fois
  — avancer de 100 pas
  — tourner de 90 degrés

Ligne par ligne :

• « Quand le drapeau vert est cliqué » → c'est le départ ; sans lui, rien ne se lance.

• « répéter 4 fois » → on va faire 4 tours du contenu. Compte : 4.

• « avancer de 100 pas » → un côté du carré.

• « tourner de 90 degrés » → le lutin prend son virage à angle droit.

• Ces deux lignes sont emboîtées dans la boucle → elles se répètent ensemble, 4 fois.

On totalise : côtés $= 4 \times 100 = 400$ pas ; virages $= 4 \times 90 = 360^\circ$ (un tour complet). C'est bien un carré de côté 100 pas.

Un triangle équilatéral

Deuxième script : presque le même, mais on change deux nombres. Regarde ce que ça donne.

Le script :

Quand le drapeau vert est cliqué
répéter 3 fois
  — avancer de 50 pas
  — tourner de 120 degrés

On le fait ensemble :

• « répéter 3 fois » → 3 côtés cette fois.

• « avancer de 50 pas » → chaque côté mesure 50 pas.

• « tourner de 120 degrés » → le virage est plus grand que pour le carré.

• Distance : $3 \times 50 = 150$ pas.

• Rotation : $3 \times 120 = 360^\circ$ → encore un tour complet, la figure se referme.

Résultat : un triangle équilatéral (3 côtés égaux) de côté 50 pas. Tu vois l'astuce : on garde la même structure « avancer / tourner » dans une boucle, on change juste le nombre de côtés et l'angle.

Une condition qui réagit

Troisième script : on ajoute enfin une condition. Objectif, un lutin qui rebondit.

Le script :

Quand le drapeau vert est cliqué
répéter indéfiniment
  — avancer de 10 pas
  — si (touche un bord ?) alors
    — tourner de 180 degrés

Décorticage :

• « répéter indéfiniment » → ça tourne en boucle, sans fin (jusqu'à ce qu'on arrête le programme).

• « avancer de 10 pas » → à chaque tour de boucle, un petit pas en avant.

• « si (touche un bord ?) alors tourner de 180 degrés » → seulement quand le lutin touche le bord, il fait demi-tour ($180^\circ$). Tant qu'il ne touche rien, cette ligne est sautée.

Résultat : le lutin avance, tape le bord, se retourne, repart… il rebondit. Sans la condition, il resterait bloqué contre le bord à pousser dans le vide.

Problème type : lire un script et conclure

Voici le type d'exercice qui tombe au contrôle : on te donne un script, tu dois conclure proprement.

Énoncé. Un lutin part du point $(0\,;\,0)$. On lance :

Quand le drapeau vert est cliqué
répéter 6 fois
  — avancer de 40 pas
  — tourner de 60 degrés

Questions : (a) quelle figure obtient-on ? (b) combien de pas au total ? (c) de combien de degrés le lutin tourne-t-il en tout ?

Résolution rédigée :

1. Départ au drapeau vert ; la boucle « répéter 6 fois » répète le contenu 6 fois → 6 côtés.

2. Les 6 côtés font tous 40 pas et les virages sont tous égaux à $60^\circ$ → la figure est régulière à 6 côtés : un hexagone régulier.

3. (b) Pas parcourus : $6 \times 40 = 240$ pas.

4. (c) Rotation totale : $6 \times 60 = 360^\circ$, un tour complet → le lutin revient dans sa direction de départ, la figure est bien fermée.

Réponse : le lutin trace un hexagone régulier de côté 40 pas ; il parcourt 240 pas et tourne de $360^\circ$ au total.

Problème type : une boucle avec condition

Deuxième type : une boucle qui contient une condition « si … alors … sinon ». Il faut suivre les deux chemins.

Énoncé. Que fait ce programme ?

Quand le drapeau vert est cliqué
répéter indéfiniment
  — si (touche la couleur rouge ?) alors
    — tourner de 90 degrés
  — sinon
    — avancer de 5 pas

Résolution :

1. « répéter indéfiniment » → la condition est testée en permanence.

2. À chaque tour, on pose la question : « touche la couleur rouge ? ».

3. Si vrai → branche « alors » : le lutin tourne de $90^\circ$.

4. Si faux → branche « sinon » : le lutin avance de 5 pas.

5. Un seul bloc s'exécute à chaque tour : « alors » ou « sinon », jamais les deux en même temps.

Réponse : le lutin avance tout droit et, dès qu'il rencontre du rouge, il pivote pour l'éviter au lieu d'avancer.

Ce que le correcteur attend, et les pièges

Pour rafler tous les points, voilà ce que le correcteur veut voir — et les pièges à éviter.

Ce qui rapporte les points :

• toujours écrire le calcul : $n \times d$ pour la distance, $n \times$ angle pour la rotation ;
• nommer la figure précisément : carré, triangle équilatéral, hexagone régulier… pas juste « une forme » ;
• vérifier que la rotation totale fait $360^\circ$ : c'est le signe que la figure est fermée.

Les pièges classiques :

• oublier « Quand le drapeau vert est cliqué » → le script ne démarre pas ;
• poser un bloc à côté de la boucle au lieu de l'emboîter dedans → il ne se répète pas ;
• confondre « répéter n fois » (qui s'arrête) et « répéter indéfiniment » (qui ne s'arrête jamais tout seul) ;
• se tromper d'angle : carré $90^\circ$, triangle équilatéral $120^\circ$, hexagone $60^\circ$ ;
• dans un « si … alors … sinon », croire que les deux branches se font : non, une seule à la fois.

Pourquoi 90, 120, 60 ? Le secret : 360 divisé par n

Petite question qui épate : pourquoi le carré demande $90^\circ$, le triangle $120^\circ$ et l'hexagone $60^\circ$ ? Ce n'est pas magique, ça se démontre.

L'idée. Pour dessiner une figure fermée à $n$ côtés et revenir orienté comme au départ, le lutin fait exactement un tour complet, soit $360^\circ$ au total.

Comme il tourne $n$ fois du même angle $a$, on a :

$n \times a = 360^\circ$,   donc   $a = 360^\circ \div n$.

On vérifie :

• carré : $n = 4$, donc $360 \div 4 = 90^\circ$ ;
• triangle équilatéral : $n = 3$, donc $360 \div 3 = 120^\circ$ ;
• hexagone : $n = 6$, donc $360 \div 6 = 60^\circ$.

Tout colle. Et maintenant tu peux prévoir un angle sans l'apprendre par cœur : pour un pentagone ($5$ côtés), l'angle sera $360 \div 5 = 72^\circ$.

Les liens et l'année prochaine

Où tout ça va te resservir — un aperçu, sans pression.

• Le repérage. Le point $(a\,;\,b)$ du bloc « aller à x: y: » est un premier contact avec le repérage dans le plan, que tu creuseras dans les prochaines années.
• Les angles. Tu manipules déjà des degrés — $90^\circ$, $120^\circ$, $360^\circ$ — exactement le vocabulaire des chapitres de géométrie sur les angles.
• Les boucles imbriquées. En glissant une boucle dans une autre, tu peux répéter un carré entier plusieurs fois en tournant un peu à chaque fois : tu obtiens une rosace (voir la figure). C'est la même idée « répéter », empilée.
• Les variables. Plus tard, tu remplaceras un nombre fixe (100 pas, 4 fois) par une valeur qui change toute seule : le programme devient réglable.

L'esprit à garder : programmer, c'est découper une tâche en petites instructions simples, exécutées dans l'ordre. Cette façon de penser te suivra dans tous tes projets Scratch des années suivantes.