Projets SCRATCH intermédiaires

.

Les projets présents dans ce groupe sont de niveau intermédiaires.

Pour ces projets, les utilisateurs sont supposés connaître et avoir acquis le fonctionnement de Scratch (être capable de faire des projets classés débutant/intermédiaire). Ils doivent disposer également d’ une base satisfaisante en algorithmique: les variables, les tests et les boucles doivent être réellement acquis. Par ailleurs, les projets de cette section sont plus complexes tant au niveau algorithmique que de la programmation à proprement parler, ils ne sont donc pas conseillés avant le cycle 4.

Chaque projet est décrit pas à pas, afin de pouvoir être utilisé en travaux dirigés. Ces projets  ne sont accessibles qu’aux comptes de type ‘Enseignant’. Chaque projet est disponible en téléchargement , entièrement commenté, avec une fiche PDF récapitulative et toutes ses ressources graphiques.

Info

SCRATCH 3 est sorti le 2 janvier 2019. Ces projets ont été fait avec SCRATCH 2, mais sont compatibles avec la dernière version de SCRATCH et les projets finis téléchargeables peuvent être ouverts et utilisés dans SCRATCH 3 sans problème. Nous préparons également des projets qui utilisent les nouveautés de cette dernière version!

Les cours :

Lecture1:Jeu de pendu

Lecture1:Celvolution – jeu – niveau 1

Lecture1:Celvolution – jeu – niveau 2

Lecture1:Un mot pour un autre

Projets SCRATCH intermédiaires

Jeu de pendu

Description du projet

Le jeu du pendu est un jeu de lettre. Il faut deviner un mot dont on connaît seulement le nombre de lettres. Le joueur propose une lettre, si elle est dans le mot, on l’affiche à la place où elle doit se trouver. S’il y a plusieurs fois la même lettre, on les affiche toutes. Si la lettre n’est pas dans le mot, on dessine un élément supplémentaire d’un dessin qui finira par représenter un pendu. Le but du jeu est de trouver le mot avant que le pendu ne soit complétement dessiné. Le nombre de propositions erronées possibles va dépendre du nombre d’éléments du dessin qui représente le pendu. Dans notre version, nous accepterons dix propositions fausses avant de déclarer le joueur perdant.

Ce projet va permettre de manipuler les variables alphanumériques. Nous allons découvrir les différents opérations et instructions qui sont associées à ce type de variable.

Partie 1 -Préparation de l’application et ajout des ressources

Supprimer le lutin SCRATCH par défaut.

Ajouter le lutin “lutin_potence_pendu.sprite2” contenus dans les ressources associées au projet. Il contient tous les costumes nécessaire pour le pendu.

Créer 3 lutins “jeu”, “affichage” et “tirage et lettres fausses” sans leur associer de costume.

Ajouter l’arrière-plan “fond_western_pendu.png“.

Partie 2 – Programmation

Le programme devra suivre le cheminement suivant :

Choisir un mot aléatoirement parmi une liste de mots prédéfinis ;

Répéter les opérations suivantes tant que le mot n’a pas été trouvé ou que le nombre de propositions fausses est plus petit ou égal à 10 ;Demander une lettre au joueur ;

Si la lettre est bonne, on l’affiche à la place où elle doit se trouver ;

Si la lettre est mauvaise, on ajoute un élément au dessin du pendu ;

Si le mot à été trouvé, signaler que le joueur a gagné, sinon lui dire qu’il a proposé trop de mauvaises lettres et qu’il a perdu.

Pseudo code pour le jeu du pendu

mot←tirage aléatoire nb_lettre_fausse←0 nb_lettre_juste←0 coups←0 TantQue mot nb_lettre_juste!=longueur de mot || lettre_fausse!=10 Ecrire "Proposez une lettre" Lire lettre coups←coups+1 Si lettre appartient à mot==vrai Alors Afficher la lettre à l'écran nb_lettre_juste←nb_lettre_juste+1 Sinon nb_lettre_fausse←nb_lettre_fausse+1 Afficher un élément de plus à la potence Fin Si Fin TantQue Si nb_lettre_juste=longueur de mot Alors Ecrire "vous avez trouvé en "+coups+" coups" Sinon Ecrire "Perdu" Fin Si

Description du pseudo code :

Tout d’abord, nous initialisons les variables. Nous effectuons un tirage aléatoire pour déterminer la variable mot qui contiendra le mot à trouver. Les variables nb_lettre_juste, nb_lettre_fausse et coups sont mises à zéro ;

Nous introduisons une boucle qui va s’exécuter tant que la variable nb_lettre_juste ne sera pas égale au nombre de lettres contenues dans les mot ou tant que le nombre de lettres fausses proposées sera différent de 10 ;

Nous demandons une lettre à l’utilisateur, nous la stockons dans la variable lettre et nous incrémentons la variable coups ;

Si la lettre est contenue dans le mot à trouver, nous l’affichons et incrémentons la variable nb_lettre_juste ;

Si la lettre n’appartient pas au mot à trouver, nous incrémentons la variable nb_lettre_fausse et ajoutons un élément de la potence ;

A la sortie de la boucle nous testons si le nombre de lettres trouvées est égal au nombre de lettres contenues dans le mot à trouver, dans ce cas le joueur a gagné, sinon, c’est qu’il a perdu.

Programmation dans Scratch

Nous commençons par déclarer les variables nécessaires au fonctionnement du programme.

coups : contient le nombre de coups que le joueur a effectué.

liste_mots : contient tous les mots qui peuvent être proposés.

mot : contient le mot qu’il faut deviner.

propose : contient toutes les lettres qui ont déjà été proposées. Cette variable servira à l’affichage.

nb_lettre_juste : contient le nombre de lettres qui ont été trouvées.

nb_lettre_fausse : contient le nombre de lettres fausses qui ont déjà été proposées.

aff_joueur : contient les lettres juste qui ont été trouvées. Cette variable servira à l’affichage.

lettre_trouvee : cette variable sert lors du test qui détermine si la lettre proposée est bonne.

OK : cette variable sert lorsque nous testons si le joueur a bien proposée une seule lettre.

i : cette variable sert de compteur dans les boucles.

Nous devons aussi déclarer des listes. Dans SCRATCH, les listes sont des variables qui peuvent contenir plusieurs données et correspondent en algorithmique à des tableaux à une dimension.

Lien

La notion de tableau est abordée dans la ressource suivante : cliquer

mots_a_trouver : liste qui contient tous les mots à trouver. Elle est construite à chaque exécution à partir de la variable liste_mot.

proposees : cette liste contient toutes les lettres déjà proposées.

pendu : contient les lettres trouvées par le joueur.

Nous remarquons que certaines variables et listes semblent être redondantes. En effet, par exemple, la variable propose contient les lettres déjà proposées et la liste proposees aussi. Nous utiliserons la liste pour effectuer les tests et pour mettre à jour les lettres proposées en fonction des propositions du joueur. La variable propose ne servira qu’à l’affichage. Nous verrons dans la suite qu’il est plus facile d’effectuer des opérations sur les listes et que l’affichage est plus simple à traiter pour des variables.

Code Scratch pour le lutin jeu

Comme pour la plupart des projets, nous commençons par placer le lutin au bon endroit sur l’écran pour que le texte n’apparaisse pas n’importe où. Ensuite, nous initialisons les variables puis nous envoyons le message “tirage“. Ce message déclenche le tirage aléatoire du mot à trouver parmi la liste de mots disponibles contenus dans la variable liste_mots. Nous aurions pu placer cette partie du code à la suite de l’initialisation des variables, mais, dans un soucis de lisibilité, nous avons préférer traiter ce tirage dans un autre lutin.

Nous utiliserons, pour la suite, une boucle répéter jusqu’à avec les deux conditions suivantes :

nb_lettre_juste==longueur(mot). Si le nombre de lettres justes est égal au nombre de lettres dans le mot à trouver c’est que le joueur à trouvé la bonne réponse ;

nb_lettre_fausse==10. Si le nombre de lettres fausses est égale à 10, alors le pendu est dessiné en entier, le joueur a perdu.

A la sortie de la boucle, nous testons si le joueur a gagné ou perdu. S’il a gagné, nous l’informons du nombre de coups qui ont été nécessaire pour trouver le mot. S’il a perdu, nous affichons le mot à trouver.

Le reste du code développé par la suite devra être inséré dans cette boucle.

La partie de code suivante va nous permettre de saisir la lettre proposée par le joueur. La variable OK nous indique si la réponse proposée est correcte, nous lui affectons la valeur non. Nous utilisons ensuite une boucle répéter jusqu’à OK==“oui”. Nous demandons la proposition du joueur. Dans un premier temps, nous cherchons si la lettre est déjà contenues dans la liste proposees. Pour ce test nous utilisons la commande liste contient mot ? qui permet de savoir si la liste indiquée contient le mot demandé. Si la lettre est déjà proposée, on repose la question.

Note

L’instruction nous permet de savoir si le mot est dans la liste en utilisant une seule commande. Si nous avions utilisée des variables, il aurait fallut effectuer des tests lettre par lettre pour savoir si le mot était contenu dans la variable. L’écriture du code aurait été bien plus lourde et moins lisible. C’est pour cela que, dans tout le projet, nous utiliserons des listes pour effectuer les tests et les opérations sur les lettres et mots.

Nous effectuons un second test sur la forme de la réponse proposée. Il ne faut pas qu’il y ait plus d’une lettre ou que la réponse soit vide. Si c’est le cas, on repose la question. Si la réponse ne contient pas de lettre déjà proposée et qu’elle est bien composée d’une seule lettre, alors nous affectons la valeur “oui” à la variable OK, nous pouvons sortir de la boucle.

La réponse proposée est valide, nous pouvons donc incrémenter la variable coups de 1. Nous ajoutons la lettre qui vient d’être proposée à la liste proposees.

Nous allons tester si la lettre proposée est contenue dans le mot à trouver. Nous affectons la valeur 1 à la variable i qui servira de compteur et 0 à la variable lettre_trouvee. Nous allons répéter ce test autant de fois qu’il y a de lettres dans le mot à trouver. Pour la première boucle, la variable i vaut 1, nous testons donc si la 1ère lettre de la variable mot (le mot à trouver) est la même que la lettre proposée. Si c’est la cas, nous incrémentons la variable nb_lettre_juste de 1, nous ajoutons la lettre trouvée à la position 1 de la liste pendu (elle contient les lettres trouvées par le joueur) et nous affectons la valeur1 à lettre_trouvee.

Nous incrémentons i de 1 et effectuons le même test pour la deuxième lettre du mot à trouver. Nous procédons de la même manière pour toutes les lettres du mot à trouver.

Lorsque nous sortons de la boucle précédente, si la variable lettre_trouvee vaut 0, c’est que la lettre proposée n’était pas dans le mot à deviner. Nous envoyons le message “lettre fausse” et nous incrémentons la variable nb_lettre_fausse de 1. Le message “lettre fausse” sera traité par les lutins affichage joueur et tirage et lettres fausses, comme nous le verrons dans la suite.

Code Scratch pour le lutin affichage joueur

Ce lutin va nous permettre d’afficher les lettres déjà trouvées par le joueur. Nous plaçons le lutin au bon endroit, affectons la valeur 1 à la variable i et effaçons le contenu de la variable aff_joueur.

Nous allons transférer les lettres de la liste pendu dans la variable aff_joueur. Nous sommes obligé de passer par cette variable pour pouvoir utiliser l’instruction dire afin d’afficher les lettres trouvées. Dans Scratch, l’opération de concaténation est représentée par la bloc regroupe mot1 mot2.

Nous créons une boucle qui va s’exécuter autant de fois qu’il y a de lettres dans le mot à trouver. Au premier passage dans la boucle (i=1), nous ajoutons la 1ère lettre de la liste pendu à aff_joueur, au deuxième passage (i=2), nous ajoutons la deuxième lettre et ainsi de suite jusqu’à la fin du mot.

Code Scratch pour le lutin Potence

Au début du jeu, nous affichons le 1er costume. Lorsque le lutin reçoit le message “lettre fausse”, nous basculons sur le costume suivant.

Code Scratch pour le lutin tirage et lettres fausses

Ce lutin va faire le tirage aléatoire du mot à trouver en débute de partie. Par la suite, il servira à afficher les lettres fausses qui ont déjà été proposées. Nous faisons gérer cette affichage par ce lutin et non par le lutin affichage joueur car un lutin ne peut pas afficher deux textes en même temps.

Tirage aléatoire du mot à trouver

Quand le message “tirage” est reçu, nous initialisons la variable liste_mots. Cette variable contient tous les mots qu’il est possible de faire deviner. Les différents mots sont séparés par une virgule. Si vous voulez rajouter des mots à trouver, c’est ici qu’il faudra le faire, en faisant bien attention de les séparer par une virgule et de ne pas ajouter d’espace. Nous effaçons le contenu de la variable mot_temp et affectons la valeur 1 à la variable i.

Nous créons une boucle qui va se répéter autant de fois qu’il y a de lettres dans la variable liste_mot. Nous testons si la iéme lettre de la variables liste_mot est une virgule. Si ce n’est pas le cas, nous ajoutons cette lettre à la variable mot_temp avec l’instruction de concaténation regroupe mot1 mot2. Lorsque nous rencontrons une virgule, c’est que le mot est complet, il est contenu dans la variable mot_temp. Nous ajoutons ce mot à la liste mots_a_trouver. Quand nous sortons de la boucle, la liste mots_a_trouver contient tous les mots que l’on peut faire deviner. Nous effectuons un tirage au sort afin d’extraire le mot à deviner de cette liste.

Nous mettons autant de tirets ( _ ) qu’il y a de lettres dans le mot a trouver dans la variable pendu. Ces tirets symbolisent les lettres qui n’ont pas été trouvées. Ils seront remplacés au fur et à mesure par les lettres que le joueur à trouvées.

Affichage de lettres fausses déjà proposée

Quand le message “lettre_fausse” est reçu, c’est que le joueur à fait une mauvaise proposition. On ajoute cette nouvelle lettre et un espace à la variable propose qui contient déjà les autres lettres fausses proposées, puis on affiche cette variable à l’écran. L’espace entre chaque lettre est ajouté pour que l’affichage soit plus lisible.

.

Projets SCRATCH intermédiaires

Celvolution – jeu – niveau 1

Description du projet

Nous allons développer un jeu du style Agar.io. Le joueur contrôle une cellule qui évolue sur un terrain de jeu quadrillé et qui devra grossir en absorbant des cellules plus petites que lui. Le déplacement du joueur se fait grâce à la souris, la cellule qu’il contrôle va toujours se diriger vers le curseur et plus le curseur est éloigné du joueur, plus la vitesse sera rapide Des cellules apparaissent aléatoirement à l’écran ; elles sont toujours de la même taille et ne bougent pas. Le but est d’arriver à grossir le plus possible pour pouvoir absorber les autres joueurs. Quand on absorbe un adversaire, on grossit proportionnellement à sa taille. Dans notre projet, l’adversaire sera géré par l’ordinateur et nous appellerons son lutin AI (Artificial Intelligence).

Ce projet va permettre de découvrir comment programmer un scrolling à l’écran afin de donner l’impression que le joueur bouge par rapport à son environnement. Nous allons utiliser plusieurs principes de programmation que nous avons vu dans les projets précédents, comme gérer la taille des lutins, créer des clones par exemple. De plus, nous allons aborder la création de nouveaux blocs.

Partie 1 -Préparation de l’application et ajout des ressources

Supprimer le lutin par défaut.

Ajouter les lutins “lutin_joueur_celvolutionniv1.svg“, “lutin_cellule_celvolutionniv1.svg“, “lutin_AI_celvolutionniv1.svg“, “lutin_grille_celvolutionniv1.sprite2” et “lutin_fin_celvolutionniv1.png“. Le lutin texte de fin peut être créé directement dans l’éditeur de costumes, il suffit d’écrire “La partie est finie”.

Il n’y a pas d’arrière-plan. La grille qui représente le fond d’écran est géré par un lutin, comme nous allons le voir dans la suite.

Partie 2 – Programmation

Le programme devra effectuer le cheminement suivant :

Faire apparaitre une cellule toutes les 2 secondes;

Déplacer le joueur et tester si le joueur à absorbé une cellule;

Déplacer la cellule gérée par l’ordinateur et tester si elle absorbe une cellule;

Tester si le joueur touche la cellule gérée par l’ordinateur. Si la taille du joueur est plus grande, on fait disparaître l’AI et on augmente la taille du joueur. Inversement, si la taille de l’Ai est plus grande, le joueur a perdu.

Animation des lutins

Nous allons tout d’abord nous occuper du déplacement des différents lutins. Durant toute la partie, la cellule représentant le joueur reste fixe au milieu de l’écran. Pour simuler son déplacement, nous allons introduire la notion de scrolling. En effet, l’effet de mouvement est produit par le défilement de la grille derrière la cellule représentant le joueur, ce défilement est appelé scrolling.

Quand, nous déplaçons le pointeur de la souris, nous devons donner l’impression que le joueur va se déplacer vers le pointeur. Il va donc falloir faire bouger la grille pour créer cette impression de mouvement.

Etudions le cas d’un déplacement suivant l’axe horizontal.

La figure ci-dessous nous montre deux méthodes qui permette de déplacer le personnage de 5 cases vers la droite. Le cadre orange est un repère que nous considérons fixe, il représente ce que l’on voit à l’écran. La première méthode, qui est la plus classique, consiste à déplacer le lutin de 5 cases vers la droite. A la fin de son déplacement, le lutin se retrouve au-dessus du chiffre 5. Maintenant, nous allons faire glisser la grille de 5 cases vers la gauche, sans déplacer le personnage. A la fin du mouvement, le personnage se retrouve aussi au-dessus du chiffre 5. Dans les 2 cas représentés sur la figure, le personnage c’est déplacé de 5 cases.

Nous remarquons que si nous voulons continuer de faire avancer le personnage de 5 cases, dans le premier cas cela ne sera pas possible car, à la fin du déplacement, il se retrouvera hors de l’écran. Avec la méthode utilisant le scrolling, il suffit de continuer à faire glisser la grille pour que le personnage donne l’impression de continuer d’avancer.

Donc, pour simuler le déplacement du joueur vers le droite, nous devrons déplacer la grille vers la gauche.

Il en sera de même pour le déplacement vertical, pour donner l’impression que le personnage va vers le haut, nous déplacerons la grille vers le bas. Pour simuler le déplacement du joueur, il suffira donc de déplacer la grille à l’opposé du pointeur de la souris, nous aurons ainsi l’impression que le joueur se dirige vers la pointeur.

Dans ce projet, le déplacement du personnage seront gérés par le lutin grille.

Pseudo code pour le lutin grille

Lorsque nous chargeons le lutin “lutin_grille_celvolution.svg”, nous remarquons que le grille occupe tout l’écran, si nous la déplaçons sur la droite, par exemple, il n’y aura plus de case sur la gauche. Dans Scratch, il n’est pas possible de charger des arrière-plans plus grand que la taille de l’écran. Heureusement, dans les blocs de type Apparence, nous avons une instruction qui nous permet d’agrandir l’arrière plan, la commande mettre à % de la taille.

abscisse←0 ordonnée←0 Augmenter la taille de la grille Debut Boucle Infinie déplacer la grille à l'opposé du pointeur de la souris Fin Boucle Infinie

Pseudo code pour le lutin joueur

Debut Boucle Infinie taille_joueur←100 Si joueur touche cellule==vrai Alors taille_joueur←taille_joueur+3 Fin Si Si joueur touche AI==vrai Si taille_joueur>taille_AI Alors taille_joueur←taille_joueur+taille_AI Sinon Ecrire "La partie est terminée" Fin Si Fin Boucle Infinie

Le déplacement étant géré par le lutin grille, nous avons juste besoin de tester les collisions avec les cellule et l’AI.

Pseudo code pour le lutin cellule

Les cellules qui apparaissent à l’écran ne bougent pas, elles devront donc suivre les mêmes mouvement que la grille pour donner l’impression d’être immobile par rapport à elle.

abscisse←nombre aléatoire entre -230 et 230 ordonnée←nombre aléatoire entre -170 et 170 Debut Boucle Infinie Déplacer la cellule à l'opposé du pointeur de la souris Fin Boucle Infinie

Pseudo code pour le lutin AI

Le lutin AI ne sera pas immobile. Il pourra se déplacer de façon aléatoire, en suivant un parcours défini ou en fonction des mouvements et de la taille du joueur. Dans cette partie du projet, nous le ferons avancer suivant un parcours prédéfini, il décrira un cercle pendant toute la durée du jeu. Pour que ses mouvements soient bien retranscrits par rapport au lutin du joueur, il faudra, tout d’abord, le déplacer comme la grille et ensuite lui appliquer le déplacement considéré.

abscisse←230 ordonnée←-170 Debut Boucle Infinie Déplacer AI à l'opposé du pointeur de la souris Déplacer AI comme défini Fin Boucle Infinie

Programmation dans SCRATCH

Dans ce projet, nous devons définir deux variables.

taille_joueur : cette variable représente la taille du joueur.

taille_AI : cette variable représente la taille du personnage joué par l’ordinateur.

Code Scratch pour le lutin grille

La grille que nous avons importée a une taille de 480 pixels par 360 pixels, soit la taille de l’écran. Nous devons maintenant l’agrandir pour pouvoir utiliser le scrolling. Dans SCRATCH, nous ne pouvons pas agrandir les lutins au delà d’une certaine limite, or nous voulons augmenter la taille de 1600 % par rapport à la taille originale, ce qui est dessus de la limite pour un costume de 480X360. Il existe une astuce qui permet de passer outre cette limitation. Il suffit de créer un costume 1X1 ne contenant qu’un seul pixel. Pour ce costume, nous pouvons augmenter la taille de 1600 % car il est très petit à la base. Ensuite, il nous suffit de basculer sur le costume contenant la grille et l’augmentation de 1600 % reste active. Nous positionnons la grille au centre de l’écran et la déplaçons de 100 plans en arrière pour être sur que tous les autres lutins seront visibles.

Nous ajoutons une boucle infinie dans laquelle nous inséreront le code qui va gérer les déplacements.

Nous allons maintenant modifier les abscisses et ordonnées du lutin grille en fonction de la position du pointeur de la souris pour créer l’impression de mouvement. Lorsque la souris se trouve au milieu de l’écran (Xsouris=0 et Ysouris=0), la grille ne doit pas bouger. Si nous déplaçons la souris vers la droite (Xsouris=1 → 240), nous devrons déplacer la grille vers la gauche comme nous l’avons vu précédemment. Pour que le déplacement soit de plus en plus plus rapide lorsque le pointeur de la souris se trouve de plus en plus loin du centre, nous décrémenterons l’abscisse de la grille d’une valeur proportionnelle à Xsouris. Nous avons choisir de la décrémenter d’une valeur égale à Xsouris/10. Cette valeur est arbitraire et peut être modifier si vous voulez augmenter ou diminuer la vitesse. Nous faisons de même pour l’ordonnée de la grille.

Si nous laissons le code tel quel, nous allons arriver aux limites de notre grille agrandie, il faut donc arrêter le déplacement avant. Nous fixons la taille limite de la façon suivante :

Limite des déplacements :

-3600 < x < 3600

-2700 < y < 2700

Lorsque l’abscisse de la grille dépasse 3600, nous la ramenons à 3599 et si elle est inférieure à -3600, nous la ramenons à -3599. Nous agissons de la même manière pour l’ordonnée.

Code Scratch pour le lutin cellule

Quand le jeu commence, nous cachons le lutin et nous créons une boucle infinie qui va nous permettre de créer un clone du lutin toutes 2 secondes.

Lorsqu’un clone est créé, nous l’affichons, lui assignons une couleur tirée aéatoire et le positionnons au hasard sur l’écran.

Nous créons une boucle infinie. La cellule doit paraître immobile par rapport à la grille, il faut donc lui appliquer les mêmes mouvements. Ensuite, nous testons si le joueur touche la cellule. Dans ce cas, nous envoyons le message “mangé_par_joueur” et supprimons le clone. Pareillement, nous testons si le lutin AI touche la cellule et nous envoyons le message “mangé_par_AI” et supprimons le clone le cas échéant.

Code Scratch pour le lutin AI

Nous fixons la taille du lutin AI à 110 % pour que le joueur ne puisse pas l’absorber dès le début du jeu et le positionnons dans le coin inférieur droit de l’écran. Nous affectons la valeur taille à la variable taille_AI.

Nous ajoutons une boucle infinie dans laquelle nous insérerons le code qui va gérer le déplacements et les collisions.

Nous avons décidé que, pour le moment, le lutin AI aller tourner en rond pendant toute la durée du jeu. Pour que l’on puisse donner l’impression d’un mouvement circulaire apparent par rapport à la grille, nous allons commencer par déplacer le lutin comme la grille. A ce stade de la gestion du déplacement, le lutin paraît donc immobile par rapport à la grille. Ensuite, nous lui appliquons les mouvements qui font lui donner l’impression de décrire un cercle. Ce mouvement est géré par le nouveau bloc direction circulaire que nous avons créé. Nous verrons sa description dans la suite. Ensuite, nous testons si le joueur touche le lutin AI. Dans le cas où il y a collision, nous testons la taille des deux lutins pour savoir qui va manger l’autre. Si le joueur est plus gros que l’AI, on envoie le message “AI_mangé”, sinon, on envoie le message “joueur_mangé”.

Quand une cellule a été absorbé par le lutin AI, le message “mangé_par_AI” est envoyé. Nous allons donc ajouter un bloc quand je reçois mangé_par_AI auquel nous collons les instructions qui vont faire jouer le son pop et augmenter la taille du lutin de 3.

Nous avons vu que les déplacements sont gérés par un bloc spécial, direction circulaire, que nous avons créé. En effet, Scratch nous permet de créer des blocs qui vont exécuter une série d’instructions. Ceci est particulièrement utile lorsqu’un script est souvent répété. Il suffit d’ajouter un nouveau bloc qui contient la série d’instructions en question. Lorsque nous avons besoin d’exécuter cette série d’instructions, il suffit juste d’utiliser le nouveau bloc que nous avons créé et ceci autant de fois que nous le voulons. Nous n’avons donc pas besoin de récrire tout le script à chaque fois. Dans le cas de notre projet, nous avons ajouté le bloc direction circulaire alors qu’il n’est utilisé qu’une seule fois. Le fait d’ajouter un bloc va nous faciliter la tâche dans la gestion des déplacements du lutin AI. Quand nous voudrons changer son comportement, il suffira de créer un nouveau bloc et de l’insérer à la place de celui que nous avons déjà créé. De plus, si nous ajoutons d’autres lutins contrôlés par l’ordinateur, nous recopierons ces blocs pour gérer les déplacements de ces nouveaux lutins.

Comment créer le bloc personnalisé direction circulaire

Si vous souhaitez créer vous même ce bloc (il est présent par défaut dans le projet) voici la démarche à suivre. Pour créer un nouveau bloc, il suffit de sélectionner la famille Ajouter blocs sous l’onglet script et de cliquer sur le bouton Créer un bloc. Une fenêtre apparaît dans laquelle nous pouvons entrer le nom du bloc que nous voulons créer.

Lorsque nous cliquons sur OK, le nouveau bloc va se placer automatiquement dans la fenêtre de script.

Maintenant, il suffit de placer les instructions que nous voulons exécuter sous ce bloc. Nous faisons tourner le lutin de 1 degré dans le sens des aiguilles d’une montre et avancer de 10 pixels.

Code Scratch pour le lutin joueur

Les déplacements étant géré par le lutin grille, dans le script lié au lutin joueur, nous devons juste gérer la taille du lutin et la fin de la partie.

Au début de la partie, nous plaçons le joueur au centre de l’écran et fixons sa taille.

Si une cellule est absorbée par le joueur, il recevra le message “mangé_par_joueur” qui va déclencher le script permettant de jouer le son pop et d’augmenter sa taille de 3.

Si le joueur mange le lutin AI, on joute la taille du lutin AI à celle du joueur.

Si le joueur est mangé par l’ordinateur, on arrête le programme.

Code Scratch pour le lutin “fin“

Nous avons créé un lutin pour afficher le message “La partie est finie !” en gros au milieu de l’écran lorsque le joueur se fait manger. Ce lutin est caché en début de partie. Lorsque le message “joueur_mangé” est reçu, nous l’affichons au centre de l’écran.

.

.

Projets SCRATCH intermédiaires

Celvolution – jeu – niveau 2

Description du projet

Ce projet fait suite au projet Celvolution niveau 1 que nous allons améliorer. Dans le premier projet, lorsqu’une cellule atteignait le bord de l’écran, il y avait toujours une partie d’elle qui était visible, même si on continuait de s’éloigner d’elle. Nous allons faire en sorte, que lorsqu’elle sort de l’écran, elle disparaisse si on continue de s’éloigner et, bien sûr, si on revient vers la cellule, elle va réapparaitre.

Nous allons aussi ajouter une grille avec un défilement infini, le joueur ne sera jamais bloqué sur un bord. Le système de gestion du scrolling va être complétement refait afin de pouvoir utiliser le lutin grille sans avoir besoin de l’agrandir.

Partie 1 Préparation de l’application et ajout des ressources

Charger le projet Celvolution niveau 1.

Supprimer le script dans le lutin grille.

Info

Dans les ressources du projet, en plus des lutins et de l’arrière-plan, nous avons inclus les codes scratch des 3 versions développées.

Partie 2 Programmation

Masquer les cellules hors de l’écran

Dans Scratch, lorsqu’un lutin arrive au bord de l’écran, s’il dépasse la limite, il reste afficher sur le bord, il ne disparaît pas. Nous allons ajouter un script qui permet de cacher les lutins cellule lorsqu’ils sortent de l’écran.

Nous reprenons le code existant et nous allons ajouter des tests sur l’abscisse et l’ordonnée du lutin. A l’écran, nous pouvons afficher des abscisses qui sont comprises entre -240 et 240. Nous allons fixer les limites d’affichage des lutins entre -235 et 235. Nous gardons une marge de 5 pixels au cas où le centre du costume ne serait pas exactement défini au centre du cercle représentant la cellule.En effet, si le centre du costume est défini trop à gauche, par exemple , lorsque la cellule arrive à la limite droite de l’écran, elle restera affichée, même si on continue de s’éloigner d’elle. Nous allons donc tester si l’abscisse est inférieure à -235 ou si elle supérieure à 235. Dans ce cas, nous cachons le lutin. Nous effectuons la même opération pour les ordonnées, en se donnant comme limite -175 et 175.

Lorsque la cellule sort des limites de l’écran, nous utilisons le bloc cacher pour que celle-ci ne soit plus visible. Il faut donc nous assurer que lorsqu’elle reviendra dans les limites de l’écran, elle soit bien affichée, il faut donc ajouter une instruction montrer. Nous la placerons juste après le calcul x et y.

Scrolling dans les 2 directions

Dans la première partie de ce projet, nous avons utilisé un lutin grille que nous avions agrandi afin de pouvoir implémenter un effet de scrolling pour donner l’impression que le joueur se déplaçait sur cette grille. Cette méthode présente plusieurs inconvénients.

Comme nous avons agrandi l’image de base, il nous sera impossible d’obtenir des lignes plus fines que celles que nous avions sur l’écran du 1er niveau. Les lignes de la grille de départ avait une épaisseur de 1 pixel. Nous avons agrandi le lutin de 1600 %, l’épaisseur des lignes ainsi obtenues sera donc de 16 pixels. Il ne nous sera pas possible d’avoir des lignes plus fines avec cette méthode.

Lorsque l’on agrandi des lutins, il peut apparaître des artefacts inattendus. On peut avoir des lignes qui se décalent, la grille peut ne pas être exactement la même que celle de départ. De plus, si il y a des couleurs sur le lutin, l’agrandissement peut modifier légèrement ces couleurs. Ceci peut être gênant si on effectue ensuite des tests de collisions sur certaines couleurs.

Il est donc recommandé de trouver une méthode plus fiable pour utiliser le scrolling.

Plutôt que d’agrandir la grille de départ, nous allons utiliser plusieurs grilles de la dimension de l’écran que nous ferons défiler. Pour un scrolling vertical, nous utiliserons 3 grilles que nous collerons par leurs bords verticaux. Lorsque nous voudrons effectuer un déplacement vers la droite, nous ferons défiler ces grilles vers la gauche, comme nous le montre la figure ci-dessous. Le cadre orange représente l’écran. Au départ, la grille 2 est centrée sur l’écran et les 2 autres se trouvent hors des limites horizontales de cet écran. Lorsque nous faisons glisser les grilles vers la gauche, la grille 3 va , peu à peu, prendre la place de la grille 2. Lorsque la grille 1 ne sera plus visible à l’écran, nous la déplacerons juste à droite de la grille 3. Ainsi, nous pouvons créer un effet de scrolling infini.

Pour un scrolling vertical, nous procédons de la même manière en collant les 3 grilles par leurs bords horizontaux. Si nous voulons combiner les 2 scrollings, il nous faudra donc 9 grilles.

Cette méthode peut être utilisé avec des éléments qui peuvent être différents. Si nous remplaçons les grilles par des éléments de décors mis bout à bout, nous pourrons obtenir un scrolling dans un tableau qui est plus grand que l’écran. Il suffit juste de créer autant d’éléments qu’il y a besoin pour couvrir la totalité de la surface du tableau.

Pour appliquer cette méthode dans notre projet, nous commençons par effacer le script qui est contenu dans le lutin grille. Ensuite, nous dupliquons le lutin 8 fois afin d’obtenir nos 9 grilles. Dans la première partie du projet, le suivi du pointeur de la souris en vu d’effectuer le déplacement de la grille était fait dans le lutin grille. Maintenant, nous avons 9 grilles, nous allons gérer ce déplacement dans le lutin joueur.

Nous commençons par ajouter 2 variables , defilement_X et defilement_Y qui nous permettront de gérer le scrolling pour les 9 grilles et 2 variables X et Y qui définiront les coordonnées de chaque grille. Il ne faudra pas oublier, pour les variables X et Y, de bien cocher la case pour ce lutin uniquement, et les créer pour chaque lutin. En effet, X et Y seront les coordonnées de chaque grille, nous sommes donc obligé de les déclarer en variables locales.

Lien

Une vidéo tutorielle SCRATCH sur les variables est disponible ici : cliquer

Pour expliquer la méthode, nous allons nous intéresser au scrolling horizontal des grilles 1 à 3. Nous avons, en utilisant le repère de SCRATCH, le schéma suivant (le cadre orange représente toujours l’écran, donc ce qui est visible par l’utilisateur) :

Nous avons, pour les 3 grilles, les abscisses suivantes :

Grille 1 : x=-480

Grille 2 : x=0

Grille 3 : x=480

Nous allons décaler les grilles vers la gauche, jusqu’à ce que l’abscisse de la grille 1 soit égale à -720.

Si l’abscisse de la Grille 1 devient plus petit que -720, nous la déplaçons à droite de la Grille 3, son abscisse prend alors la valeur 720.

Nous pouvons continuer à faire défiler les grilles. Lorsque l’abscisse de la Grille 2 sera inférieure à -720, on lui donnera la valeur 720 pour qu’elle se retrouve à droite de la Grille 1. Nous pouvons continuer ainsi à l’infini.

Pour calculer l’abscisse de la Grille 2, nous utiliserons la formule mathématique suivante :

X = arrondi.inférieur((def_X+720)/1440)*1440 – def_X

La variable def_X représente le scrolling dans le sens horizontal. Comme pour la première partie du projet sa valeur sera proportionnelle à la distance entre le joueur et le pointeur de la souris. Nous lui affecterons la même valeur soit : def_X=-0.1*Xsouris.

En utilisant la formule ci-dessus, lorsque def_X varie de 0 à 720, X varie de 0 à -720, ensuite, lorsque def_X varie de 721 à 2160 (720+1440), X varie de -719 à 720 et ainsi de suite. Nous avons donc :

def_X : 0 → 720 X : 0 → -720

def_X : 721 → 2160 X : 719 → -720

def_X : 2161 → 3600 X : 719 → -720

…

Nous avons donc une formule qui nous donne des valeurs de X qui oscille entre -720 et 720. Nous pouvons donc l’utiliser directement pour positionner la Grille 2. Nous utiliserons la même formulation pour l’abscisse de la Grille 1, il suffit juste d’enlever 480 car le centre de la Grille 1 est à 480 pixels de celui de la Grille 2. Suivant le même principe, pour la Grille 3, nous utiliserons cette formule et nous ajouterons 480. Nous avons donc :

Xgrille1 = arrondi.inférieur((def_X+720)/1440)*1440 – def_X – 480

Xgrille2 = arrondi.inférieur((def_X+720)/1440)*1440 – def_X

Xgrille3 = arrondi.inférieur((def_X+720)/1440)*1440 – def_X + 480

Pour le scrolling vertical, nous utilisons le même raisonnement et nous obtenons :

Ygrille1 = arrondi.inférieur((def_Y+540)/1080)*1080 – def_X – 360

Ygrille2 = arrondi.inférieur((def_Y+540)/1080)*1080 – def_X

Ygrille2 = arrondi.inférieur((def_Y+540)/1080)*1080 – def_X + 360

Avec cette formulation, la valeur de Y oscille entre -540 et 540.

Maintenant, il nous suffit juste de rentrer les valeurs de X et Y pour chaque lutin grille et de les afficher quand elles sont susceptibles d’apparaître à l’écran.

[insérer vidéo2]

Utilisation du théorème de Pythagore

Nous allons utiliser le théorème de Pythagore pour détecter les collision entre le lutin joueur et la cellule AI dirigée par l’ordinateur. A la place du bloc touché?, nous allons utiliser la théorie développé dans le projet “le théorème de Pythagore et les collisions” pour savoir si le joueur a toucher le lutin AI.

Nous commençons par créer une nouvelles variable :

distAI_joueur : cette variable contiendra la distance entre le lutin AI et le joueur qui sera calculée à l’aide du théorème de Pythagore.

Le calcul de la distance entre le joueur et la cellule Ai va se faire grâce à la formule suivante :

Le déplacement est géré par le scrolling de l’arrière-plan, le joueur est fixe au milieu de l’écran, nous avons donc, pendant toute la durée du jeu :

Xjoueur = 0

Yjoueur = 0

Nous obtenons donc :

C’est cette équation que nous allons utiliser pour détecter les collisions entre les deux lutins. Nous ajoutons le code Scratch suivant dans le lutin AI pour calculer la variable distAI_joueur :

Dans Scratch, la taille est gérée par rapport au pourcentage de la taille originale. Pour notre code, nous avons besoin de connaître la taille en pixels de chaque lutin. Nous fixons la taille du joueur à 45 et celle de AI à 55.

taille_joueur = 45

taille_AI = 55

Pour savoir s’il y a contact entre les deux lutins, nous comparerons la distance les séparant avec la somme des tailles des deux lutins divisé par 2. En effet, la taille du lutin représente son diamètre et nous devons comparer la somme des rayons des deux lutins avec la distance les séparant. A la place du test si joueur touché? alors, nous écrirons :

Pour l’affichage du lutin, nous calculons le pourcentage de la taille par rapport à sa taille de départ, ce qui nous donne, pour le lutin AI (sa taille de départ est 55) :

Pour le lutin joueur, nous aurons (sa taille de départ est 45) :

Le code complet pour le lutin joueur devient :

Le code complet pour le lutin AI devient :

Pour aller plus loin :

Vous pouvez appliquer la méthode du théorème de Pythagore pour le lutin cellule.

Vous pouvez améliorer le déplacement du lutin géré par l’ordinateur. Il peut se diriger vers les cellules pour les absorber et essayer de manger le joueur lorsqu’il de vient plus gros que lui.

.

Projets SCRATCH intermédiaires

Un mot pour un autre

Description

Dans ce projet, nous allons créer un petit programme qui demandera les éléments d’une phrase à l’utilisateur : nom, verbe et complément de lieu. Puis nous allons faire réaliser à notre programme un petit jeu d’écriture inspiré de la méthode S+7 de l’OULIPo et l’appliquer au nom et au verbe. Dans un second temps, nous prendrons un complément de lieu aléatoire pris dans une liste afin d’ ajouter un peu de hasard. Le programme affichera alors une nouvelle phrase.

Info

L’OULIPo, abréviation d’ OUvroir de LIttérature Potentielle, fondé en 1960 par un mathématicien , François Le Lionnais, et un écrivain, Raymond Queneau. L’un de ses principes est de produire des travaux d’ écriture en appliquant certaines contraintes formelles comme moteur de créativité. Il propose de nombreux jeux d’écriture alliant littérature et mathématique.

La méthode L + 7

Dans ce petit jeu d’écriture, nous allons prendre la première lettre de notre mot et prendre dans le dictionnaire, non pas le 7eme mot suivant du dictionnaire, mais, un mot du dictionnaire commençant par une lettre +7 dans l’alphabet.

Ex : arbre. La première lettre est a. Dans l’alphabet a+7 sera h. Nous remplacerons donc arbre par un nom du dictionnaire commençant par h.

Le dictionnaire

Comme nous le voyons, il nous faut un dictionnaire. Nous allons devoir en créer un. De manière très générale, un dictionnaire est un ouvrage contenant un ensemble de mots d’une même langue. Nous nous rappelons qu’en programmation nous avons un type de variable qui nous permet justement de stocker un ensemble d’éléments du même type : les tableaux, appelés listes dans SCRATCH. Évidemment, nous n’allons pas créer un vrai dictionnaire. Nous allons nous contenter de deux listes :

une qui contiendra des noms;

et une qui contiendra des verbes (déjà conjugués).

Puisque la base de notre jeu littéraire est de prendre un terme et de le changer avec un terme commençant par sa première lettre + 7, il nous faudra au moins un mot commençant par chaque lettre de l’alphabet dans chaque liste.

Attention

Dans notre liste contenant les noms, nous allons écrire le nom puis l’article. Nous verrons plus tard pourquoi. Par exemple, si nous vous voulons ajouter ” le chat ” à notre liste de noms, nous ajouterons la chaine de caractères “chat le”.

Nous créons 2 listes dans lesquelles nous ajoutons à la main au moins 26 verbes conjugués à la troisième personne du singulier, et au moins 26 noms singuliers.

Info

Nous avons créé 3 listes basiques dans ce projet afin qu’il fonctionne, mais il pourra être intéressant de faire réaliser ces listes aux élèves en leur faisant utiliser un vrai dictionnaire (même si cela relève plus du français que des mathématiques). Ce programme pourrait être réalisé en interdisciplinarité avec un enseignant de français.

Nous allons aussi créer une liste qui contiendra plusieurs compléments de lieux.

Le principe

Maintenant que nous avons nos listes, regardons comment nous allons procéder.

Nous demandons un nom singulier à l’utilisateur (nous allons indiquer que nous souhaitons un nom singulier et ainsi imposer le genre sinon nous devrions faire un programme beaucoup plus complexe) puis nous lui demandons d’entrer un verbe (déjà conjugué au singulier) et un complément de lieux.

Nous stockons ces trois données dans des variables.

Nous prenons la première lettre du nom, nous ajoutons 7 lettres à sa première lettre et remplaçons le nom de départ par un nom commençant par première lettre + 7, pris au hasard dans le dictionnaire.

Nous procédons de la même manière pour le verbe.

Nous prenons un complément de lieux au hasard dans la liste contenant nos compléments de lieux.

Pour finir, nous affichons la phrase de départ composée par le nom, le verbe et le complément de lieux donnés par l’utilisateur et ensuite la phrase une fois transformée par notre programme.

Décomposition d’un mot

Ce projet repose essentiellement sur la manipulation de chaînes de caractères. Le procédé que nous allons suivre est le suivant.

Nous demandons à l’utilisateur d’entrer un nom.

Nous séparons le nom de l’article (nous vous fournissons un bloc SCRATCH prédéfini, nous n’aurez donc pas à le programmer).

Nous le stockons dans une variable que nous appellerons nom_depart. Cette variable sera de type alphanumérique.

Nous prenons la première lettre de ce nom.

Nous regardons dans l’alphabet quelle est la lettre correspondant à cette lettre + 7.

Nous cherchons dans notre dictionnaire les noms commençant par cette lettre, et nous en prenons un au hasard.

Les 4 premières étapes sont relativement simples et pourraient être transcrites ainsi:

//nous créons nos variables nom_depart←"" Afficher "rentrer un nom singulier (par exemple le chat)" Lire nom_depart nom_depart←nom_depart séparé de l’article

Dans SCRATCH, nous programmerons cela ainsi (nous utilisons le bloc préalablement livré avec le projet):

Lettre + 7

Nous abordons un point plus épineux, prendre notre première lettre et trouver dans l’alphabet quelle est la 7ème lettre après celle-là. Voyons comment nous allons programmer cela.

Nous allons tout d’abord créer une variable alphabet qui contiendra toutes les lettres de l’alphabet (dans l’ordre). Cette variable sera de type alphanumérique.

Nous avons notre chaîne de caractères qui contient donc 26 caractères. Le premier est la lettre a , le second la lettre b, le troisième la lettre c, etc…

Dans SCRATCH, nous pouvons identifier une lettre dans une chaine de caractère, suivant sa position dans cette chaine, grâce au bloc de type opérateur suivant :

Nous allons donc pouvoir identifier facilement nos lettres de l’alphabet grâce à leur indice de position dans notre variable alphanumérique alphabet.

Nous allons donc avoir le raisonnement suivant :

Nous créons une variable premiere_lettre et lui affectons comme valeur la première lettre du nom entré par l’utilisateur.

Soit un compteur égal à 1, jusqu’à que ce que notre variable premiere_lettre soit égale à la lettre numéro compteur de variable alphabet, on incrémente le compteur de 1.

Nous utilisons donc une boucle et une expression booléenne.

Ainsi, si notre variable premiere_lettre est, par exemple, égale à c :

Au premier passage, compteur vaut 1, la lettre 1 de la variable alphabet est a. L’expression “c”==“a” renvoie faux;

Au second passage, compteur vaut 2 , la lettre 2 de la variable alphabet est b. L’expression “c ”==“b” renvoie faux;

Au troisième passage, compteur vaut 3, la lettre 3 e la variable alphabet est c. L’expression “c”==“c” renvoie vrai. Notre condition est remplie, notre boucle s’arrête.

A ce stade de notre raisonnement, nous savons que la lettre par laquelle commence le nom rentré par l’utilisateur est la lettre numéro compteur de la variable alphabet. A partir de là, trouver la 7ème lettre suivante est assez simple : la lettre numéro compteur + 7 est celle nous voulons. Nous la stockerons donc dans une variable que nous nommons lettre_7.

Dans SCRATCH cela nous donnera ceci :

Recalculer le compteur

Mais que se passe-t-il si notre première lettre n’est non plus c, qui avait pour position 3, mais v (si l’utilisateur rentre “la voiture” par exemple), qui aura pour position 22 ? Notre programme affectera à lettre_7 la lettre en position 29 de la variable alphabet (22+7). Or cette lettre n’existe pas !

Il va donc nous falloir recalculer notre compteur pour revenir au début de notre chaine de caractère dès que l’on arrive à 26, c’est-à-dire à la lettre z.

Pour cela, un test et un simple calcul suffisent : si compteur +7 est plus grand que 26, nous mettons notre compteur à compteur+7 moins 26, soit le nombre total de lettre de l’alphabet.

Si compteur+7>26 Alors compteur←compteur+7-26 Fin Si

Utilisation du dictionnaire

Nous avons notre lettre+7 dans notre variable lettre_7. Nous arrivons maintenant à l’étape où nous devons chercher dans notre dictionnaire les noms commençant par cette lettre et en prendre un au hasard.

Pour réaliser cela, nous allons utiliser des tableaux/listes et une boucle.

Lien

Pour rappel, parcourir un tableau/liste avec une boucle est expliqué dans la ressource théorique suivante: Des boucles,des tests et les manipulations de tableaux

Le cheminement sera le suivant :

Nous allons parcourir notre liste/tableau contenant les noms que nous avons créé, prendre dedans tous les noms commençant par notre lettre_7 et les stocker dans une nouvelle liste/tableau que nous appellerons nouveaux_noms_possibles en réalisant le test suivant:

Note

Lorsque nous avons constitué notre listes noms, nous avons pris soin de mettre le nom avant l’article pour pouvoir faire cette manipulation. En effet avons besoin de comparer la première lettre de chaque nom. La manipulation des chaînes de caractères étant tout de même assez réduite dans SCRATCH, placer le nom avant l’article est la méthode la plus simple pour accéder facilement à la première lettre de chaque élément contenu dans une liste.

Tableau nouveaux_noms_possibles() Pour compteur 1 à 26 Si lettre 1 de Tableau noms[compteur]==lettre_7 Alors Ajouter Tableau noms[compteur] dans Tableau nouveaux_noms_possibles Fin Si Fin Pour

A la fin de cette boucle, tous les mots contenus dans notre dictionnaire de noms commençant par la lettre contenue dans lettre_7 seront des éléments du tableau/liste nouveaux_noms_possibles. Nous n’aurons plus qu’à en prendre un au hasard et à le stocker dans une variable que nous appellerons nom_fin et à remettre le nom et son article dans le bon ordre (pour cela nous avons également codé un bloc SCRATCH prêt à l’emploi).

Le verbe

Nous utiliserons la même procédure (à ceci près que nous n’aurons pas à nous soucier de l’article) et stockerons le résultat dans une variable que nous appellerons verbe_fin .

Le complément de lieu

Nous avons une liste/tableau contenant différents complément de lieux. Nous allons donc définir une nouvelle variable que nous nommerons complement_fin et lui affecter un des éléments de cette liste pris au hasard.

Construction de la phrase finale

Nous avons maintenant tous nos nouveaux éléments à l’issue de notre jeu d’écriture sous forme de variables alphanumériques. Il ne nous reste qu’à opérer une concaténation de chaînes pour avoir notre phrase finale.

phrase_finale←nom_fin+" "+verbe_fin+" "+complement_fin Ecrire phrase_finale

.