Polygones réguliers sur Scratch : le script pour les tracer

Polygones réguliers sur Scratch: le script pour les tracer

Le triangle devient une ligne brisée, le carré ressemble à un escalier, le pentagone part de travers. Ce blocage ne vient pas d’un manque de soin: il révèle une confusion très fréquente entre l’angle que nous observons à l’intérieur d’une figure en géométrie et l’angle dont le lutin a besoin pour changer de direction.

Scratch rend cette confusion particulièrement visible, ce qui en fait un excellent outil d’apprentissage. Le lutin ne « sait » pas dessiner un pentagone: il avance, s’arrête à un sommet, pivote, puis repart. Pour construire la figure, nous devons donc traduire une propriété géométrique en une suite d’instructions. C’est précisément là que se bâtit le lien entre mathématiques et algorithmique.

La règle qui consolide tout le raisonnement tient en une formule simple: pour un polygone régulier à n côtés, le lutin tourne de 360 ÷ n degrés après chaque côté.

Comprendre l’angle que Scratch doit faire tourner

Le piège classique consiste à saisir dans Scratch la mesure de l’angle intérieur. Pour un carré, par exemple, chaque angle intérieur mesure 90°. Beaucoup d’élèves programment alors: avancer de 100 pas, tourner de 90 degrés, répéter 4 fois. Par chance, cela fonctionne pour le carré — mais cela entretient parfois un malentendu.

Pourquoi? Parce que le 90° du carré est à la fois l’angle intérieur et l’angle extérieur: la coïncidence est particulière. Dès que nous passons au triangle équilatéral, elle disparaît. Ses angles intérieurs mesurent 60°, mais si le lutin tourne de 60° après chaque côté, il ne pourra pas refermer le triangle. Il doit tourner de 120°.

Scratch commande une rotation du lutin. Il faut donc utiliser l’angle extérieur, c’est-à-dire le changement de direction entre un côté et le suivant. En faisant le tour complet d’une figure, ces rotations totalisent toujours 360 degrés. Si les côtés et les angles sont tous identiques, cette rotation totale se partage équitablement entre les sommets.

La formule peut donc s’écrire ainsi:

angle de rotation = 360 ÷ nombre de côtés

Nous gagnons à faire manipuler cette idée avant même d’ouvrir Scratch. Sur une feuille, un élève peut suivre le contour d’un polygone avec son doigt et marquer l’instant où il doit « tourner pour continuer ». Il ne tourne pas vers l’intérieur de la figure: il pivote pour poursuivre son chemin. Cette manipulation réduit la charge cognitive au moment de programmer, car le bloc « tourner » cesse d’être une commande abstraite.

Un polygone régulier ne se programme pas en demandant au lutin de dessiner une forme: on lui apprend à répéter exactement le même déplacement et le même changement de direction.

Préparer le lutin et le stylo avant le tracé

Avant de construire la boucle, prenons le temps de stabiliser l’environnement. Un script correct peut sembler ne rien faire si le stylo n’est pas abaissé, si le lutin démarre hors de la scène ou s’il conserve l’orientation laissée par un essai précédent. Ces petites difficultés techniques sont banales, mais elles perturbent l’ancrage du raisonnement mathématique: l’élève pense que son calcul est faux alors que le problème vient de l’initialisation.

Dans Scratch, il faut d’abord ajouter l’extension Stylo. Elle se trouve dans le bouton d’ajout d’extensions, en bas à gauche de l’interface. Une fois activée, elle propose notamment les blocs permettant d’effacer les tracés et de mettre le stylo en position d’écriture.

Au début du programme, nous pouvons installer cette routine:

1. Choisir l’événement de départ: le bloc « quand le drapeau vert est cliqué ».

2. Effacer les tracés précédents avec le bloc « effacer tout », afin que chaque essai soit lisible.

3. Placer le lutin à une position de départ dégagée, par exemple vers le bas ou sur le côté de la scène.

4. Employer « s’orienter à 90 » pour fixer sa direction initiale vers la droite.

5. Ajouter « stylo en position d’écriture » avant la boucle: sans cette commande, le lutin se déplace, mais aucune ligne ne reste visible.

Cette préparation n’est pas du décor. Elle donne au programme une condition de départ identique à chaque exécution. En algorithmique, retrouver le même résultat quand on relance le même script est une ressource précieuse: nous pouvons alors modifier un seul paramètre, observer l’effet, formuler une hypothèse et la tester.

Pour les premiers essais, une taille de côté de 80 ou 100 pas offre généralement une figure assez lisible. Le nombre de pas correspond à une longueur affichée à l’écran, en pixels. Ce choix n’a pas d’incidence sur les angles: il change uniquement la taille du polygone. C’est une distinction à faire percevoir très tôt. Si le triangle est trop grand ou sort de la scène, diminuer la valeur du bloc « avancer » suffit; changer l’angle ne résoudrait pas ce problème.

Un script de départ propre

La logique des blocs est la suivante:

• quand le drapeau vert est cliqué;
• effacer tout;
• aller à une position choisie;
• s’orienter à 90;
• mettre le stylo en position d’écriture;
• lancer la boucle de tracé.

Le lutin peut tourner à droite ou à gauche: les deux choix sont valables. Une rotation à droite produit une figure orientée dans un sens, une rotation à gauche dans l’autre. La géométrie du polygone reste la même. Il est utile de le signaler, car deux scripts visuellement différents peuvent reposer sur le même algorithme.

Construire la boucle qui dessine les côtés

Le bloc « répéter » est le cœur du programme. Il exprime une idée fondamentale de la pensée informatique: lorsqu’une action identique doit être accomplie plusieurs fois, nous n’écrivons pas la même instruction à la suite; nous décrivons la répétition.

Pour tracer un triangle équilatéral de 100 pas de côté, la boucle contient deux actions:

• avancer de 100 pas;
• tourner de 120 degrés.

L’ensemble doit être répété 3 fois.

Autrement dit, le programme demande au lutin de tracer un premier côté, de pivoter au sommet, de tracer le suivant, puis de recommencer jusqu’au retour au point de départ. L’ordre des deux blocs compte. Si nous tournons avant d’avancer, le lutin produit lui aussi un triangle, mais avec une orientation différente. Ce n’est pas une erreur géométrique; c’est une occasion intéressante de distinguer ce qui est essentiel à la construction de ce qui relève de la position initiale.

Pour un carré, la structure devient:

• répéter 4 fois;
• avancer de 100 pas;
• tourner de 90 degrés.

Pour coder un pentagone Scratch, il ne faut pas chercher une nouvelle famille de blocs. Nous conservons la même architecture, puis nous adaptons deux nombres:

• répéter 5 fois;
• avancer de 100 pas;
• tourner de 72 degrés.

Le programme est plus puissant qu’il n’en a l’air. Il ne décrit pas seulement un triangle, un carré ou un pentagone: il décrit une procédure générale de tracé de formes géométriques dans Scratch.

La boucle répond au « combien de fois? »; l’angle extérieur répond au « de combien tourner? ». Confondre ces deux rôles rend le script fragile.

Pourquoi recopier les blocs est une fausse bonne idée

Nous rencontrons souvent deux approches chez les débutants. La première consiste à empiler plusieurs fois « avancer » puis « tourner ». La seconde utilise une boucle.

La copie peut avoir sa place lors d’un tout premier tâtonnement: elle permet de voir le mécanisme geste après geste. Mais elle ne doit pas devenir une habitude. La boucle réduit la charge cognitive et met en évidence une propriété essentielle du polygone régulier: chaque étape de construction est identique à la précédente.

Passer du triangle au polygone à n côtés

Une fois le premier polygone réussi, le travail le plus formateur consiste à ne plus changer les nombres au hasard. Nous pouvons demander: « Que faut-il modifier pour obtenir une autre figure, et que faut-il conserver? »

La réponse se construit progressivement:

• le nombre de répétitions est égal au nombre de côtés;
• la distance d’avancement fixe la longueur de chaque côté;
• l’angle de rotation est obtenu en divisant 360 par le nombre de côtés;
• le choix de tourner à droite ou à gauche change le sens du tracé, non la régularité de la figure.

Pour aller plus loin, créons trois variables: nombre de côtés, longueur du côté et angle. Au démarrage, le script peut demander à l’utilisateur le nombre de côtés souhaité, enregistrer sa réponse, puis calculer l’angle avec l’opération 360 / nombre de côtés.

La structure générale devient alors:

1. Demander le nombre de côtés.

2. Mettre nombre de côtés à la réponse.

3. Mettre angle à 360 / nombre de côtés.

4. Initialiser le stylo, la position et l’orientation du lutin.

5. Répéter nombre de côtés fois:

• avancer de longueur du côté pas;
• tourner de angle degrés.

Cette étape marque un véritable changement de nature dans l’activité. L’élève n’a plus un script pour le pentagone et un autre pour l’hexagone: il possède un algorithme capable de générer une famille de figures. Nous passons du programme-exemple au programme-outil.

Il convient néanmoins d’étayer le calcul avec quelques valeurs testées. Une formule mal saisie dans Scratch peut rester invisible si l’élève n’a aucun ordre de grandeur en tête. Avant de lancer le script, nous pouvons anticiper:

• avec 3 côtés, l’angle doit être supérieur à 90°, car il vaut 120°;
• avec 4 côtés, il vaut 90°;
• avec 6 côtés, il vaut 60°;
• quand le nombre de côtés augmente, l’angle de rotation diminue.

Cette dernière observation ouvre une belle discussion. Un polygone de très grand nombre de côtés se rapproche visuellement d’un cercle, car le lutin effectue beaucoup de petits virages. Scratch donne ici une forme concrète à une idée qui resterait autrement très théorique.

Déboguer un polygone qui ne se ferme pas

Un tracé raté est une information, pas une sanction. Nous avons intérêt à le lire avec l’élève plutôt qu’à effacer immédiatement le programme. La forme obtenue indique souvent la nature de l’erreur.

Si le lutin dessine une spirale ou s’éloigne progressivement, l’angle de rotation est probablement inadapté. Si la figure a le bon nombre de côtés mais ne revient pas exactement au point de départ, il faut regarder le calcul de l’angle et le nombre de répétitions. Si rien n’apparaît, le souci se situe fréquemment dans le stylo ou dans la position du lutin.

Voici les erreurs les plus courantes et la manière de les interpréter:

• Le lutin bouge mais ne trace aucune ligne. Le bloc « stylo en position d’écriture » a été oublié ou placé après la boucle. Nous le déplaçons avant le premier déplacement.
• Le triangle ne se ferme pas avec une rotation de 60°. Le programme utilise l’angle intérieur. Nous revenons à la question: de combien le lutin doit-il pivoter pour repartir sur le côté suivant? La bonne valeur est 120°.
• Le pentagone possède des côtés mais ressemble à une étoile ou s’entrecroise. L’angle n’est sans doute pas 72°, ou le lutin tourne plusieurs fois à chaque sommet. Il faut observer une itération de boucle, puis vérifier la multiplication: 5 rotations de 72° totalisent 360°.
• La figure est coupée par les bords. La longueur de côté est trop grande pour la place disponible sur la scène, ou la position de départ est trop proche d’un bord. Nous réduisons le déplacement ou nous déplaçons le point de départ.
• La figure est correcte au premier lancement, puis se superpose de façon confuse. Le script ne commence pas par « effacer tout ». Cette instruction facilite la comparaison entre les essais.
• Le même programme donne une figure tournée différemment. L’orientation initiale n’est pas fixée. Ajouter « s’orienter à 90 » permet de retrouver un repère stable.

L’enjeu n’est pas de rendre le code impeccablement court trop tôt. Il est de permettre à l’élève de relier chaque bloc à un effet observable. Quand il modifie l’angle de 72° à 70°, par exemple, la figure ne se referme plus tout à fait: cette petite différence rend tangible la précision du raisonnement géométrique.

Faire varier la longueur sans fragiliser la figure

La longueur du côté est un second levier pédagogique très riche. Dans le bloc « avancer de … pas », nous pouvons remplacer une valeur fixe par une variable. L’élève choisit alors la taille de sa figure sans toucher à l’algorithme de construction des angles extérieurs.

Il faut toutefois garder en tête les limites visuelles de la scène. Un grand polygone peut sortir du cadre, notamment si le lutin commence près d’un bord ou si la figure est orientée vers le haut. Dans ce cas, la réponse n’est pas de modifier la formule 360 / n, qui garantit la fermeture angulaire. Nous agissons sur la longueur, la position de départ ou l’orientation.

Cette distinction est structurante:

• la longueur règle l’échelle du dessin;
• le nombre de côtés règle la famille de polygones;
• l’angle extérieur règle le changement de direction;
• la boucle organise la répétition de la procédure.

Nous pouvons même proposer une activité de comparaison: conserver un hexagone et faire varier seulement la longueur du côté, puis conserver une même longueur et faire varier le nombre de côtés. Dans le premier cas, la forme grandit ou rétrécit sans changer de nature. Dans le second, l’angle se transforme et le contour se rapproche progressivement d’un cercle.

Pour des élèves qui avancent plus vite, il devient pertinent de créer un bloc personnel, par exemple « tracer un polygone ». Ce bloc peut recevoir deux paramètres: le nombre de côtés et la longueur. Ce n’est pas indispensable pour réussir le tracé, mais c’est une étape très féconde: nous nommons une procédure, nous la réutilisons et nous évitons de reconstruire le même raisonnement dans chaque projet Scratch mathématiques.

Un petit programme, une grande idée algorithmique

Tracer un polygone régulier avec Scratch ne se réduit pas à placer les bons blocs dans le bon ordre. L’activité fait tenir ensemble une propriété géométrique, une boucle de répétition et une procédure de débogage. Le lutin devient un instrument de vérification: s’il ne revient pas à son point de départ, le programme nous invite à revisiter le raisonnement.

La méthode reste stable: initialiser le lutin et le stylo, répéter autant de fois qu’il y a de côtés, avancer d’une longueur choisie, puis tourner de 360 ÷ n degrés. À partir de là, le triangle, le carré, le pentagone et les polygones plus nombreux ne sont plus des exercices isolés, mais des variations d’une même construction.

Aidons surtout l’enfant à verbaliser ce qu’il change et ce qu’il conserve. Un support tangible — une feuille où il note n, 360 ÷ n, la longueur et le résultat observé — suffit souvent à consolider le passage entre la figure imaginée, le calcul et le script. C’est dans cette circulation entre manipulation, langage mathématique et programmation que Scratch prend toute sa valeur.