Tracé géométrique sur Scratch : la checklist de départ

Tracé géométrique sur Scratch: la checklist de départ

Un carré qui ressemble à un carré n’est pas encore une preuve: il faut avoir placé le lutin, choisi la bonne orientation, activé le stylo, répété les instructions le bon nombre de fois et utilisé l’angle adapté.

La difficulté principale ne vient donc pas de l’interface. Elle vient de la traduction d’une figure en instructions précises. Pour réussir un tracé géométrique sur Scratch, tu dois passer de la géométrie au programme sans perdre une seule information en chemin.

Un tracé correct commence par une initialisation complète et se termine par une vérification de la figure, pas par un simple clic sur le drapeau vert.

Avant de tracer: préparer un projet propre

Ajouter l’extension « Stylo »

Dans Scratch 3, les blocs de dessin ne sont pas affichés automatiquement dans un nouveau projet. Tu dois ajouter l’extension « Stylo » en cliquant sur le bouton d’extension situé en bas à gauche de l’interface.

Une fois l’extension ajoutée, une nouvelle catégorie de blocs apparaît. Tu y trouves notamment:

• « effacer tout », pour supprimer les traces d’un tracé précédent;
• « stylo en position d’écriture », pour permettre au lutin de dessiner lorsqu’il se déplace;
• « relever le stylo », pour déplacer le lutin sans laisser de ligne;
• « mettre la couleur du stylo à… », pour modifier l’aspect du tracé;
• « mettre la taille du stylo à… », pour obtenir une ligne plus visible ou plus fine.

Cette étape paraît secondaire, mais elle explique une erreur très fréquente: le programme se lance, le lutin avance, et rien ne s’affiche. Dans ce cas, le bloc « stylo en position d’écriture » manque souvent, ou bien le stylo a été relevé par une instruction précédente.

Réinitialiser le lutin à chaque lancement

Un programme de géométrie doit produire le même résultat chaque fois que tu cliques sur le drapeau vert. Si le lutin conserve sa position, son orientation ou ses traces d’un essai précédent, tu ne peux plus savoir si ton algorithme fonctionne réellement.

La séquence de départ la plus fiable comprend les blocs suivants, placés sous « quand le drapeau vert est cliqué »:

1. « effacer tout »;

2. « aller à x: 0 y: 0 »;

3. « s’orienter à 90 »;

4. « stylo en position d’écriture ».

L’ordre peut parfois être adapté selon le dessin demandé, mais cette organisation offre une base claire. Le lutin revient au centre, regarde vers la droite, efface l’ancien tracé et se prépare à dessiner.

La position « x: 0 y: 0 » n’est pas obligatoire pour toutes les figures. Elle est cependant très pratique pour démarrer un exercice dans des conditions prévisibles. Si l’énoncé impose un point de départ particulier, tu remplaces simplement ces coordonnées par celles demandées.

Comprendre les orientations du lutin

Scratch utilise des orientations qui ne correspondent pas exactement aux repères habituels d’une feuille de géométrie. Pour éviter une erreur de direction dès le premier déplacement, retiens les quatre valeurs de base:

Ainsi, si tu écris « s’orienter à 90 », puis « avancer de 100 », le lutin part vers la droite. Si tu écris « s’orienter à 0 », il part vers le haut.

Ne confonds pas orientation et rotation. L’orientation fixe une direction absolue. Le bloc « tourner de… degrés » modifie la direction actuelle du lutin. Cette distinction devient essentielle dès que tu dessines un polygone.

Traduire une figure géométrique en instructions

Pour programmer une figure, tu dois d’abord la décrire comme une suite d’actions. Un carré, par exemple, ne se résume pas à quatre côtés égaux. Dans Scratch, il devient une succession répétée de deux instructions:

• avancer d’une certaine longueur;
• tourner d’un certain angle.

Pour un carré de côté 80, le programme logique est donc:

• avancer de 80;
• tourner de 90°;
• recommencer quatre fois.

Le bloc « répéter 4 fois » évite de recopier les mêmes instructions. Il rend le programme plus court et montre immédiatement la structure de la figure.

La règle générale des polygones réguliers

Pour dessiner un polygone régulier à \(n\) côtés, tu dois répéter \(n\) fois la séquence suivante:

1. avancer de la longueur du côté;

2. tourner de \(360° \div n\).

Le calcul fournit l’angle de rotation extérieur, c’est-à-dire l’angle nécessaire pour que le lutin se place dans la direction du côté suivant.

Le pentagone et l’octogone sont de bons tests pour vérifier que tu as compris la règle. Le calcul n’est pas toujours immédiat, mais il reste le même: un tour complet mesure 360°, réparti entre les côtés.

Pourquoi il ne faut pas utiliser l’angle intérieur

C’est l’erreur classique dans un exercice « dessiner un polygone sur Scratch ». Pour un triangle équilatéral, l’angle intérieur vaut 60°. Pourtant, le lutin doit tourner de 120°.

Pourquoi? Parce que le lutin avance dans la direction du côté précédent. Lorsqu’il arrive au sommet, il doit modifier sa direction pour suivre le côté suivant. Le virage effectué par le lutin est l’angle extérieur, supplémentaire de l’angle intérieur.

Pour un carré, les deux valeurs sont identiques: l’angle intérieur et l’angle extérieur valent chacun 90°. Cette coïncidence peut masquer l’erreur. Si tu testes seulement un carré, tu peux croire que ta méthode est correcte alors que tu utilises une mauvaise règle. Teste plutôt un triangle ou un hexagone: l’erreur devient immédiatement visible.

Pour « tourner de… degrés » dans Scratch, calcule \(360° \div\) le nombre de côtés. Ne reporte pas directement l’angle intérieur lu sur la figure.

La checklist d’initialisation du stylo

Avant de chercher à embellir le dessin, vérifie que le programme part toujours du même état. Une bonne initialisation évite les tracés décalés, les figures superposées et les lignes qui apparaissent avant le début réel du dessin.

Tu peux utiliser cette liste dans l’ordre:

• le projet contient bien l’extension « Stylo »;
• le bloc « quand le drapeau vert est cliqué » commande le programme;
• les anciennes traces sont supprimées avec « effacer tout »;
• le lutin est placé aux coordonnées prévues;
• son orientation de départ est fixée;
• le stylo est mis en position d’écriture;
• le bloc de répétition contient uniquement les actions du motif;
• le nombre de répétitions correspond au nombre de côtés.

Si ton programme doit dessiner plusieurs figures, la réinitialisation doit être placée au bon endroit. Pour commencer une nouvelle figure sans conserver la précédente, tu peux relever le stylo, déplacer le lutin, choisir une nouvelle orientation, puis remettre le stylo en position d’écriture. Si tu utilises « effacer tout », toutes les figures déjà dessinées disparaîtront: cette instruction ne sert donc pas à changer de position, mais à nettoyer la scène.

Couleur et épaisseur: utiles, mais après la logique

Les blocs de couleur et de taille rendent le tracé plus lisible. Ils ne corrigent toutefois aucune erreur géométrique. Une figure fausse avec un stylo coloré reste une figure fausse.

Pour un exercice de mathématiques, règle d’abord:

• la position;
• l’orientation;
• la longueur des déplacements;
• l’angle de rotation;
• le nombre de répétitions.

Ensuite seulement, ajoute la couleur ou modifie la taille du stylo. Cette priorité te fait gagner du temps au brouillon comme dans la programmation: tu repères plus facilement si le problème vient de la logique ou de la présentation.

Construire un polygone avec une boucle

Le bloc « répéter N fois », dans la catégorie « Contrôle », est le cœur du tracé des figures répétitives. Il permet d’exprimer une régularité géométrique avec une instruction algorithmique simple.

Pour un hexagone régulier de côté 50, la structure est:

• initialiser le projet;
• répéter 6 fois:
• avancer de 50;
• tourner de 60°.

Le nombre 6 vient du nombre de côtés. Le nombre 60 vient du calcul \(360 \div 6\). Si tu modifies la longueur du côté mais pas le nombre de côtés, la figure devient plus grande ou plus petite, sans changer de nature. Si tu modifies le nombre de répétitions et l’angle, tu obtiens une autre figure.

Repérer le bloc qui doit être répété

Une erreur de programmation fréquente consiste à placer la rotation en dehors de la boucle. Le lutin avance alors plusieurs fois dans la même direction, puis tourne une seule fois à la fin. Tu obtiens une ligne ou une forme ouverte, pas un polygone.

Dans la boucle, tu dois placer le couple complet:

• déplacement;
• rotation.

La rotation appartient à chaque sommet de la figure. Elle doit donc être exécutée après chaque déplacement, et non une seule fois après l’ensemble des déplacements.

Pour contrôler ton brouillon, entoure mentalement le motif qui se répète. Si tu dessines un carré, le motif est « avancer, tourner ». Si tu dessines une étoile, le motif peut rester similaire, mais l’angle et le nombre de répétitions changent. Le bon programme naît de cette décomposition.

Vérifier la fermeture de la figure

Un polygone régulier doit revenir à son point de départ après le dernier côté. Si le tracé ne se ferme pas, plusieurs causes sont possibles:

• le nombre de répétitions est incorrect;
• l’angle de rotation est faux;
• la longueur des côtés varie;
• le lutin n’a pas été correctement initialisé;
• une instruction supplémentaire modifie la direction dans la boucle.

Observe le dernier sommet. Si la figure se ferme presque, le problème peut venir d’un angle mal calculé ou d’une valeur de déplacement approximative. Si elle part nettement dans une autre direction, vérifie en priorité l’orientation initiale et le nombre de répétitions.

Vérification visuelle: lire le dessin comme une preuve

Le résultat à l’écran ne remplace pas la justification, mais il t’aide à localiser l’erreur. Tu dois apprendre à observer la figure avant de modifier les blocs au hasard.

Les symptômes les plus fréquents

Cette lecture visuelle est particulièrement utile au brouillon. Elle t’évite de reprendre tout le programme. Une figure ouverte ne signifie pas que tout est faux: elle indique souvent une seule erreur dans l’angle, la répétition ou l’initialisation.

Compter les sommets sans se laisser tromper

Lorsque le lutin termine un polygone, le dernier déplacement peut rejoindre le point de départ. Pour vérifier le nombre de côtés, compte les segments tracés, pas seulement les points visibles.

Un carré possède quatre côtés et quatre rotations. Un triangle possède trois côtés et trois rotations. Dans un programme régulier, le nombre de répétitions correspond aux deux nombres: chaque répétition produit un côté et prépare la direction du côté suivant.

Si tu ajoutes une rotation sans déplacement, tu modifies l’orientation finale mais pas le nombre de côtés. Cette instruction peut être utile pour préparer une autre figure, mais elle ne doit pas être confondue avec une étape du tracé.

Décrire le programme avec une rédaction mathématique

Dans un exercice de Scratch au collège, le correcteur ne cherche pas uniquement une image réussie. Il cherche à comprendre pourquoi les blocs produisent la figure demandée. Une rédaction courte et précise peut donc rapporter des points de justification.

Tu peux présenter ton raisonnement en trois étapes:

1. préciser le nombre de côtés de la figure;

2. calculer l’angle de rotation;

3. expliquer la répétition du motif.

Pour un hexagone régulier, une rédaction correcte peut prendre cette forme:

• l’hexagone possède 6 côtés;
• l’angle de rotation est \(360° \div 6 = 60°\);
• il faut répéter 6 fois les instructions « avancer de la longueur du côté » puis « tourner de 60° ».

Cette rédaction prouve que tu n’as pas choisi 60° au hasard. Elle relie la propriété géométrique au bloc Scratch correspondant.

Pour un triangle équilatéral, ne te contente pas d’écrire que chaque angle mesure 60°. Cette information concerne l’angle intérieur. Le programme demande l’angle de rotation du lutin, donc tu dois expliquer que la rotation utilisée est l’angle extérieur: \(360° \div 3 = 120°\).

Le vocabulaire qui rend la justification lisible

Utilise des verbes d’action précis:

• « placer » le lutin;
• « orienter » le lutin;
• « avancer » de la longueur du côté;
• « tourner » de l’angle extérieur;
• « répéter » le motif;
• « fermer » la figure;
• « vérifier » le retour au point de départ.

Évite une phrase vague comme: « Le programme fait un carré parce que les blocs sont répétés. » Elle ne donne ni la longueur, ni l’angle, ni le nombre de répétitions. Le barème valorise généralement la présence des informations qui permettent de reconstituer le raisonnement.

Une bonne justification n’a pas besoin d’être longue. Elle doit être complète. Deux lignes exactes valent mieux qu’un paragraphe qui décrit seulement l’aspect du dessin.

Du carré aux figures plus complexes

La méthode ne s’arrête pas aux polygones réguliers. Elle permet aussi de construire des figures composées, à condition de séparer clairement chaque partie du programme.

Tracer un rectangle

Pour un rectangle, les côtés opposés ont la même longueur, mais les quatre déplacements n’utilisent pas nécessairement la même valeur. Le programme doit donc alterner deux longueurs:

• avancer de la longueur;
• tourner de 90°;
• avancer de la largeur;
• tourner de 90°;
• recommencer le couple deux fois.

Tu peux utiliser une boucle « répéter 2 fois » si le motif répété est correctement construit. Le motif doit alors contenir les quatre actions qui forment un tour complet du rectangle: longueur, rotation, largeur, rotation.

Ne mets pas une seule valeur d’avance dans une boucle en espérant obtenir un rectangle. Tu obtiendras un carré si les rotations sont droites, ou une autre figure si les paramètres ne correspondent pas.

Tracer une figure composée

Pour une figure composée de plusieurs polygones, le stylo doit parfois être relevé entre deux parties. Sinon, le déplacement vers le nouveau point crée un segment parasite.

La logique devient:

1. terminer la première figure;

2. relever le stylo;

3. déplacer le lutin vers le point de départ de la seconde figure;

4. fixer la nouvelle orientation;

5. remettre le stylo en position d’écriture;

6. lancer le second tracé.

Cette organisation est utile dans les activités Scratch de mathématiques où l’on demande de dessiner une maison, un motif répétitif ou une figure symétrique. Chaque sous-figure doit garder sa propre logique. Si tout est mélangé dans une seule longue suite de blocs, l’erreur devient difficile à localiser.

Utiliser des blocs personnalisés

Lorsque tu répètes plusieurs fois la même construction, tu peux créer un bloc personnalisé, par exemple « tracer un carré de côté… ». Cette étape n’est pas toujours exigée dans un exercice débutant, mais elle introduit une idée importante de l’algorithmique: regrouper une procédure pour la réutiliser.

Le bloc personnalisé doit recevoir les informations utiles, notamment la longueur du côté si elle varie. Tu évites ainsi de recopier la même série de blocs et tu rends le programme plus lisible.

Cependant, ne crée pas un bloc personnalisé pour cacher une erreur de raisonnement. Avant de simplifier le programme, fais fonctionner une première version simple. La clarté de la logique passe avant l’élégance du code.

Les erreurs qui coûtent des points

Certaines erreurs sont rapidement corrigées à l’écran, mais elles révèlent aussi un manque de méthode dans la rédaction.

Commencer sans réinitialiser

Si tu testes le programme plusieurs fois sans « effacer tout », tu peux attribuer au nouvel essai une trace produite par l’ancien. Le dessin devient illisible et tu risques de corriger un problème qui n’existe pas.

Clique sur le drapeau vert après chaque modification et observe uniquement le résultat du nouveau lancement. La réinitialisation est une condition de vérification, pas une décoration.

Confondre déplacement et rotation

« Avancer de 80 » modifie la position du lutin. « Tourner de 90° » modifie sa direction. Les deux blocs n’ont pas le même rôle. Une figure géométrique se construit grâce à leur enchaînement.

Si tu places deux déplacements consécutifs, tu obtiens un segment plus long. Si tu places deux rotations consécutives, tu changes seulement la direction. Relis donc ton programme en décrivant l’action de chaque bloc, l’un après l’autre.

Modifier trop de paramètres à la fois

Lorsque le tracé est faux, ne change pas simultanément la longueur, l’angle, la position et le nombre de répétitions. Tu ne sauras pas quelle modification a corrigé ou aggravé le résultat.

Procède par ordre:

1. vérifie que le stylo dessine;

2. vérifie la position de départ;

3. vérifie l’orientation;

4. vérifie la longueur;

5. vérifie l’angle;

6. vérifie le nombre de répétitions.

Cette progression suit le chemin réel du lutin. Elle transforme le débogage en observation méthodique plutôt qu’en essai au hasard.

Oublier l’unité ou la valeur demandée

Dans Scratch, les déplacements sont exprimés en pas et les rotations en degrés. Dans ta rédaction, indique clairement ce que représente chaque valeur. Écris « avancer de 80 pas » et « tourner de 90° » plutôt que de juxtaposer des nombres sans explication.

Si l’exercice demande une figure de côté donné, le bloc « avancer de… » doit reprendre cette valeur. Une figure proportionnelle mais trop petite ne répond pas forcément à la consigne.

Une méthode rapide avant de rendre le programme

Avant de considérer ton tracé comme terminé, relis-le dans l’ordre d’exécution. Tu dois pouvoir répondre sans hésiter aux questions suivantes:

• Que se passe-t-il lorsque le drapeau vert est cliqué?
• Où le lutin se place-t-il?
• Dans quelle direction regarde-t-il?
• Le stylo est-il abaissé avant le premier déplacement?
• Quel motif est répété?
• Combien de fois ce motif est-il exécuté?
• Quel calcul justifie l’angle de rotation?
• Le dernier segment rejoint-il le point de départ?
• Le programme donne-t-il le même résultat après plusieurs lancements?
• La rédaction explique-t-elle le lien entre la figure et les blocs?

Si une réponse manque, le programme n’est pas encore complètement justifié. Tu peux alors revenir au brouillon et écrire la figure sous forme d’actions: positionner, orienter, avancer, tourner, répéter. Cette suite suffit souvent à faire apparaître le bloc mal placé.

Le bon réflexe n’est pas de corriger un dessin à l’œil jusqu’à ce qu’il paraisse juste. Il faut retrouver l’instruction qui produit chaque segment et chaque virage.

Pour retenir la méthode

Un tracé géométrique sur Scratch repose sur quatre correspondances simples:

• le nombre de côtés devient le nombre de répétitions;
• la longueur du côté devient la valeur du déplacement;
• l’angle extérieur devient la valeur de la rotation;
• le point de départ et la direction deviennent l’initialisation du lutin.

Pour un polygone régulier à \(n\) côtés, le programme suit donc la règle:

• répéter \(n\) fois;
• avancer de la longueur du côté;
• tourner de \(360° \div n\).

La partie la plus rentable dans un exercice n’est pas l’ajout d’effets visuels. Ce sont les détails qui rendent le programme vérifiable: « effacer tout », « aller à x: 0 y: 0 », « s’orienter à 90 », puis « stylo en position d’écriture ». Ensuite, tu contrôles la boucle, le calcul de l’angle et la fermeture de la figure.

C’est cette rigueur qui transforme un dessin obtenu par essais successifs en véritable raisonnement algorithmique. Le correcteur doit pouvoir lire ton programme, suivre le déplacement du lutin et comprendre pourquoi la figure apparaît. Именно la dernière ligne de ta justification peut faire la différence: indique toujours le calcul de l’angle, le nombre de répétitions et le retour attendu au point de départ.