Niveau : débutant

Public : tous publics

Descriptif : Cette fiche est faite pour vous guider au mieux dans Scratch et son
interface de création. Elle détaille les outils de l’interface, les blocs, les interfaces
dessins et sons. Il n’est pas utile de la lire de bout en bout pour pouvoir utiliser
Scratch, mais elle peut néanmoins vous être utile si vous vous posez une question
sur un bloc ou un aspect en particulier.

Sommaire
I. Scratch, un véritable langage informatique .................................................................... 2
II. L’interface ...................................................................................................................... 2
1. Interface globale ......................................................................................................... 2
2. Dans le détail.............................................................................................................. 3
 Barre d’outils ........................................................................................................... 3
 Arrière-plan et liste des lutins .................................................................................. 4
 Onglets ................................................................................................................... 5
 Vue petite scène ..................................................................................................... 6
III. Les fonctionnalités ...................................................................................................... 6
1. Blocs .......................................................................................................................... 6
 Mouvement : ........................................................................................................... 7
 Apparence .............................................................................................................. 8
 Sons ..................................................................................................................... 10
 Stylo ..................................................................................................................... 11
 Données ............................................................................................................... 12
 Événements .......................................................................................................... 15
 Contrôle ................................................................................................................ 16
 Capteurs ............................................................................................................... 17
 Opérateurs ............................................................................................................ 19
 Ajouter blocs ou les blocs “procédure” .................................................................. 21
2. Dessiner les costumes/arrière-plans......................................................................... 23
 Le mode Bitmap.................................................................................................... 23
 Le mode Vecteur .................................................................................................. 24
3. Sons ......................................................................................................................... 26
IV. Et maintenant ? ........................................................................................................ 27

1
En 2006, le MIT développe un nouveau langage informatique : Scratch.
Le but étant de rendre la programmation accessible à tous et ce dès 8 ans. Le
logiciel est gratuit et est traduit en une vingtaine de langues. Les créations réalisées
et partagées sur le site sont en creative commons, ce qui permet en outre de
modifier les créations des autres utilisateurs et d’apprendre par l’exemple.

Le langage se présente sous forme de blocs qu’il faut assembler pour former des
suites de lignes de code. Il s’agit d’une version visuelle du Smaltalk, un langage de
programmation orienté objet, qui a beaucoup influencé le développement d’autres
langages tels que Java ou Ruby.
Scratch est donc dynamique : il permet de modifier le code et ce, directement en
cours d'exécution. Son utilisation est ludique, il suffit de manipuler les briques et
d’observer immédiatement le résultat.

Plus concrètement, Scratch est un véritable langage puisqu’il aborde les concepts
de base de la programmation tels que les boucles, les conditions, les variables, etc.
Il est idéal pour expliquer l’algorithme aux petits et grands et ce, de façon très
accessible. C’est un outil efficace pour l’initiation de chacun. S’il est possible de
créer des jeux ou des animations extrêmement simples, il est possible aussi d’aller
assez loin et de créer des jeux complexes.

Vous pouvez, en tant que Voyageur du Code, imaginer divers ateliers d’initiation à la
programmation avec Scratch. Des ateliers sur une ou plusieurs séances, au cours
desquels vous pouvez accompagner les participants dans la réalisation d’une
animation ou d’un jeu autour d’un thème par exemple.

Regardons d’abord ce qui s’offre à notre vue au premier abord.

2
Il est à noter que le sac à dos n’existe pas dans la version off line de Scratch.

Pour dupliquer un lutin, le supprimer ou changer sa taille, il suffit de cliquer sur

l'icône voulue. Le curseur de la souris indique alors que l’outil est actif, il ne reste
plus qu’à cliquer une ou plusieurs fois sur le lutin que l’on veut modifier.
Lorsque l’on duplique un lutin, on duplique son script et ses costumes.

3
 

Il existe différentes façons de créer un arrière-plan ou un lutin. On peut le choisir

dans la bibliothèque Scratch, le dessiner ou l’importer. On peut aussi créer un lutin
ou un arrière-plan à partir d’une photo. Il est nécessaire dans ce cas d’avoir un
ordinateur équipé d’une webcam.

En cliquant sur la touche info, en haut à gauche du lutin, il est possible d'accéder à
un certains nombres d’éléments.

1 → Le nom du lutin. Il est possible de le modifier ici.

2 → La position du lutin sur la scène (ici x=8 et y=26). Il s’agit de l’abscisse et de
l’ordonnée. La taille de la scène est la suivante :

4
Si le lutin est situé au-delà des limites de la scène, il n’y apparaîtra plus. Il faut alors
le replacer dans le cadre.
3 → Indique l’orientation du lutin. Il est possible de régler son inclinaison. Si, par
exemple, nous voulons avoir un chat avec la tête en bas, nous pouvons bouger le
petit curseur bleu sur -90. La direction va de pair avec le style de rotation, qui va
permettre ou non de mettre notre chat la tête en bas, ou simplement d’inverser sa
direction.
4 → Il est possible de choisir entre trois styles de rotation (icônes de gauche à droite)
:
- Le lutin pivote à 360° lors de ses mouvements.
- Le lutin ne pivote que vers la gauche ou vers la droite.
- Le lutin ne pivote pas.
5 → Peut glisser dans le lecteur : le joueur peut déplacer le lutin avec sa souris en
jouant.
6 → Permet de rendre ou non le lutin visible à l’écran. Les effets
d’apparition/disparition sont néanmoins à programmer dans l’aire de script.

5
 

Les blocs sont classés en différentes catégories très repérables par les couleurs.

En parcourant ces différentes sections, vous vous rendez compte que tous les blocs
n’ont pas la même forme. Avant de rentrer dans les détails, définissons ces formes.
On peut distinguer 5 types de blocs :

Blocs instructions. Ils définissent les actions

du lutin.
Blocs de données. Ils renvoient à la
variable de l’élément choisi. Par exemple, si
on examine cette instruction :

Le code renvoie à la variable abscisse “x”

qui est la position horizontale du lutin et
celui-ci dit sa position :

6
 Blocs chapeaux/entrées. Ils sont le point de
départ du script. Ils sont les événements qui
déterminent le début d’une action.
Blocs de structure de contrôle. Ces blocs
influent sur le déroulement des instructions
(ceux-ci sont identifiables par leur couleur).

Blocs booléens. Ils indiquent quelle

condition est testée dans les blocs
« structure de condition » (tel que celui ci-
dessous). Le résultat renvoyé par ces blocs
est soit vrai, soit faux.

On construit le script ainsi :

Ainsi, lorsque le drapeau vert est cliqué, si

le lutin touche un bord de la scène, la
condition est vraie et il avance de 10.
Si en revanche il ne touche pas le bord de
la scène, la condition est fausse, il n’avance
pas.

Cette distinction faite, rentrons dans les détails. Les blocs précédés d’un *
(astérisque) sont explicités plus en détail à la suite du tableau les concernant.


Déplace le lutin d’un certain nombre de pas.
Le lutin se déplace en avant ou en arrière
(ou vers le haut, vers le bas, de biais)
suivant la direction où il est positionné.

7
 Fait tourner le lutin vers la droite d’un
nombre de degrés à définir.
Fait tourner le lutin vers la gauche d’un
nombre de degrés à définir.
*Définit la direction du lutin. 90° droite; -
* 90° gauche; 0° haut, 180° bas.
Oriente le lutin vers un autre lutin ou vers le
pointeur de la souris.
Le lutin se déplace sur une position à définir
sur la scène.
Le lutin se déplace sur l’emplacement d’un
autre lutin ou sur le curseur de la souris.
Le lutin se déplace jusqu’à un point à définir
en un temps à définir.
Le lutin se déplace d’un nombre à définir
sur l’abscisse x. Un nombre positif déplace
le lutin vers la droite, un nombre négatif
déplace le lutin vers la gauche.
Le lutin se déplace sur un emplacement à
définir sur l'abscisse x.

Le lutin se déplace d’un nombre à définir

sur l'ordonnée y. Un nombre positif déplace
le lutin vers le haut, un nombre négatif
déplace le lutin vers le bas.
Le lutin se déplace sur un emplacement à
définir sur l'ordonnée y.

Si le lutin atteint le bord de la scène, il

rebondit.

* *Définit le style de rotation du lutin. Il est

possible de le fixer dans les infos du lutin,
mais il est aussi possible de le modifier au
cours de l’animation.
Fournit la valeur de la position x du lutin
Fournit la valeur de la position y du lutin
Fournit la valeur de la direction actuelle du
lutin

*  Le lutin s’oriente à droite, à gauche, vers le haut, vers le bas, mais il

pivote aussi en fonction de son style de rotation que l’on peut soit définir directement dans
les infos, soit définir à l’aide du bloc .


Les descriptions précédées d’un * sont explicitées plus en détail à la suite du
tableau.

8
 Le lutin affiche le message choisi dans une
bulle de parole pendant un temps à définir
avant de disparaître.
Le lutin affiche le message choisi dans une
bulle de parole.

Le lutin affiche le message choisi dans une

bulle de pensée pendant un temps à définir.
Le lutin affiche le message choisi dans une
bulle de pensée.
Le lutin apparaît.

Le lutin disparaît.

Bascule sur un autre costume.

Bascule sur le costume suivant dans la liste

des costumes. Arrivé au dernier costume, la
liste recommence du début.
Bascule vers l’arrière-plan spécifié dans la
liste des arrière-plans.

*Permet d’ajouter un effet au lutin. Le

* déroulant permet plusieurs choix : couleur,
œil de poisson, tournoyer, pixéliser,
mosaïque, luminosité, fantôme. Plus le
chiffre associé est élevé, plus l’effet est
marqué.

*Met l’effet graphique du lutin à une valeur

* spécifiée. Les effets sont les mêmes que
ceux évoqués précédemment.
Annule tous les effets graphiques du lutin.

Modifie la taille du lutin de la valeur

spécifiée. Un nombre négatif le fera rétrécir.
Permet d’agrandir ou de rapetisser le lutin.
100% étant sa taille initiale.
Déplace le lutin devant tous les autres
lutins.

Déplace le lutin vers l’arrière-plan. Le

nombre à indiquer dépendra du nombre de
lutins.
Indique le numéro du costume actuel du
lutin.
Indique le nom de l’arrière-plan actuel.
Indique la taille actuelle du lutin.

* → Les effets graphiques

sont modifiables selon des valeurs comprises entre -200 et 200, 0 étant l’effet de
base.

9
Les couleurs varient de 0 à 200 en suivant le cercle chromatique.

Ainsi, si la couleur est définie à 20 (orange) et qu’au cours du script on ajoute 30 à la

couleur, on obtient du jaune vert.


Les descriptions précédées d’un * sont explicitées plus en détail à la suite du
tableau.
Joue le son choisi sans arrêter la suite de
l’animation.
Joue le son choisi jusqu’au bout avant de
continuer la suite de l’animation.
Arrête tous les sons en cours.

Joue un son de batterie qu’il est possible de

modifier en cliquant sur le menu déroulant.
La durée est à spécifier.
Suspend les instruments en cours pendant
un temps défini.

Joue la note choisie (par défaut 60)

pendant un temps défini. Il suffit de cliquer
sur le menu déroulant pour changer la note
à jouer.
Définit le type d’instrument à jouer. Pour le
changer, il suffit de cliquer sur le menu
déroulant.
Permet de modifier le volume du lutin. Le
* volume est de 100 par défaut. Un nombre
négatif réduit le volume, un nombre positif
l’augmente.
Définit le volume sonore du lutin. 100 %
* étant le volume par défaut.

*Fournit la valeur du volume actuel du lutin.

*

10
 Change le tempo (battement par minute) du
lutin selon une valeur à définir.
Définit le tempo (battement par minute) du
lutin.

Fournit la valeur du tempo actuel du lutin.

* → Le volume peut être réglé à l’aide des blocs suivants :

, .


Les descriptions précédées d’un * sont explicitées plus en détail à la suite du
tableau.
Permet d’effacer toutes les marques de
stylo de tous les lutins.
Le lutin laisse une empreinte de lui-même
sur sa position actuelle. Une estampille
n’est qu’une image, elle ne peut pas être
animée.
Le lutin laisse une trace sur son passage à
la manière d’un stylo.

Le lutin ne laisse pas de trace lors de son

déplacement.

Permet de choisir la couleur du stylo. Pour

la changer, cliquez sur le petit carré de
couleur et cliquez sur la couleur voulue
n’importe où dans la page de votre
navigateur.
*Modifie la couleur du stylo par une valeur à
* définir.

*Met la valeur du stylo à une valeur à

* définir.

Permet d’accentuer (valeur positive) ou de

d'atténuer (valeur négative) la couleur
choisie pour le lutin.

Permet de définir l’intensité de la couleur

choisie. Une valeur positive accentuera la
couleur; une valeur négative l’atténuera.

Permet d’agrandir (valeur positive) ou de

rétrécir (valeur négative) le tracé du stylo.

Définit l’épaisseur du tracé du stylo. Une

valeur négative équivaudra à zéro.

11
* → Les couleurs varient
de 0 à 200 en suivant le cercle chromatique.

Ainsi, lorsque la couleur est définie à 20 (orange) et qu’au cours du script on y ajoute
30, on obtient du jaune vert.

 Créer une variable

Une variable est un espace de mémoire dans lequel l'ordinateur peut stocker des
données. Par exemple, le score d’un jeu est une variable : on stocke une valeur de
base et elle change au cours de la partie selon le calcul des bonus et malus.
Pour créer une variable, il suffit de cliquer sur l’onglet “créer une variable”. Cette
fenêtre s’ouvre alors :

Nous appellerons, pour l’exemple, notre variable “score”. Il faut ensuite décider si
cette variable ne s’appliquera qu’à ce seul lutin ou bien également à tous les autres.
Si elle ne s’applique qu’au seul lutin sélectionné, alors elle fonctionne
indépendamment des autres lutins créés. Si elle s’applique à tous les lutins, alors
elle peut varier en fonction des actions de chacun des lutins créés. Toutefois, si vous
décidez en cours de route de modifier cette variable pour un seul lutin, cela ne
fonctionnera pas.

12
Lorsqu’une variable est créée, plusieurs blocs apparaissent :

Fournit la valeur de la variable “score”.

Porte la variable à une valeur à définir.

Ajoute à la variable une valeur à définir.

Montre sur la scène la variable “score” ainsi

que sa valeur.

Cache sur la scène la variable “score” et sa

valeur.

Un clic droit sur la variable visible sur la scène, déroule un menu contextuel qui
permet de modifier l’affichage de la variable.
En cochant l’onglet “lecture normale”, la fenêtre de la variable s’affiche ainsi :

En cochant l’onglet “grande lecture”, la fenêtre de la variable s’affiche ainsi :

Si l’on coche l’onglet “potentiomètre”, la fenêtre de la variable s’affiche avec un

curseur qu’il est possible de régler directement sur la valeur désirée :

13
En cliquant sur l’onglet “cacher”, la variable n'apparaît plus sur la scène.

 Créer une liste

Une liste est une structure de données permettant de regrouper, d’organiser et de
traiter des informations plus simplement. Par exemple, il est possible de créer une
liste de mots que mon lutin affichera de manière aléatoire.
Pour créer une nouvelle liste, il suffit de cliquer sur “créer une liste”. On peut ensuite
paramétrer la liste “pour tous les lutins”, ce qui signifie qu’elle s’appliquera à tous les
lutins créés. Ou bien on peut paramétrer la liste “pour ce lutin uniquement”, ce qui
signifie qu’elle s’appliquera seulement au lutin sélectionné. Pour l’exemple, nous
créerons une liste de course.

Lorsque la liste est créée, un certain nombre de blocs apparaissent:

Renvoie à la liste “course”.

Ajoute un élément à définir à la liste

“course”.
Supprime l’élément désigné de la liste. Il est
possible de sélectionner un élément à l’aide
de son numéro correspondant, de tous les
sélectionner, ou bien de ne sélectionner
que le dernier.
Permet d’insérer un nouvel élément dans la
liste. À noter que si un nouvel élément est
inséré à la place 1 et que cette place est
occupée par un ancien élément, celui-ci se
déplacera en place 2, laissant la place 1 au
nouvel élément. Le reste de la liste suivra.

Permet de remplacer un ancien élément

désigné de la liste par un nouveau.

Renvoie à un élément défini de la liste

“course”.

14
 Renvoie au nombre d’éléments de la liste
“course”. Si la liste “course” contient 5
éléments, la longueur est de 5.
Si la liste “course” contient l’élément
indiqué, le résultat sera “vrai”, sinon il sera
“faux”.
Affiche sur la scène la liste “course” et ses
éléments.

Cache sur la scène la liste “course” et ses

éléments.

Un clic droit sur la liste visible de la scène et il est possible d’importer ou d’exporter
une liste. Il est aussi possible de cacher la liste.

Les blocs événements définissent l’action qui déclenchera l’animation des lutins.
Cette action peut être différente pour chaque lutin.
Les descriptions précédées d’un * sont explicitées plus en détail à la suite du
tableau.
Exécute le script du lutin lorsque le drapeau
vert au dessus de la scène est cliqué.

Exécute le script du lutin lorsque la touche

“espace” est cliquée. Il est possible de
changer de touche en cliquant sur le
déroulant.
Exécute le script du lutin lorsque celui-ci est
cliqué.

Exécute le script lorsque l’arrière-plan

change pour un autre défini.

Exécute le script lorsque le “volume

sonore”, le “chronomètre” ou le
“mouvement vidéo” (au choix) est supérieur
à une valeur à définir.
*Exécute le script lorsque le lutin reçoit un
message à définir.
*
*Envoie à tous les autres lutins un message
* à spécifier.

*Le lutin envoie à tous les autres lutins un

* message à spécifier et attend qu’ils aient
fini les animations liées à cet événement
avant de continuer sa propre animation.

15
*

→ Définir un message permet de synchroniser

les éléments (lutins et/ou arrière-plans) entre eux. Par exemple, un premier lutin
peut, au cours de son animation, envoyer un message à un second lutin qui ne
commencera son animation que lorsqu’il aura reçu ce message. Si on commande au
premier lutin d’“envoyer à tous message1”, il enverra son message tout en
continuant son animation jusqu’au bout. En revanche, si on commande au premier
lutin d’“envoyer à tous message1 et attendre”, il enverra son message et attendra
que le second lutin finisse l’animation liée au message avant de continuer sa propre
animation.

Le lutin attendra 1 seconde avant de

poursuivre le script.
Le script compris dans la boucle est répété
un nombre défini de fois avant de continuer.

Le script compris dans la boucle est répété

indéfiniment.

Si la condition déterminée est vérifiée, le

lutin exécute le script compris dans le bloc
condition.

Si la condition déterminée est remplie, le

lutin exécute le script compris dans la partie
supérieure de la condition. Si la condition
n’est pas vérifiée (“sinon”), le lutin exécute
le script compris dans la partie inférieure.
Le lutin attend jusqu’à ce qu’une condition
(à définir) soit vraie avant de continuer son
script.
Le script compris dans la boucle s’exécute
tant qu’une condition (à définir) n’est pas
vraie.

Stop l’animation soit pour tous les lutins,

soit pour le script en cours, soit pour un
autre script du lutin.
Indique aux clones du lutin ce qu’ils doivent
faire une fois créés.

Le lutin crée un clone de lui-même ou d’un

autre lutin.

16
 Supprime le clone.


Les descriptions précédées d’un * sont explicitées plus en détail à la suite du
tableau.
Si un élément spécifié (lutin, pointeur souris
ou bord) est touché, le résultat sera vrai,
sinon il sera faux.
Si une couleur spécifiée est touchée, le
résultat sera vrai, sinon il sera faux.

Si une couleur spécifiée touche une autre

couleur spécifiée, alors le résultat sera vrai,
sinon il sera faux.
Fournit la valeur de la distance entre le lutin
et un autre lutin ou le pointeur de la souris.
Le lutin pose une question et ouvre une
boîte de dialogue dans laquelle il est
possible de répondre.
Fournit la valeur de la réponse donnée
dans la boîte de dialogue.
Si la touche définie est pressée, alors le
résultat sera vrai, sinon il sera faux.
Si la souris est pressée, alors le résultat
sera vrai, sinon il sera faux.
Fournit la valeur de la position de la souris
sur l'abscisse x (horizontale).

Fournit la valeur de la position de la souris

sur l’ordonnée y (verticale).
* Fournit la valeur du volume sonore capté
* par les micros.

** Fournit la valeur du mouvement ou la

** direction du lutin ou de la scène détectée
par la webcam.
Active ou désactive la webcam.

Permet de définir la transparence de la

webcam. Cette valeur est comprise entre 0
et 100%. 0 étant le moins opaque, 100 le
plus opaque.
*** Fournit la valeur du chronomètre.
***
***Réinitialise le chronomètre.
***

17
 **** Fournit la valeur d’un paramètre du lutin
**** ou de la scène. Il suffit de cliquer sur le
déroulant pour choisir le paramètre.
Fournit la valeur de l’heure ou la date
actuelle.
Fournit la valeur du nombre de jours depuis
l’an 2000.
Fournit la valeur du nom d’utilisateur.

* → L’utilisation de ce bloc nécessite un ordinateur équipé d’un

microphone. Il permet de détecter le son capté par celui-ci. En cela, il est différent du
bloc qui fournit la valeur du son du lutin.

** → Il est nécessaire d’activer la webcam au

préalable, à l’aide du bloc . Le bloc permet à la webcam de

vérifier le nombre de mouvements d’un lutin ou de l’ensemble de la scène, ou bien la
direction du mouvement d’un lutin ou de l’ensemble de la scène.

*** → Le chronomètre est toujours en cours d’exécution. Si on veut

qu’au début de l’action (ou même au cours de l’action) le chronomètre parte de zéro,

il faut bien penser à mettre le bloc . Le chronomètre ne

s'arrêtera jamais, mais il repartira alors de zéro.

**** → Le menu déroulant permet de choisir entre différents

paramètres. Lorsque les paramètres renvoient à un lutin, les choix de paramètres
sont les suivants :

Quelle différence avec ces blocs ?

Ces deux blocs permettent de renvoyer à l'abscisse x ou l'ordonnée y du lutin à qui
appartient le script. Le bloc permet de renvoyer à l’abscisse
ou à un autre paramètre d’un autre lutin.
Lorsque les paramètres renvoient à la scène, les choix de paramètres sont les
suivants :

18
Le numéro d’arrière-plan correspond au numéro écrit en haut à gauche des icônes
dans l’onglet “arrière-plan” :

Le volume correspond au volume des sons émis par le lutin choisi ou la scène.


Les opérateurs servent au calcul. Il est à noter qu’un chiffre pouvant être négatif ou
positif, il est important de prendre en compte l’ordre des nombres dans les
opérations.
On trouve dans les opérateurs soit des nombres, soit des chaînes de caractères (qui
sont des mots ou des suites de mots, des espaces et des caractères spéciaux).
Les descriptions précédées d’un * sont explicitées plus en détail à la suite du
tableau.
Additionne deux nombres.

Soustrait le second nombre du premier.

Multiplie deux nombres.

Divise le premier nombre par le second.

Fournit la valeur d’un nombre aléatoire

compris entre deux valeurs.

Si le premier nombre est inférieur au

second, le résultat est vrai, sinon il est faux.

19
 Si le premier nombre est égal au second, le
résultat est vrai, sinon il est faux.

Si le premier nombre est supérieur au

second, le résultat est vrai, sinon il est faux.

Si les deux conditions sont remplies, la

condition est vraie.

Si l’une des deux conditions est remplie, la

condition est vraie.

Si la condition n’est pas remplie, le résultat

est vrai.

*Permet de regrouper deux chaînes de

* caractères. Par exemple, un mot et un
élément d’une liste (à l’aide d’un bloc
“renvoi”).
*Fournit la valeur de la lettre désignée dans
*
une chaîne spécifiée (ici, la première lettre
de “world”).
*Fournit la valeur de la longueur de la
* chaîne spécifiée, c’est-à-dire le nombre de
caractères de la chaîne (le nombre de
lettres dans le mot ou la phrase et les
espaces).
**Fournit la valeur du reste de la division
** entière du premier nombre par le second
nombre.
Fournit la valeur du nombre entier le plus
proche du nombre spécifié (l’arrondi de
7,89 est 8).
Fournit la valeur de la racine du nombre
spécifié.

* → On appelle “chaîne de
caractères”, une suite de caractère (lettres, espaces, caractères spéciaux).
Lorsqu’on compte une chaîne, il faut bien compter tous les caractères, y compris les
caractères spéciaux.

** → Le modulo permet d’obtenir le reste d’une division entière. Par

exemple, si on à “17 modulo 5” on fait le calcul suivant :

17 modulo 5 = 2.

20
 
Lorsque une série d’actions se succèdent de manière répétée dans tout le script, il
est laborieux de toujours devoir inscrire la même chose. Il est possible de créer ce
qu’on appelle une procédure, qui regroupe l’ensemble des actions sous un seul et
même bloc.
Dans la dernière catégorie de blocs, il est possible de créer un nouveau bloc. En
cliquant sur “créer un bloc”, une fenêtre s’ouvre :

Il faut alors donner un nom à sa procédure. Pour l’exemple, elle s’appellera “Faire un
carré”.
Deux blocs sont alors disponibles :

Nous avons un crayon sur la scène, et nous souhaitons qu’il dessine trois carrés à
des endroits différents de la scène.
Il serait fastidieux d’entrer plusieurs fois les mêmes suites de blocs. Il suffit donc de
définir la procédure ainsi :

21
La procédure est donc définie par une succession d’actions qu’il ne sera pas utile de
répéter à chaque fois. Il suffira d’utiliser le second bloc. Nous écrirons le script
suivant pour notre crayon :

Le lutin exécute la succession d’actions définie sans qu’on ait eu à la répéter.

Vous pouvez associer à votre procédure une ou plusieurs options. Lorsque vous
cliquez sur “créer un bloc”, vous avez en bas un menu déroulant “option”.

22
Vous pouvez ainsi créer un paramètre pour votre bloc qui sera un nombre, une
chaîne de caractères, une entrée booléenne, un label (voir l’introduction du chapitre
Les blocs).

Si vous souhaitez dessiner vos propres lutins ou arrière-plans, il suffit de cliquer sur
le petit pinceau dans l’espace arrière-plan ou au-dessus de la liste des lutins. Vous
êtes alors basculé vers l’onglet Costumes ou Arrière-plans. Deux modes de dessin
sont disponibles : le mode Bitmap et le mode Vecteur. Sachez qu’il est possible de
convertir un dessin vectoriel en dessin Bitmap, mais pas l’inverse. Choisissez donc
bien votre mode avant de commencer votre création.


Les outils sont listés à gauche, il suffit de cliquer dessus pour les sélectionner :

23
Le mode Bitmap vous permet de dessiner assez librement à l’aide du pinceau. En
revanche, les éléments créés sont fixes. Il vous est impossible d’en changer la
couleur, la taille ou la position.
Une image Bitmap est constituée de pixels, des points de couleur. Les éléments
seront donc distingués par leur couleur. Si vous faites chevaucher deux éléments de
même couleur et que vous décidez de modifier celle-ci, les deux éléments
changeront de couleur.


Cette fois, les outils sont situés à droite de l’écran :

24
Une image vectorielle se compose de formes géométriques indépendantes. Il est
donc possible de modifier les éléments, d’en changer la position, la couleur, la taille
et la forme de façon indépendante.

Le mode vecteur offre donc une plus grande liberté. Il est possible de modifier les
formes d’un dessin original ou même des dessins existants en changeant la forme
des éléments géométriques qui les composent, par exemple.

Ici, nous avons joué avec les points géométriques qui composent le chat Scratch.

25
Une image vectorielle n’étant pas composée sur la base de pixels, il est possible de
jouer plus aisément avec la couleur. On peut par exemple faire des dégradés de
couleur.

Notez qu’un dessin est parfois composé de plusieurs formes imbriquées. Un dessin
colorié est donc composé de deux sortes de formes : les formes géométriques
extérieures et les formes géométriques que constitue sa couleur.
Prenons un exemple : la pomme Scratch est composée de son cercle extérieur, que
nous pouvons déformer; et de sa couleur que nous pouvons aussi déformer, et ce
de manière indépendante du cercle qu’elle remplit.

Lorsque vous cliquez sur l’onglet Sons, vous pouvez éditer des sons en les
important depuis l’ordinateur ou bien en les choisissant dans la bibliothèque. Vous
pouvez aussi enregistrer un son si votre ordinateur est muni d’un micro.

26
Une fois votre son choisi, vous pouvez le modifier à l’aide des onglets Édition et
Effets en dessous de la bande.
Pour supprimer une partie ou bien la modifier, il vous suffit de la sélectionner :
cliquez sur le début de la sélection et faite glisser votre curseur jusqu’au point voulu.

Scratch permet donc d’aller assez loin dans la programmation. Il est possible
d’imaginer un grand nombre d’activités autour du logiciel.

27
On peut imaginer un atelier d’initiation sur une séance plus ou moins longue,
laquelle permettra d’aborder les principes de bases de la programmation à travers la
réalisation de fiches ou la création guidée d’un jeu ou d’une animation.

Mais on peut aussi imaginer un stage sur plusieurs jours :

- dans un premier temps, une initiation à la programmation à l’aide d’une fiche
activité disponible sur le site Voyageursducode.fr.
- un second temps remixage où l’on s’amuse à modifier un jeu existant.
Quelques jeux amusants sur Scratch : Casse-Brique, Mario, Pac-Man, Space
Invader.
- le troisième temps du stage sera consacré à la création autour d’une
thématique. Par exemple : un livre numérique, une série de mini-jeux, un
cadavre exquis, etc.

Notez que vous pouvez allier Scratch et Makey-Makey. Le Makey-Makey est une
carte électronique qui permet d'émuler le clavier et de fabriquer une manette avec
tout matériau conducteur…

N’hésitez pas à consulter les parcours pédagogiques sur le site Voyageursducode.fr.

28