Tracé de figures sur Scratch : la checklist avant de coder

Tracé de figures sur Scratch: la checklist avant de coder

Elles apparaissent plutôt avant la première ligne de programme: l’extension de dessin n’est pas activée, le lutin conserve son ancienne position, l’orientation de départ n’est pas maîtrisée ou l’élève confond l’angle intérieur avec l’angle de rotation.

Le résultat est immédiat: une figure décalée, un polygone qui ne se referme pas, un triangle qui tourne dans la mauvaise direction ou un tracé différent à chaque lancement. Pourtant, ces problèmes se préviennent avec une préparation courte et toujours identique. Ta checklist doit donc agir comme un contrôle de départ: installer l’outil, nettoyer la scène, fixer la position, fixer la direction, puis seulement programmer la boucle.

Sur Scratch, un tracé réussi commence avant le bloc « avancer »: tu dois d’abord imposer un état de départ parfaitement connu.

L’activation indispensable de l’extension Stylo

Scratch 3.0 ne charge plus automatiquement l’extension « Stylo » dans un nouveau projet. Si tu ne l’ajoutes pas, les blocs permettant de dessiner n’apparaîtront pas dans l’interface. Tu peux alors construire un algorithme correct sur le papier sans pouvoir produire la moindre ligne dans la scène.

Pour ajouter l’extension, repère le bouton d’ajout situé en bas à gauche de l’interface de Scratch. Clique dessus, puis sélectionne « Stylo ». Une nouvelle catégorie de blocs apparaît avec les commandes nécessaires au tracé, notamment celles qui permettent:

• d’effacer les dessins présents sur la scène;
• de mettre le stylo en position d’écriture ou de relevé;
• d’effectuer le tracé avec le déplacement du lutin;
• selon les réglages utilisés, de modifier l’aspect du trait.

Cette étape semble élémentaire, mais elle fait partie de la préparation du projet Scratch au collège. Dans une copie ou une capture d’écran, l’absence de l’extension peut rendre ton programme difficile à lire: les blocs de mouvement sont présents, mais l’intention de dessin n’est pas complète.

Vérifie l’outil avant de construire la figure

Ne commence pas par programmer un carré ou un polygone à plusieurs côtés. Fais d’abord un contrôle simple. Après avoir chargé « Stylo », place temporairement les blocs suivants:

• « stylo en position d’écriture »;
• « avancer de 50 pas »;
• « relever le stylo ».

Lance le script et observe la scène. Une ligne doit apparaître pendant le déplacement du lutin. Ce test ne sert pas à résoudre l’exercice: il sert à vérifier que l’outil répond correctement.

Si aucune ligne n’est visible, ne modifie pas encore l’angle ou le nombre de répétitions. Le problème se situe probablement dans l’activation de l’extension, dans la position du lutin ou dans l’ordre des blocs. Un bon raisonnement de programmation consiste à isoler les causes: tu testes d’abord le stylo, puis le déplacement, puis la répétition.

Le stylo doit être écrit au bon moment

Le bloc « stylo en position d’écriture » doit être placé avant le premier déplacement qui doit laisser une trace. Si tu le places après « avancer de 50 pas », le premier segment ne sera pas dessiné. La figure sera alors incomplète dès son premier côté, même si toute la suite du script est correcte.

À l’inverse, le bloc « relever le stylo » est utile lorsque tu veux déplacer le lutin sans dessiner, par exemple pour changer de figure ou replacer le curseur. Cette distinction est fondamentale:

• déplacement avec stylo baissé: le lutin trace;
• déplacement avec stylo relevé: le lutin se positionne sans laisser de ligne.

Dans un programme comportant plusieurs figures, pense donc à relever le stylo avant un déplacement de repositionnement. Sinon, tu risques de créer un segment parasite entre deux tracés.

La procédure de réinitialisation pour un tracé reproductible

Un script de dessin doit produire le même résultat à chaque lancement. Si la scène garde les traits précédents ou si le lutin démarre à l’endroit où le dernier programme l’a laissé, tu ne peux plus vérifier correctement ta figure.

La séquence de réinitialisation constitue le point de départ de ton algorithme. Elle doit inclure quatre actions:

1. effacer tous les tracés présents sur la scène;

2. placer le lutin aux coordonnées x: 0 y: 0;

3. imposer une orientation de départ de 90°;

4. mettre le stylo en position d’écriture.

Dans Scratch, cette suite peut être placée juste après le bloc de déclenchement, par exemple lorsque le drapeau vert est cliqué. L’ordre est lisible et logique: tu nettoies, tu positionnes, tu orientes, puis tu autorises le dessin.

Pourquoi effacer la scène ne suffit pas

Le bloc « effacer tout » supprime les lignes visibles, mais il ne replace pas le lutin. Celui-ci conserve sa position et son orientation à la fin du précédent lancement. Si ton script commence uniquement par l’effacement, le deuxième tracé peut démarrer à un endroit différent du premier.

Cette erreur est fréquente dans les activités de programmation au collège, car le premier essai semble fonctionner. L’élève relance ensuite le programme, observe une figure décalée et pense que la boucle est fausse. En réalité, le dessin précédent a été supprimé, mais l’état du lutin n’a pas été réinitialisé.

Pour obtenir un tracé reproductible, il faut donc distinguer deux éléments:

• l’état de la scène: les lignes déjà dessinées;
• l’état du lutin: sa position, son orientation et l’état du stylo.

Les deux doivent être remis à zéro avant l’exécution.

La séquence de départ à retenir

Tu peux utiliser cette suite comme modèle pour presque toutes les figures géométriques programmées dans Scratch:

Ce tableau n’est pas une formule obligatoire pour toutes les activités, mais il te donne un point de départ fiable. Si l’exercice demande une autre position ou une autre direction, tu modifies ces valeurs après avoir compris leur fonction.

Vérifie visuellement le point de départ

Le centre de la scène correspond aux coordonnées x: 0 et y: 0. Pour une première figure, ce choix est pratique: tu peux observer les côtés qui partent vers la droite, la gauche, le haut ou le bas sans perdre immédiatement le dessin hors de la zone visible.

Avant de lancer la boucle, observe la flèche du lutin. Elle doit pointer dans la direction prévue. Si elle regarde vers le haut alors que tu as construit ton raisonnement avec un premier déplacement horizontal, la figure ne sera pas nécessairement fausse, mais elle ne sera pas orientée comme prévu.

Cette vérification visuelle prend quelques secondes et évite une longue recherche d’erreur. Sur Scratch, la position et l’orientation sont des données algorithmiques, mais elles se contrôlent aussi avec les yeux.

Le piège des angles: distinguer l’angle intérieur de la rotation

C’est le point qui rapporte souvent les points de méthode lorsqu’il est correctement justifié, et qui provoque le plus d’erreurs dans les tracés de polygones. Le lutin ne reçoit pas l’angle intérieur de la figure dans le bloc « tourner de... degrés ». Il reçoit l’angle extérieur, c’est-à-dire l’angle par lequel il change de direction après avoir tracé un côté.

Pour un polygone régulier à n côtés, la rotation à programmer est:

360 / n

Cette formule donne l’angle extérieur nécessaire pour faire un tour complet autour de la figure.

Le cas du triangle équilatéral

Un triangle équilatéral possède trois côtés et trois angles intérieurs de 60°. Il serait donc incorrect de demander au lutin de tourner de 60° après chaque côté. Le tracé ne formerait pas le triangle attendu.

Le lutin doit tourner de:

360 / 3 = 120°

On peut aussi retrouver cette valeur en calculant le supplément de l’angle intérieur:

180° - 60° = 120°

Dans le script, le bloc de rotation doit donc utiliser 120°. Le lutin avance, tourne de 120°, avance à nouveau, puis répète cette séquence trois fois. La somme des rotations vaut 360°, ce qui permet au parcours de revenir dans la direction initiale et de fermer la figure.

Le carré: l’exemple qui confirme la règle

Pour un carré, n = 4. La rotation extérieure vaut:

360 / 4 = 90°

L’angle intérieur du carré est lui aussi de 90°, ce qui peut cacher la règle parce que les deux valeurs coïncident dans ce cas particulier. C’est pour cela que certains élèves réussissent le carré puis se trompent sur le triangle: ils ont mémorisé 90° sans comprendre ce que représente la rotation.

Le carré est donc un bon exercice de contrôle, mais pas un exemple suffisant pour comprendre la différence entre les deux angles. Compare-le avec le triangle:

Les valeurs du tableau montrent le piège: l’angle intérieur augmente lorsque le nombre de côtés augmente, tandis que la rotation extérieure diminue. Pour le pentagone, par exemple, tu ne programmes pas 108°, mais 72°, car 360 / 5 = 72.

La règle de brouillon qui évite la confusion

Avant de poser les blocs, écris toujours deux lignes distinctes:

• angle intérieur de la figure: …;
• angle de rotation dans Scratch: 360 / n = ….

Ne mélange pas ces deux informations dans la même annotation. Si tu écris uniquement « angle = 60° » pour un triangle, tu risques de reporter cette valeur dans le bloc « tourner », alors qu’elle décrit l’intérieur de la figure.

Pour une activité de tracé de figures géométriques sur Scratch, cette justification est aussi utile dans la rédaction. Ton correcteur cherchera à lire la raison du choix de l’angle, pas seulement la valeur finale. Une phrase comme « le lutin tourne de 120° car l’angle extérieur d’un triangle régulier vaut 360 / 3 » montre que tu maîtrises l’algorithme.

Le lutin ne tourne pas selon ce qu’il voit à l’intérieur de la figure; il tourne selon le changement de direction nécessaire pour suivre son contour.

Vérifie la fermeture de la figure

Une figure régulière doit revenir au point de départ après le bon nombre de répétitions. Si le triangle ne se ferme pas, plusieurs causes sont possibles:

• le nombre de répétitions n’est pas égal au nombre de côtés;
• l’angle de rotation est incorrect;
• la longueur n’est pas la même à chaque répétition;
• le lutin n’a pas été réorienté avant le lancement;
• le stylo n’était pas baissé au début du tracé.

Observe d’abord la forme générale. Une erreur d’angle produit souvent une ouverture régulière ou une figure qui tourne progressivement autour d’un point. Une erreur de longueur crée plutôt des côtés de tailles différentes. Cette lecture visuelle permet de cibler la correction au lieu de modifier tous les blocs au hasard.

Construire l’algorithme de dessin sans répéter inutilement les blocs

Le tracé d’un polygone régulier repose sur une même paire d’actions répétées:

1. avancer d’une longueur donnée;

2. tourner de l’angle extérieur.

Ces deux actions doivent être placées dans une boucle. Pour un carré, la répétition se fait quatre fois; pour un triangle, trois fois; pour un hexagone, six fois.

L’intérêt de la boucle n’est pas seulement de raccourcir le programme. Elle rend visible la structure mathématique de la figure: chaque côté est construit de la même manière, et la rotation est identique à chaque sommet.

Le raisonnement à écrire au brouillon

Avant de chercher les blocs, transforme la consigne en données:

• nombre de côtés;
• longueur d’un côté;
• angle de rotation;
• point de départ;
• orientation initiale.

Tu obtiens alors une structure simple:

• initialiser la scène;
• répéter n fois;
• avancer de la longueur choisie;
• tourner de 360 / n.

Cette organisation sépare les décisions géométriques des commandes Scratch. Si la figure est fausse, tu peux vérifier chaque donnée l’une après l’autre.

Les variables deviennent utiles pour généraliser

Pour un seul carré, des nombres écrits directement dans les blocs peuvent suffire. Mais dès que tu veux dessiner plusieurs polygones ou faire varier la figure, les variables rendent ton programme plus lisible.

Tu peux créer, par exemple:

• nombre de côtés;
• longueur du côté;
• angle de rotation.

Le principe est alors de calculer l’angle à partir du nombre de côtés. Si la variable nombre de côtés contient n, l’angle de rotation est 360 / nombre de côtés.

Cette méthode correspond à une véritable initiation à la pensée informatique: tu ne programmes plus uniquement une figure particulière, tu construis un algorithme capable de s’adapter. Pour un triangle, la variable vaut 3; pour un carré, 4; pour un pentagone, 5. La structure reste la même.

Attention cependant à ne pas ajouter des variables sans nécessité. Une variable doit porter une information utile au programme. Si tu crées plusieurs données mais que tu ne les utilises pas dans les blocs, tu compliques la lecture sans gagner de points.

Contrôle rapide de la boucle

Avant d’exécuter le script, pose-toi trois questions:

• La boucle se répète-t-elle autant de fois qu’il y a de côtés?
• Le déplacement est-il placé avant la rotation?
• La rotation utilise-t-elle 360 / n et non l’angle intérieur?

L’ordre « avancer puis tourner » est particulièrement important pour comprendre le dessin. Le lutin trace un côté, arrive au sommet, puis change de direction pour tracer le suivant. Si tu tournes avant le premier déplacement, tu obtiendras peut-être une figure correcte mais orientée autrement. Dans un exercice évalué, cette différence peut compter si une position de départ ou une direction précise est demandée.

Le réglage du centre de rotation du lutin

Un lutin n’est pas seulement une flèche visible à l’écran. Son costume possède un centre de rotation. Pour un lutin ordinaire, ce centre peut être peu gênant. Pour un lutin en forme de crayon, il devient déterminant.

Si la pointe du crayon n’est pas alignée avec le centre de la zone d’édition du costume, la ligne tracée ne correspondra pas à l’extrémité visible du crayon. Tu observeras alors un décalage entre le lutin et le trait. Le programme peut être parfaitement logique, mais le dessin semblera imprécis.

Aligner la pointe du crayon

Si tu utilises un lutin « Pencil » ou un costume en forme de crayon, ouvre l’onglet « Costumes ». Vérifie la position de la pointe par rapport au centre de la zone d’édition. La pointe doit être alignée avec ce centre de rotation.

L’objectif est simple: lorsque le lutin avance, le point qui dessine doit être celui que tu regardes. Sans cet alignement, tu risques de corriger les coordonnées ou la longueur des côtés alors que le véritable problème vient du costume.

Cette vérification est particulièrement utile pour les constructions où le lutin doit repartir exactement d’un sommet ou suivre un contour précis. Plus la figure est petite, plus un décalage visuel peut devenir gênant.

Distinguer l’erreur de costume de l’erreur d’algorithme

Pour savoir si le problème vient du programme ou du lutin, fais un test avec une ligne courte:

1. place le lutin au centre;

2. oriente-le vers la droite;

3. baisse le stylo;

4. avance d’une distance réduite;

5. observe la position de la pointe par rapport au trait.

Si le trait démarre à côté de la pointe, retourne dans « Costumes » avant de modifier le script. Si le trait est correctement aligné mais que le polygone se déforme, vérifie alors la longueur, l’angle ou la boucle.

Cette démarche te fait gagner des points de méthode parce qu’elle repose sur une observation précise. Tu ne déclares pas simplement que le programme ne fonctionne pas: tu identifies la nature de l’écart.

La logique des coordonnées et de l’orientation angulaire

Scratch utilise un repère avec des coordonnées horizontales et verticales. La position x: 0 y: 0 correspond au centre de la scène. Les valeurs de x déplacent le lutin vers la droite ou vers la gauche; les valeurs de y le déplacent vers le haut ou vers le bas.

L’orientation angulaire de Scratch possède toutefois une particularité à mémoriser:

• 0° correspond à la direction du haut;
• 90° correspond à la droite;
• 180° correspond au bas;
• -90°, ou 270°, correspond à la gauche.

Cette convention n’est pas celle que tu utilises toujours spontanément en géométrie. Ne suppose donc pas que 0° signifie automatiquement « vers la droite ». Dans Scratch, l’orientation standard vers la droite est 90°.

Pourquoi choisir 90° au départ

Utiliser 90° comme orientation initiale dirige le lutin vers la droite. C’est un choix pratique pour un premier tracé: le côté initial se construit horizontalement, et tu peux observer plus facilement le déplacement de la figure depuis le centre.

Ce n’est pas la seule orientation possible. Tu peux commencer vers le haut ou vers la gauche si la consigne l’impose. Ce qui compte, c’est de fixer l’orientation explicitement au début du script avec « s’orienter à... ».

Si tu ne le fais pas, le résultat dépend de l’état précédent du lutin. Une figure peut alors être correcte dans sa forme mais différente d’une exécution à l’autre. Or un algorithme doit être reproductible.

Observer les coordonnées pendant l’exécution

Les blocs de position permettent aussi de contrôler le parcours. Si le lutin quitte rapidement la scène, la longueur du côté est peut-être trop grande ou le point de départ mal choisi. Si le tracé est coupé, le lutin a peut-être atteint une limite visible avant de terminer la figure.

Pour une première construction, commence avec une longueur raisonnable, puis augmente-la après avoir vérifié la logique. Le but n’est pas de remplir toute la scène dès le premier essai, mais de rendre chaque étape observable.

Tu peux également déplacer temporairement le lutin avec le stylo relevé afin de tester une autre zone de la scène. N’oublie pas de réinitialiser ensuite la position et l’orientation dans le script définitif.

Une checklist complète avant de lancer le programme

Avant de cliquer sur le drapeau vert, passe en revue les éléments suivants. Cette liste est courte, mais chacun de ses points correspond à une erreur classique dans les activités Scratch au collège.

1. L’extension « Stylo » est-elle chargée?

Si les blocs de dessin ne sont pas présents, ajoute l’extension depuis le bouton situé en bas à gauche.

2. La scène est-elle nettoyée au début du script?

Place « effacer tout » avant le premier tracé pour éviter de confondre l’ancien dessin avec le nouveau.

3. Le lutin est-il placé au point prévu?

Pour un départ central, utilise x: 0 y: 0. Si la consigne donne une autre position, reporte-la exactement.

4. L’orientation initiale est-elle imposée?

Utilise « s’orienter à 90 » pour commencer vers la droite, ou une autre valeur si la figure doit démarrer dans une direction précise.

5. Le stylo est-il baissé avant le premier côté?

Le premier déplacement à dessiner doit suivre le bloc « stylo en position d’écriture ».

6. Le nombre de répétitions correspond-il au nombre de côtés?

Un triangle se trace avec trois répétitions, un carré avec quatre, et ainsi de suite.

7. La rotation correspond-elle à l’angle extérieur?

Calcule 360 / n. Ne reporte pas directement l’angle intérieur dans le bloc « tourner ».

8. La longueur est-elle identique à chaque déplacement?

Un polygone régulier demande des côtés de même longueur.

9. Le costume est-il correctement centré?

Avec un crayon, aligne la pointe avec le centre de rotation dans l’onglet « Costumes ».

10. La figure se ferme-t-elle visuellement?

Observe le dernier côté et le point de départ. Une petite ouverture signale souvent une erreur d’angle, de répétition ou de position.

Cette checklist n’a pas pour objectif de remplacer le raisonnement. Elle le sécurise. Tu dois toujours pouvoir expliquer pourquoi chaque bloc est présent et quelle information mathématique il traduit.

Les erreurs qui coûtent du temps et des points

Certaines erreurs reviennent dans presque tous les tracés de figures sur Scratch. Les reconnaître permet de corriger rapidement.

Programmer l’angle intérieur

C’est l’erreur la plus connue. Pour un triangle équilatéral, l’élève voit 60° dans la figure et écrit tourner de 60°. Le lutin ne suit alors pas le contour attendu.

La correction consiste à calculer l’angle extérieur avec 360 / n. Dans ta rédaction, écris la formule avant la valeur numérique. Le calcul justifie le bloc et montre que tu ne l’as pas choisi au hasard.

Oublier la réinitialisation

Un script qui fonctionne une seule fois n’est pas encore fiable. Si tu dois cliquer sur le drapeau vert après avoir déplacé manuellement le lutin ou après une première exécution, le programme doit reconstruire la figure de la même manière.

Place donc l’effacement, la position et l’orientation dans le script principal, pas dans une manipulation manuelle préalable.

Déplacer le lutin avec le stylo baissé

Lorsque tu veux commencer une nouvelle figure ailleurs, un déplacement effectué stylo baissé crée une ligne indésirable. Le correcteur peut croire que ton algorithme relie deux figures alors que tu souhaitais seulement repositionner le lutin.

Utilise « relever le stylo », déplace le lutin, puis baisse à nouveau le stylo juste avant le nouveau tracé.

Modifier plusieurs paramètres à la fois

Si la figure ne se ferme pas, ne change pas simultanément la longueur, l’angle et le nombre de répétitions. Tu ne sauras plus quel changement a résolu le problème.

Procède par contrôle visuel:

• forme globale incorrecte: vérifie l’angle;
• nombre de côtés incorrect: vérifie la répétition;
• figure trop grande ou trop petite: vérifie la longueur;
• figure décalée: vérifie la position;
• trait décalé par rapport au crayon: vérifie le centre du costume.

Cette méthode transforme le débogage en observation organisée. Elle est plus efficace que les essais successifs sans hypothèse.

Le détail de rédaction qui rapporte le dernier point

Dans un exercice évalué, le programme ne suffit pas toujours. Une démonstration ou une justification doit relier la géométrie aux blocs utilisés. Tu dois prouver que ton script traduit correctement la figure.

Pour un polygone régulier à n côtés, indique:

• la valeur de n;
• le calcul de l’angle de rotation 360 / n;
• le nombre de répétitions;
• la longueur choisie pour chaque côté;
• la raison pour laquelle la figure se referme après un tour complet.

Pour le triangle équilatéral, tu peux expliquer que le lutin avance trois fois, qu’il tourne de 120° à chaque sommet et que la somme des rotations vaut 360°. Pour le carré, tu relies les quatre répétitions et les rotations de 90°.

La formulation doit rester directe. Évite une phrase vague comme « le programme dessine la figure grâce à une boucle ». Elle ne justifie ni l’angle ni le nombre de côtés. Écris plutôt ce que chaque donnée représente dans la construction.

Une rédaction claire suit le programme

Présente tes explications dans le même ordre que ton script:

1. la scène et le lutin sont réinitialisés;

2. le stylo est mis en position d’écriture;

3. la boucle se répète autant de fois qu’il y a de côtés;

4. chaque répétition trace un côté puis effectue la rotation extérieure;

5. la figure se ferme parce que les rotations totalisent un tour complet.

Cette organisation aide ton correcteur à retrouver rapidement les éléments du barème. Elle t’aide aussi à repérer une incohérence: si tu ne peux pas expliquer une valeur dans ta rédaction, elle n’est peut-être pas encore maîtrisée dans ton programme.

Le bon tracé n’est donc pas seulement une figure qui apparaît à l’écran. C’est un programme initialisé, calculé, observable et justifié. Lorsque tu effaces la scène, replaces le lutin, imposes 90°, alignes le stylo et calcules 360 / n, tu élimines les erreurs les plus coûteuses avant même de lancer le script. Et lorsque tu termines par une justification précise de l’angle extérieur et du nombre de répétitions, tu transformes un dessin qui fonctionne en véritable réponse mathématique.