Introduction à SCRATCH

Présentation

SCRATCH est un langage de programmation visuel. Il a été conçu par le MIT pour apprendre à coder facilement, dès un âge assez jeune. Ce langage ne demande pas de taper des lignes de code, comme dans un langage classique, mais repose sur des blocs d’instructions que l’on emboite les uns dans les autres dans l’éditeur de l’application SCRATCH.

Voici à quoi ressemble un exemple de blocs :

Info

Pourquoi le langage s’appelle SCRATCH!

Les concepteurs de ce langage se sont inspirés des DJ de musique hiphop qui utilisent ce que l’on appelle le scratching qui consiste à prendre des bouts de séquences de musiques et sons et à les mixer pour créer de nouveaux morceaux. SCRATCH permet donc de créer des programmes en mixant des blocs de séquences !

Installer et lancer SCRATCH

Pour coder avec le langage SCRATCH il faut utiliser l’application du même nom. Elle est entièrement gratuite et est disponible de deux façons :

En ligne dans votre navigateur. Pour cela il faut donc avoir internet. Vous devez créer un compte (gratuit également) et c’est parti pour faire vos programmes directement dans votre navigateur. Tous les programmes que vous ferez pourront être sauvegardés dans votre compte et accessibles à tout moment.

Comment créer un compte : rendez-vous sur https://scratch.mit.edu/ et cliquez sur rejoins SCRATCH

Attention

La version actuelle de SCRATCH en ligne (2017) ne fonctionne pas sur périphériques mobiles, tablettes ou téléphone.

Hors-ligne sur votre ordinateur avec le logiciel SCRATCH 2. Avant d’installer SCRATCH 2 il vous faut installer l’application Adobe AIR ( lien ci-dessous ). Puis téléchargez SCRATCH2 sur le site de SCRATCH ( lien ci-dessous ) et installez le. Il suffira alors de le lancer en double cliquant sur l’icône qui sera au bureau de votre ordinateur.

Récapitulatif des deux versions

Présentation de l’interface

L’interface de SCRATCH est identique quelle que soit sa version : hors-ligne (l’application SCRATCH2) et en ligne (sur le site http://scratch.mit.edu/).

Cette interface est découpée en plusieurs parties distinctes. De manière générale, nous avons:

à droite tout ce qui concerne l’affichage de ce qui sera programmé et les éléments qui seront affichés (les lutins),

à gauche tout ce qui concerne la programmation proprement dite : les blocs d’instructions du langage SCRATCH et l’espace de travail où se trouvera le programme lui-même.

Voici un schéma d’ensemble:

Les différents panneaux de l’interface SCRATCH

Le menu général

Situé en haut (voir schéma ci-dessus), il permet de gérer plusieurs options et outils.

 Changer la langue

(1) en cliquant sur l’icône représentant le petit globe terrestre vous pouvez changer la langue de l’interface, et choisir celle qui vous convient. Par défaut lors de l’installation la langue utilisée est l’anglais. La première chose que vous ferez lors de premier lancement de l’application sera donc de mettre l’application en français à l’aide de ce bouton. Une fois la langue changée elle sera la langue par défaut de l’interface tant que vous ne changerez pas à nouveau.

Menu d’options

(2) Le bouton fichier permet de gérer les fichiers, c’est à dire créer de nouveaux projets, enregistrer le projet en cours, ou ouvrir un projet déjà existant.

(3) Le bouton Editer permet de changer la taille de la scène et d’activer le mode turbo (nous en parlerons beaucoup plus tard, il s’agit d’une option qui n’est pas indispensable)

(4) Le bouton Aide, si vous êtes perdus ou ne savez pas comment faire quelque chose, vous trouverez de l’aide sur plusieurs sujets concernant SCRATCH. Malheureusement la plupart sont rédigés en anglais.

Menu d’outils

(5) Le tampon permet de copier un lutin ou un script

(6) Les ciseaux permettent de supprimer un lutin ou un script

(7) Outil pour agrandir un lutin présent sur la scène

(8) Outil pour diminuer la taille d’un lutin sur la scène

(9) Permet d’obtenir des informations sur un bloc spécifique

Les fenêtres de droite

Elles concernent l’affichage des programmes et les éléments graphiques qu’ils contiennent. Elles comportent :

La scène. C’est un peu comme un mini écran ! C’est là où le programme que l’on code va s’exécuter.

En dessous nous avons une fenêtre qui contient tous les lutins que l’on va utiliser dans notre programme. Un lutin est un élément graphique auquel on donne des instructions.

Une fenêtre où nous allons pouvoir ajouter et modifier les arrières plans. Un arrière-plan est une image qui sera toujours à l’arrière-plan sur la scène.

Les fenêtres de gauche

Elles contiennent les blocs d’instructions du langage SCRATCH, ainsi que les espaces de travail où l’on va pouvoir programmer.

On y trouve 3 fenêtres auxquelles on accède par 3 onglets : La fenêtre script, la fenêtre costume et la fenêtre sons.

La fenêtre script contient d’une part les blocs du langage scratch et d’autre part l’espace de travail dans lequel on va pouvoir écrire notre programme à l’aide des blocs. Ces blocs sont classés par type. Chaque type permet de programmer différents aspects et fonctions des lutins. Par exemple les blocks de type mouvements permettront de programmer les mouvements des lutins sur la scène, de différentes manières.

Chaque bloc peut être attrapé à l’aide de la souris pour être déposé dans la fenêtre de droite qui contiendra le programme proprement dit.

Les blocs que l’on place dans cet espace de travail peuvent s’encastrer les uns dans les autres et ainsi construire des suites d’instructions.

La fenêtre costume. C’est dans cet espace que nous allons pouvoir modifier l’apparence des lutins. Un costume est une image qui représente un lutin dans un état particulier. Un lutin peut donc avoir plusieurs costumes. Faire différents costumes pour un lutin va donc nous permettre de l’animer. L’éditeur graphique de SCRATCH nous permet de dessiner des lutins directement dans l’application. Il est également possible d’en importer depuis la bibliothèque ou depuis son ordinateur.

La fenêtre son. Nous pourrons y enregistrer ou importer des sons que nous utiliserons dans nos programmes grâce aux blocs de type son.

Ajouter un lutin – faire son premier programme

Les lutins

Les lutins sont les composants essentiels de tout programme SCRATCH. En effet chaque programme est constitué : de lutins et de scripts qui les contrôlent et leur donnent des instructions.

Définition : un lutin est donc une ressource graphique qui peut être programmée avec des blocs.

Créer un lutin dans un projet

Il existe plusieurs façons de créer un lutin dans un programme SCRATCH. La création de lutin se fait dans la fenêtre qui contient la liste des lutins (voir ressource précédente) à l’aide du menu que l’on peut voir sur la figure 1 (ci-dessous). Chaque icône correspond à une méthode de création et nous allons les voir dans l’ordre.

1 – Choisir un lutin depuis la bibliothèque :  SCRATCH propose une large bibliothèque de lutins prêts à être utilisés dans vos projets. Elle s’ouvre lorsque l’on clique sur ce bouton. Les lutins peuvent être filtrés par catégorie (animaux, choses, gens, etc) et par thèmes (ville, sports, musique, etc). Il suffit de choisir le lutin que l’on souhaite ajouter, puis de cliquer sur OK, et le lutin est ajouté à la liste des lutins disponibles dans le projet.

2 – Dessiner un nouveau lutin : comme nous l’avons vu dans la présentation de l’interface, SCRATCH possède un petit éditeur graphique intégré que l’on ouvre avec l’onglet costume. Il dispose d’outils de base permettant de dessiner librement avec un crayon, de faire des lignes, des formes géométriques, écrire du texte, et dispose d’un pot de peinture pour remplir avec des couleurs. Le choix des couleurs de dessin se fait avec la palette.

On peut également modifier un lutin déjà existant.

3 – Importer un lutin depuis un fichier : il est également possible d’importer n’importe quelle fichier image que l’on a déjà dans son ordinateur. Par exemple Educode fourni les ressources graphiques avec tous les projets SCRATCH présents sur le site.

4 – Enfin on peut créer un lutin en prenant un cliché avec sa webcam (si l’ordinateur qu’on utilise en a une)

Notre premier programme

Une fois notre lutin créée, nous pouvons le programmer.

Nous allons faire un petit jeu, en utilisant très peu de commandes.

Pour ce programme nous allons importer un lutin depuis notre ordinateur.

Nous allons commencer par donner un nom à notre lutin. Pour cela nous le sélectionnons dans la liste des lutins, et nous voyons qu’un petit bouton bleu avec un I se trouve à côté de la vignette. Cliquons dessus. Nous voyons que ce panneau nous indique plusieurs informations concernant notre lutin. Pour le moment occupons nous seulement du nom. Nous allons renommer notre lutin et l’appeler “lutin fusée”.

Maintenant nous allons créer notre premier programme et demander à ce lutin de se déplacer sur la scène et de suivre le pointeur de notre souris sur la scène.

Nous ouvrons les blocs de type mouvements, et prenons le bloc s’orienter vers pointeur de souris, et le bloc avancer de 10. Nous les encastrons l’un en dessous de l’autre.

Nous voilà avec notre premier groupe d’instruction. Si nous lançons notre programme en cliquant sur le drapeau vert, il ne se passe… rien ! en effet, à aucun moment nous n’avons dit dans notre programme quand il devait s’exécuter. Nous allons dans les blocs évènements, prendre le bloc ‘quand drapeau vert est cliqué’. Nous le mettons comme première instruction pour dire que nos instructions vont s’exécuter après cet évènement. Si nous cliquons maintenant sur le drapeau vert nous voyons que notre fusée se déplace bien en direction du pointeur de 10 pixel, mais une seule fois seulement à chaque click !

Nous souhaitons que cela se fasse tant que le programme est lancé (donc dans qu’on ne l’a pas arrêté, c’est-à-dire tant qu’on a pas appuyé sur le bouton rouge). Nous allons donc dans les blocs de types contrôle, et prenons le bloc répéter indéfiniment. Nous mettons nos instructions s’orienter et avancer à l’intérieur. Essayons, et nous voyons que notre fusée suit maintenant bien notre pointeur de souris !

Ajoutons un arrière-plan pour aller avec notre programme. L’ajout d’un arrière-plan est absolument identique à celui d’un lutin. Depuis la bibliothèque, depuis l’éditeur, depuis son ordinateur ou avec la webcam.

Nous avons maintenant fait notre premier mini programme. Avec seulement 4 blocs et 2 images. Nous pourrons aller plus loin en ajoutant par exemple des lutins ennemis à éviter !

Les costumes – changer de costume et animer un lutin

Nous avons vu brièvement lors de la présentation des lutins et de l’éditeur dessin de l’interface, qu’un lutin pouvait avoir plusieurs costumes.

Un costume est une image d’un lutin dans un état ou une pose particulière. Par conséquent, lorsque l’on souhaite changer l’image d’un lutin au cours d’un programme (le faire marcher, exploser, changer de couleur, etc) on doit changer son « costume »

Les bases de l’animation

Avant de voir comment accomplir cela dans SCRATCH, intéressons-nous tout d’abord au fonctionnement d’une animation à proprement parler. De manière générale, une animation est une succession  plus ou moins rapides d’images fixes qui donnent l’illusion d’un mouvement.

La marche du robot

Prenons un exemple avec les images fixes suivantes :

Nous avons 6 images qui décomposent les étapes d’un petit robot en train de marcher. Chacune représente un cliché en quelques sortes.

Maintenant faisons les succéder très rapidement :

Nous avons bien l’illusion qu’il marche !

Animer un lutin

Note : toutes les manipulations expliquées ci-dessous sont réalisées en temps réel dans la vidéo disponible au début de cette ressource.

Maintenant voyons comment réaliser la même chose dans SCRATCH. Nous avons nos 6 images dans notre ordinateur (lien vers les ressources disponibles en bas de page). Nous créons un lutin à partir de la première image.

Ajoutons les costumes

Maintenant passons à la fenêtre costumes. Nous avons pour le moment un seul costume, notre image de base. Nous voyons un petit menu pour ajouter des costumes. Il est exactement le même que celui qui nous permet d’ajouter un lutin ou un arrière plan. Ajoutons notre 2ème cliché comme nouveau costume. Puis toutes nos images.

Lorsque nous avons nos 6 costumes, animons le robot !

Programmons l’animation

Pour cela, il faut revenir  à la fenêtre script.

Tout d’abord, comme toujours en programmation, demandons nous ce que nous souhaitons faire : nous souhaitons animer notre robot, c’est-à-dire que les images de ses costumes se succèdent sur la scène les unes après les autres, et ce suffisamment vite pour créer l’illusion du mouvement de marche.

Regardons les blocs de type apparence :  nous avons un bloc qui s’appelle costume suivant.

Il va nous permettre de passer d’un costume à l’autre. Nous allons programmer notre lutin de la manière suivante : qu’il change de costume en allant au costume suivant, indéfiniment. Ainsi il affichera le costume 1 , puis le 2, le 3 jusqu’au dernier, et il recommencera. Nous devrions donc avoir notre animation !

Il est également possible de choisir le costume vers lequel on veut basculer (et non plus le costume suivant de manière linéaire) avec le bloc basculer sur le costume

Si nous lançons le programme nous voyons que ça fonctionne , mais que c’est un peu trop rapide. Nous allons donc ajouter une instruction de type contrôle afin qu’il y ait un petit temps d’ attente entre chaque costume. Pour cela nous prenons le bloc attendre. Définissons notre temps d’attente à 1 dixième de seconde, soit 0.1 seconde. Cela devrait nous donner une animation plus fluide.

Maintenant demandons à notre lutin d’avancer de 10 tout en s’animant à l’aide d’un bloc mouvement.  Notre lutin  marche !

Nous venons de voir comment animer un lutin en modifiant ses costumes et sa position. Il est possible avec SCRATCH de faire de vrais petits dessins animés en utilisant ces simples instructions. Tout n’est plus qu’une question d’imagination et de dessins de costumes et de lutins ! Ces derniers peuvent être dessinés dans l’éditeur de SCRATCH mais aussi avec d’autres logiciels de création graphique (comme Paint par exemple). Vous pouvez également utiliser des photos prises avec votre webcam.

Télécharger les costumes du lutin

Les boucles simples – répéter des instructions

En algorithmique informatique une boucle est un morceau de programme, donc une ou plusieurs instructions, qui se répète autant de fois qu’on le souhaite. On a la possibilité de faire des boucles dans tous les langages de programmation.

Nous avons les types de boucles suivant : la boucle infinie, la boucle avec compteur, et la boucle tant que. Chacune est expliquées dans la série suivante : Algorithmique – partie 2

Dans SCRATCH, la série de blocs qui permet de réaliser des boucles se trouve dans les blocs de type contrôle.

Comme on le voit les blocs de types boucles sont un peu différent des autres. Ils sont un peu en forme ce c .C est pour que l’on puisse mettre d’autre blocs à l’intérieur.

Le principe est simple, tous les blocs d’instructions qui sont placés à l’intérieur d’un bloc boucle sont répétés autant de fois que la boucle le demande. Voyons les différents types de boucles.

Les boucles infinies

Une boucle infinie est une boucle qui ne s’arrête jamais. Dans SCRATCH on la programme avec le bloc répéter indéfiniment. Toutes les instructions qui seront placées à l’intérieur seront répétées indéfiniment….

Les boucles avec compteur

Une boucle avec compteur est une boucle qui s’exécute un nombre de fois que l’on définit numériquement. Par exemple on peut décider de répéter une boucle 3 fois.

Les boucles Tant que

Enfin, en algorithmique nous avons les boucles tant que. Ces dernières s’exécutent tant qu’une condition booléenne est ou n’est pas remplie. Une condition booléenne est une condition qui est soit vrai soit fausse.  Dans SCRATCH étrangement le tant que a été changé en jusqu’à et toutes les instructions comprises à l’intérieur du bloc seront exécutées jusqu’ à ce que la condition indiquée dans le bloc soit remplie.

Les boucles imbriquées

Nous avons vu les différents types de boucles, mais nous pouvons aussi mettre des boucles dans des boucles et programmer des séquences plus complexes tout comme dans l’exemple de notre robot utilisé dans la vidéo ci-dessus. (voir vidéo)

Utiliser le stylo – dessiner avec un lutin

Chaque lutin dispose d’un stylo qui lui permet de dessiner sur la scène. Il est donc possible avec SCRATCH de réaliser des dessins, des figures géométriques, etc. en utilisant le lutin comme un stylo que l’on déplacerait sur une feuille de papier.

La famille de blocs qui permettent au lutin de dessiner et de contrôler le stylo s’appelle logiquement stylos, et ses blocs sont de couleur vert bouteille (nous verrons que les blocs permettant de réaliser des opérations arithmétiques sont eux vert pomme).

Dessiner sur la scène

Comme toujours en programmation chaque action doit être détaillée et donnée à être exécutée. Regardons ce qui se passe lorsque l’on souhaite écrire dans le monde réel :

nous prenons un crayon,

puis nous le posons sur le papier,

nous réalisons l’écriture à proprement parler

et nous relevons notre crayon du papier !

Dans SCRATCH c’est exactement la même chose:

pour utiliser le stylo il faut d’abord se mettre en position pour écrire sur la scène, grâce au bloc d’instruction stylo en position d’écriture.

Une fois que le stylo est en position, tout déplacement du lutin sur la scène sera celui de son stylo en train de dessiner.

Une fois que ce que l’on veut dessiner est réalisé il faut relever le stylo, comme on le ferait avec un vrai crayon. Sinon l’ordinateur continuera à dessiner à chaque nouveau mouvement.

Prenons un exemple simple et dessinons un carré. Nous créons un lutin, ici une tortue (en hommage au premier langage d’apprentissage qui apprenait à dessiner à l’écran avec une tortue, le logo ! )

Puis nous allons dire à notre tortue de dessiner un carré de 80 pixels de coté (le pixel est l’unité de mesure sur un écran).

Comment fait-on un carré ? il va falloir l’expliquer à notre lutin.

Un carré est un quadrilatère qui a 4 cotés égaux et 4 angles droits. Un angle droit est de 90 degrés. Donc nous allons :

Avancer de 80, nous avons notre premier coté,

tourner de 90 degrés pour créer un angle droit

puis avancer à nouveau de 80, nous avons notre 2eme coté, tourner de 90 degrés pour créer un angle droit

puis à nouveau avancer de 80 et tourner de 90 degrés et encore une dernière fois.

Voilà, nous avons carré. (voir la réalisation de ce programme dans la vidéo ci-dessus)

Si nous regardons les étapes de notre programme on voit que l’on fait plusieurs fois la même chose : avancer de 80 et tourner de 90 degré. Et nous avons vu dans la vidéo précédente que nous disposons d’instructions qui peuvent justement répéter des instructions : les boucles.  C’est le moment d’utiliser une boucle avec compteur et de répéter 4 fois avancer de 80 et tourner de 90, ainsi nous réalisons un programme avec moins de blocs, et plus optimisé!

Les blocs pour la mise en forme du stylo

Il existe d’autres blocs qui permettre d’appliquer un style ou une couleur au trait du stylo.

Changer la couleur du trait

Ce bloc permet de changer la couleur du trait du stylo, dès que l’on sélectionne ce bloc le pointeur de la souris se transforme automatiquement en pipette permettant de choisir n importe quelle couleur qui se trouve à l’écran et de la sélectionner en cliquant dessus.

Changer l’ intensité du trait d écriture et la taille du trait

Utiliser un tampon comme motif

Le lutin peut également être utilisé comme motif de tampon avec la commande « estampiller ». A chaque fois que l’on “estampille” c’est comme si l’on tamponnait sur la scène le dessin (ou photo, etc) que représente le lutin.

Effacer l’écran

Enfin si nous souhaitons effacer ce qui a été dessiné nous utilisons le bloc effacer tout. Si nous le plaçons en tête de notre programme il nous permet d’effacer ce qui a été dessiné précédemment et qui est toujours présent sur la scène.

Les variables – créer et utiliser une variable

En programmation une variable est comme une boite dans laquelle on peut stocker une information. On  utilise les variables pour conserver des données comme le score d’un joueur, le nom d’un utilisateur ou la vitesse d’un lutin par exemple.

Nous voyons plus en détail ce qu’est une variable en algorithmique informatique dans notre série 1 – introduction à l’algorithmique informatique.

Pour créer une variable dans SCRATCH, nous utilisons les blocs de type données (voir image ci-dessous). Lorsqu’une nouvelle variable est créée, un nouveau bloc apparait dans la liste de blocs données, prêt à être utilisé.

Créer une variable

Nous allons reprendre une ressource précédente où nous avions programmé un petit robot pour qu’il marche indéfiniment de long en large de la scène et lui ajouter une variable.

Pour créer une variable il faut d’abord cliquer sur le bouton créer une variable, une fenêtre apparait et nous demande de lui donner un nom. Le choix du nom est complètement libre, mais il est vraiment conseillé de lui donner un nom qui nous permettra de nous rappeler ce à quoi elle correspond et ce qu’elle va faire dans notre programme.

Attention

Dans SCRATCH il n’y a pas de règle d’écriture pour les noms de variables, ils peuvent contenir des accents ou des espaces. Mais ça n’est pas le cas dans la plupart des langages de programmations qui ont eux des règles assez strictes.

Nous allons appeler notre variable « vitesse » car elle va nous servir à définir la vitesse de notre petit robot en train de marcher.

Ensuite il faut choisir si l’on veut que notre variable soit accessible seulement par notre lutin, ou par tous les lutins du programme. La plupart du temps nous choisirons tous les lutins, mais cela dépendra des programmes. Puis, on clique  sur le bouton ok.

Notre variable est créée et son bloc est maintenant disponible. De nouveaux blocs ont également apparus. Ils vont permettre de modifier les variables du programme : leur donner une valeur ou bien changer leur valeur. Un petit menu sous forme de liste permet de choisir sur chaque bloc à quelle variable on veut appliquer ces instructions. Dans notre exemple nous n’avons crée qu’une seule variable donc il n’y a qu’un seul choix.

Maintenant que nous avons notre variable vitesse, nous allons lui donner sa valeur.

Nous allons lui donner pour valeur 1.

Et nous allons dire à notre robot d’avancer non plus de 10, mais de la valeur vitesse, donc de 1. Pour cela nous prenons notre  bloc vitesse et nous le posons à la place de la valeur 10.

Lançons le programme. Le robot avance de 1 à chaque passage de la boucle, ce qui est tellement peu qu’on a presque l’impression qu’ il fait du sur place.

Modifier une variable

Maintenant nous allons modifier notre variable vitesse à chaque nouveau passage de la boucle et lui ajouter 1 dès que le robot aura avancé. Notre vitesse va alors augmenter à chaque passage et devenir de plus en plus grande, Elle sera de 1 puis de 2 puis de 3, etc.

Info

Afficher en permanence la valeur d’une variable sur la scène

Si l’on coche la case à coté de notre bloc variable, sa valeur sera visible dans un petit carré en haut de la scène. On peut d’ailleurs choisir de le déplacer. Ainsi nous allons pouvoir voir les changements de valeur de notre variable vitesse. Il est également possible de choisir d’afficher ou non les variables sur la scène avec les blocs suivants:

Lançons le programme et regardons ce qui se passe : le robot avance, de plus en plus vite et de plus en plus vite ! En théorie cela devrait être indéfini mais à un moment cela ira trop vite pour SCRATCH qui se mettra à dysfonctionner, ou comme on dit en informatique à bugger.

Si l’on arrête le programme et qu’on le relance, on voit qu’il recommence depuis le début puisque notre première instruction est de donner la valeur 1 à notre variable vitesse. A chaque lancement de programme notre robot commencera donc toujours à avancer avec une vitesse de 1.

Renommer une variable

Si l’on souhaite renommer une variable, il suffit de se placer sur le bloc qui la représente, de cliquer avec le bouton de droit de la souris et de choisir renommer

Supprimer une variable

De même si l’on veut la supprimer on clique droit avec la souris et l’on choisit supprimer. Scratch ne supprimera pas une variable qui est en cours d’utilisation dans un programme. Si l’on relance le programme on voit que notre bloc variable réapparait.

Conclusion

Nous venons de créer notre première variable. En programmation Les variables sont essentielles. Ce sont elles qui permettent de réaliser des programmes le simple calcul immédiat, et de faire de vraies applications.

Faire des calculs avec les blocs opérateurs

Pouvoir réaliser des calculs est fondamental en programmation, que ce soit pour manipuler des variables ou faire des algorithmes. Nous pouvons réaliser dans SCRATCH toutes sortes d’opérations en utilisant les blocs de types opérateurs. Ces blocs sont de couleurs vert pomme.

Les opérations arithmétiques de base

Il y a 4 blocs pour réaliser des calculs arithmétiques de base :

Le bloc addition qui permet de réaliser une addition entre 2 chiffres que l’on rentre soit même ou des variables.

Sur le même principe nous avons le bloc soustraction,

Le bloc pour faire des multiplications,

Et le bloc pour faire des divisions.

Que fait-on du résultat ?

Faire une opération est une chose mais comment que fait-on du résultat obtenu ?

Nous pouvons soit :

L’afficher. Pour cela nous pouvons utiliser les blocs de type apparence dire ou penser , et un lutin affichera le résultat dans une bulle au-dessus de lui.

Le stocker dans une variable.

Programme pour calculer une moyenne

Pour mettre tout cela en pratique nous allons faire un programme qui va nous permettre de calculer une moyenne de note et d’afficher ce résultat à l’écran.

Prenons les notes de math de Julia : elle a obtenu 12 et 10.

Le calcul de sa moyenne sera 12+10 divisé par le nombre de notes, 2

Pour cela nous allons créer 2 variables : une qui va contenir la somme des notes, et une qui va contenir le calcul de la moyenne, soit la somme divisée par 2.

Nous les appelons somme  et une que nous appelons moyenne.

Nous prenons notre variable somme et nous lui affectons comme valeur, la somme de nos notes en utilisant le bloc opérateur de type addition

Maintenant que nous avons notre somme nous prenons la variable moyenne et nous lui affectons le résultat du calcul somme, contenu dans notre variable somme divisée par 2

Puis nous demandons à Julia de nous dire le résultat.

Le programme sera le suivant (ce programme est réalisé dans la vidéo présente en haut de page):

Pourquoi utiliser des variables plutôt que faire afficher directement les opérations ?

D’abords parce qu’on le voit déjà avec ce calcul simple on fait une très longue ligne de code, donc imaginons un calcul plus long, si par exemple nous avions 10 notes. Et le code final ne serait pas très lisible.

Mais surtout si nous voulons faire évoluer notre programme, par exemple Julia vient d’avoir un 20 en programmation SCRATCH en math ! il nous suffit d’ajouter à notre variable la note 20 et changer notre diviseur et non pas de tout récrire tout le calcul

Allons même un peu plus loin, dans ce programme nous rentrons les notes directement dans le programme, mais si nous voulons faire un programme qui demande à l’utilisateur de rentrer des notes, nous devrons utiliser les variables pour pouvoir ensuite faire le calcul. Nous verrons cela dans la ressource sur les blocs capteurs qui nous permettront de demander des informations à l’utilisateur.

Les nombres aléatoires

Nous avons également un bloc « nombre aléatoire » qui va nous permettre de choisir un nombre au hasard entre 2 valeurs que nous définissons. Les nombres aléatoires sont fréquemment utilisés dans la programmation de jeu.

En exemple vous pouvez voir la programmation d’un jeu de « Boule Magique 8 » dans la vidéo en début de page. Ce jeu consiste à penser à une question et à demander la réponse à la boule qui l’affiche. Dans sa version originale la boule était une boule de billard N°8 d’où son nom. Il repose sur le hasard le plus total et sur un choix aléatoire entre plusieurs réponses qui sont soit positive, soit négative, soit ni positive, ni négative.

Voilà nous avons vu comment réaliser des calculs avec les blocs opérateurs. Il existe d’autres blocs de calculs un peu plus complexes et nous les verrons dans une ressource ultérieure.

Coordonnées, pixels et rapport orthonormé

Les coordonnées sur la scène

La position des lutins

Lorsque l’on crée un lutin, il apparait automatiquement sur la scène. Dans un programme, si l’on souhaite le localiser ou bien le déplacer à un endroit particulier il va nous falloir récupérer ou indiquer sa position sur la scène. Pour cela nous allons utiliser ses coordonnées.

Pour comprendre comment utiliser les coordonnées des lutins dans Scratch regardons tout d’abord à quoi correspond la scène.

Scène, affichage, et pixel

Comme nous l’avons vu lors de la présentation de SCRATCH, la scène est comme un mini écran qui va afficher ce que l’on programme. La scène peut être représentée comme une grille qui est entièrement composée de pixels, ou points. Cette grille fait 480 pixels de large et 360 pixel de haut.

Regardons en gros plan pour voir ce que cela donnerait :;

La scène est donc comme un repère du plan et les coordonnées sont une paire de nombre qui correspondent à un point ou pixel.

La première coordonnée, x, est la position du sur l’axe horizontal(ou l’axe des abscisses).

La seconde , y, est la position sur l’axe vertical (ou l’axe des ordonnées).

Le point d’origine [0,0] se situe au centre de la grille.

Tous les points auront donc :

une valeur x comprise entre -240 et 240

et une valeur y comprise entre 180 et -180.

Lorsque nous plaçons un lutin sur la scène nous lui donnons les coordonnées x,y du point où nous voulons qu’il s’affiche. Regardons quelques exemples :

Info

Il est possible de voir à tous moments les coordonnées d’un lutin dans le coin en haut à droite du plan de travail de la fenêtre script.

Déplacer un lutin en utilisant ses coordonnées

Dans une ressource précédente nous avons vu comment déplacer un lutin là l’aide du bloc mouvement « avancer de » en donnant la distance à parcourir, par exemple 30. En fait il signifie, prendre la position x du lutin sur la scène et lui ajouter 30 pixels ou points. La nouvelle position du lutin aura donc pour coordonnées:

(ancienne coordonnée x +30, y)

Si nous regardons les autres blocs de type mouvement, nous voyons que plusieurs d’entre eux nous propose de donner des coordonnées x et y à notre lutin ou de les modifier. Ainsi nous allons pouvoir contrôler notre lutin de manière très précise. Le faire avancer, aller vers le haut, vers le bas, en diagonale,etc. Et ce de manière très précise, au pixel près.

Pour placer un lutin à un endroit, au début d’un programme par exemple, nous pouvons par exemple utiliser les blocs:

Donner la valeur à x (1 sur l’image ci-dessus)

Donner la valeur à y (2 sur l’image ci-dessus)

Ou encore le bloc :

Aller à x y (3 sur l’image ci-dessus)

La vidéo présente plus haut montre un exemple de l’utilisation de quelques un de ces blocs avec un petit programme déplaçant un lutin de manière aléatoire.

Life in pixel

Maintenant que nous avons vu comment positionner un lutin sur la scène avec ses coordonnées, regardons ce qui se passe encore plus en détail.

Un lutin est un assemblage de pixels. Regardons par exemple une portion d’un lutin en gros plan sur l’image ci-dessous.

Le point de référence

Si nous mettons notre lutin au centre de la scène, c’est à dire au point 0,0, nous voyons que le point de référence utilisé pour positionner notre lutin se trouve au centre de celui-ci.

Lorsque nous mettons un  lutin par exemple au centre de la scène, c’est à dire au point 0,0, nous voyons que le point de référence utilisé pour positionner notre lutin se trouve au centre de celui-ci.

Chaque costume de lutin dispose en effet d’un point de référence qui est utilisé pour placer le lutin sur la grille de la scène. C’est ce point qui sera placé aux coordonnées.

Il est possible de voir ce point et de le changer. Pour cela il faut aller dans la fenêtre costume. En haut à droite, nous avons un bouton qui s’appelle « définir le centre du costume ». Si nous cliquons dessus nous voyons 2 axes, et le point d’intersection est le centre du lutin. Nous pouvons le déplacer à l’aide de la souris et ainsi donner le point de référence que l’on souhaite à nos lutins.SCRATCH repositionnera alors automatiquement le lutin sur la scène avec cette nouvelle référence.

C’est ce point de référence est également celui utilisé lors de la rotation d’un lutin.

Bien définir son point de référence est important lorsque l’on fait des programmes où l’on doit utiliser la position du lutin pour des calculs (de distance ou autre) ou des déplacements.

Quelques exemples sont en démonstration dans la vidéo qui se trouve en début de page.

10 - LES EXPRESSIONS BOOLÉENNES ET LES INSTRUCTIONS CONDITIONNELLES

1.11 - LES CAPTEURS

1.12 - UTILISER LES EVENEMENTS

1.13