Blocs et Scripts

Blocs et Scripts dans Scratch 3.0

Les blocs et scripts sont le cœur de la programmation dans Scratch. Ce guide vous apprendra tout ce que vous devez savoir pour maîtriser ces éléments fondamentaux.

Comprendre les Blocs

Qu’est-ce qu’un Bloc ?

Un bloc est une instruction visuelle qui représente une action, une valeur ou une condition. Les blocs sont les briques de construction de vos programmes Scratch.

Anatomie d’un Bloc

Chaque bloc possède :

• Forme : Détermine comment il peut se connecter
• Couleur : Indique sa catégorie
• Texte : Décrit son action
• Paramètres : Valeurs que vous pouvez modifier
• Connecteurs : Points d’attache avec d’autres blocs

Types de Blocs par Forme

1. Blocs Chapeaux (Hat Blocks) 🎩

Caractéristiques

• Forme : Arrondie en haut, connecteur en bas
• Fonction : Démarrent l’exécution des scripts
• Position : Toujours en haut d’un script
• Couleur : Généralement dorée ou de la couleur de leur catégorie

Exemples Principaux

Événements de Démarrage

quand [drapeau vert] est cliqué
// Le plus utilisé - démarre quand on lance le projet

Événements Clavier

quand la touche [espace] est pressée
quand la touche [flèche droite] est pressée
quand la touche [a] est pressée

Événements Souris

quand ce sprite est cliqué
// Réagit au clic sur le sprite spécifique

Événements de Communication

quand je reçois [message1]
// Réagit aux messages envoyés par d'autres scripts

Événements Conditionnels

quand [volume] > (10)
quand [minuteur] > (30)
// Se déclenche quand une condition est remplie

Événements de Clonage

quand je commence comme un clone
// Script exécuté par chaque clone créé

Utilisation Pratique

// Contrôles de jeu
quand la touche [espace] est pressée
si <non <je touche [Sol]?>> alors
  ajouter (20) à y  // Saut
  jouer le son [saut]
fin

// Interface utilisateur
quand ce sprite est cliqué
si <(mode) = [menu]> alors
  mettre [mode] à [jeu]
  envoyer à tous [démarrer jeu]
fin

2. Blocs Pile (Stack Blocks) 📦

Caractéristiques

• Forme : Rectangulaire avec encoches
• Fonction : Actions à exécuter
• Connexion : Se connectent au-dessus et en-dessous
• Exécution : Séquentielle, de haut en bas

Catégories Principales

Mouvement

avancer de (10) pas
tourner ↻ de (15) degrés
aller à x: (0) y: (0)
glisser en (1) secondes à x: (100) y: (50)
s'orienter vers (90) degrés
rebondir si le bord est atteint

Apparence

dire [Bonjour !] pendant (2) secondes
se montrer
se cacher
basculer sur le costume (costume2)
ajouter (25) à l'effet [couleur]
mettre la taille à (150) %

Son

jouer le son [Meow] jusqu'au bout
jouer le son [Meow]
arrêter tous les sons
ajouter (10) au volume
mettre l'effet [hauteur] à (50)

Variables et Listes

mettre [ma variable] à (0)
ajouter (1) à [score]
ajouter [élément] à [ma liste]
supprimer (1) de [ma liste]
montrer la variable [score]

Événements

envoyer à tous [message1]
envoyer à tous [message1] et attendre

Exemple de Séquence

quand [drapeau vert] est cliqué
aller à x: (-200) y: (0)          // Position de départ
s'orienter vers (90) degrés       // Regarder à droite
dire [Je commence !] pendant (2) secondes
répéter (5) fois
  avancer de (50) pas             // Avancer
  jouer le son [step]             // Son de pas
  attendre (0.5) secondes         // Pause
fin
dire [Arrivé !]                   // Message final

3. Blocs C (C-Blocks) 🔄

Caractéristiques

• Forme : En forme de C avec espace intérieur
• Fonction : Contiennent et contrôlent d’autres blocs
• Types : Boucles, conditions, définitions
• Emboîtement : Peuvent contenir d’autres blocs C

Blocs de Répétition

Répéter X fois

répéter (10) fois
  avancer de (10) pas
  tourner ↻ de (36) degrés
fin
// Dessine un décagone

Répéter indéfiniment

répéter indéfiniment
  si <je touche le bord?> alors
    rebondir si le bord est atteint
  fin
  avancer de (5) pas
fin
// Mouvement perpétuel avec rebond

Répéter jusqu’à ce que

répéter jusqu'à ce que <je touche [Arrivée]?>
  si <touche [flèche droite] pressée?> alors
    ajouter (5) à x
  fin
  si <touche [flèche gauche] pressée?> alors
    ajouter (-5) à x
  fin
fin
// Contrôle jusqu'à atteindre l'objectif

Blocs Conditionnels

Si simple

si <(score) > (100)> alors
  basculer sur le costume [heureux]
  jouer le son [victoire]
  dire [Excellent !] pendant (2) secondes
fin

Si… sinon

si <(vies) > (0)> alors
  dire [Continue !]
  mettre [état] à [jeu]
sinon
  dire [Game Over]
  mettre [état] à [fin]
  arrêter [tous les scripts]
fin

Blocs d’Attente

Attendre durée

attendre (2) secondes
// Pause fixe

Attendre condition

attendre jusqu'à ce que <je touche [Joueur]?>
// Attend un événement spécifique

Emboîtement de Blocs C

répéter indéfiniment
  si <touche [espace] pressée?> alors
    répéter (5) fois
      ajouter (10) à y
      attendre (0.1) secondes
    fin
    répéter (5) fois
      ajouter (-10) à y
      attendre (0.1) secondes
    fin
  fin
fin
// Saut animé avec contrôle clavier

4. Blocs Reporters (Reporter Blocks) 📊

Caractéristiques

• Forme : Ovale ou rectangulaire arrondie
• Fonction : Retournent des valeurs
• Utilisation : S’insèrent dans les paramètres d’autres blocs
• Types : Nombres, textes, propriétés

Reporters de Position

(abscisse x)        // Position horizontale
(ordonnée y)        // Position verticale
(direction)         // Orientation en degrés

Reporters d’Apparence

(numéro de costume) // Numéro du costume actuel
(nom de costume)    // Nom du costume actuel
(taille)           // Taille en pourcentage

Reporters de Capteurs

(abscisse de la souris)     // Position X de la souris
(ordonnée de la souris)     // Position Y de la souris
(volume)                    // Niveau sonore du micro
(minuteur)                  // Temps écoulé
(réponse)                   // Dernière réponse saisie

Reporters d’Opérateurs

((10) + (5))                           // Addition
((20) - (8))                           // Soustraction
((6) * (7))                            // Multiplication
((15) / (3))                           // Division
(nombre aléatoire entre (1) et (10))   // Nombre aléatoire
(arrondir (3.7))                       // Arrondi
([abs] de (-5))                        // Valeur absolue

Reporters de Texte

(rejoindre [Bonjour ] [monde])         // Concaténation
(lettre (1) de [Scratch])              // Caractère à une position
(longueur de [programmation])          // Nombre de caractères

Utilisation dans des Expressions

// Calcul de distance
mettre [distance] à ([sqrt] de (((abscisse x) - (cible_x)) * ((abscisse x) - (cible_x)) + ((ordonnée y) - (cible_y)) * ((ordonnée y) - (cible_y))))

// Message dynamique
dire (rejoindre [Score: ] (rejoindre (score) (rejoindre [/] (score_max))))

// Position relative
aller à x: ((abscisse x) + (nombre aléatoire entre (-50) et (50))) y: ((ordonnée y) + (10))

5. Blocs Booléens (Boolean Blocks) ✅

Caractéristiques

• Forme : Hexagonale (6 côtés)
• Fonction : Retournent vrai ou faux
• Utilisation : Dans les conditions et opérateurs logiques
• Couleur : Généralement verte

Capteurs de Contact

<je touche [Sprite2]?>              // Contact avec sprite
<je touche [pointeur de souris]?>   // Contact avec souris
<je touche [bord]?>                 // Contact avec bord
<je touche la couleur [#ff0000]?>   // Contact avec couleur

Capteurs d’Entrée

<touche [espace] pressée?>          // Touche du clavier
<souris pressée?>                   // Bouton de souris

Comparaisons

<(score) > (100)>                   // Supérieur
<(vies) < (1)>                      // Inférieur
<(nom) = [Joueur1]>                 // Égal

Opérateurs Logiques

<<(score) > (50)> et <(vies) > (0)>>    // ET logique
<<touche [a] pressée?> ou <touche [w] pressée?>>  // OU logique
<non <je touche [Ennemi]?>>             // NON logique

Listes

<[ma liste] contient [élément]?>    // Élément dans liste

Utilisation Complexe

si <<<(score) > (highscore)> et <(niveau) > (5)>> ou <(mode_debug) = (1)>> alors
  dire [Conditions spéciales remplies !]
  envoyer à tous [événement spécial]
fin

Classification par Couleur

🏃‍♂️ Mouvement (Bleu Foncé)

• Déplacement et orientation des sprites
• Position et rotation
• Détection des bords

🎨 Apparence (Violet)

• Visibilité et costumes
• Effets visuels et taille
• Bulles de dialogue

🔊 Son (Rose/Magenta)

• Lecture de sons
• Contrôle du volume
• Effets sonores

🎯 Événements (Doré/Jaune)

• Déclencheurs de scripts
• Messages entre sprites
• Interactions utilisateur

🎮 Contrôle (Orange)

• Boucles et conditions
• Attentes et arrêts
• Clonage

👁️ Capteurs (Bleu Clair)

• Détection de contact
• Entrées utilisateur
• Propriétés d’autres sprites

🧮 Opérateurs (Vert)

• Calculs mathématiques
• Comparaisons
• Opérations sur le texte

📊 Variables (Orange Foncé)

• Stockage de données
• Listes et tableaux
• Affichage de valeurs

🧩 Mes Blocs (Violet Foncé)

• Blocs personnalisés
• Fonctions définies par l’utilisateur
• Paramètres personnalisés

Construction de Scripts

Structure d’un Script

Composants Essentiels

1. Bloc chapeau : Point de départ
2. Corps du script : Séquence d’actions
3. Logique de contrôle : Boucles et conditions
4. Gestion des données : Variables et listes

Exemple de Structure Complète

quand [drapeau vert] est cliqué           // 🎩 Chapeau
mettre [score] à (0)                      // 📦 Initialisation
mettre [vies] à (3)
aller à x: (0) y: (0)
répéter indéfiniment                      // 🔄 Boucle principale
  si <touche [flèche droite] pressée?> alors  // 🔄 Condition
    ajouter (5) à x                       // 📦 Action
    si <(abscisse x) > (240)> alors       // 🔄 Condition imbriquée
      mettre x à (240)                    // 📦 Correction
    fin
  fin
  si <je touche [Ennemi]?> alors          // 🔄 Condition
    ajouter (-1) à [vies]                 // 📦 Action
    si <(vies) < (1)> alors               // 🔄 Condition
      dire [Game Over !]                  // 📦 Action
      arrêter [tous les scripts]          // 📦 Arrêt
    fin
  fin
fin

Patterns de Scripts Courants

1. Initialisation

quand [drapeau vert] est cliqué
// Remettre à zéro
mettre [score] à (0)
mettre [vies] à (3)
mettre [niveau] à (1)
// Position initiale
aller à x: (0) y: (0)
s'orienter vers (90) degrés
// Apparence initiale
basculer sur le costume [normal]
mettre la taille à (100) %
annuler les effets graphiques
// État initial
se montrer
dire [Prêt !] pendant (2) secondes

2. Boucle de Jeu

répéter indéfiniment
  // Entrées utilisateur
  [gérer contrôles]
  // Logique de jeu
  [mettre à jour position]
  [vérifier collisions]
  [mettre à jour score]
  // Affichage
  [mettre à jour interface]
fin

3. Gestion des Contrôles

// Mouvement horizontal
si <touche [flèche droite] pressée?> alors
  ajouter (vitesse) à x
fin
si <touche [flèche gauche] pressée?> alors
  ajouter ((vitesse) * (-1)) à x
fin

// Mouvement vertical
si <touche [flèche haut] pressée?> alors
  ajouter (vitesse) à y
fin
si <touche [flèche bas] pressée?> alors
  ajouter ((vitesse) * (-1)) à y
fin

// Action spéciale
si <touche [espace] pressée?> alors
  si <(énergie) > (10)> alors
    [action spéciale]
    ajouter (-10) à [énergie]
  fin
fin

4. Système de Collision

// Vérification de collision
si <je touche [Ennemi]?> alors
  // Effet visuel
  répéter (3) fois
    mettre l'effet [couleur] à (25)
    attendre (0.1) secondes
    annuler les effets graphiques
    attendre (0.1) secondes
  fin
  // Conséquences
  ajouter (-1) à [vies]
  jouer le son [hurt]
  // Repositionnement
  aller à x: (0) y: (0)
fin

5. Génération d’Objets

// Script principal (sprite invisible)
quand [drapeau vert] est cliqué
se cacher
répéter indéfiniment
  attendre (nombre aléatoire entre (1) et (3)) secondes
  créer un clone de [moi-même]
fin

// Script des clones
quand je commence comme un clone
aller à x: (nombre aléatoire entre (-240) et (240)) y: (180)
se montrer
répéter jusqu'à ce que <(ordonnée y) < (-180)>
  ajouter (-5) à y
  si <je touche [Joueur]?> alors
    ajouter (10) à [score]
    jouer le son [collect]
    supprimer ce clone
  fin
fin
supprimer ce clone

Bonnes Pratiques de Construction

1. Organisation Claire

// ✅ Bon - Scripts organisés par fonction
// Script 1: Initialisation
quand [drapeau vert] est cliqué
[initialiser variables]
[positionner sprite]

// Script 2: Contrôles
quand [drapeau vert] est cliqué
répéter indéfiniment
  [gérer entrées clavier]
fin

// Script 3: Collisions
quand [drapeau vert] est cliqué
répéter indéfiniment
  [vérifier collisions]
fin

2. Éviter la Répétition

// ❌ Mauvais - Code répétitif
si <touche [flèche droite] pressée?> alors
  ajouter (5) à x
  jouer le son [step]
  ajouter (1) à [pas]
fin
si <touche [flèche gauche] pressée?> alors
  ajouter (-5) à x
  jouer le son [step]
  ajouter (1) à [pas]
fin

// ✅ Bon - Utiliser des variables
mettre [direction] à (0)
si <touche [flèche droite] pressée?> alors
  mettre [direction] à (5)
fin
si <touche [flèche gauche] pressée?> alors
  mettre [direction] à (-5)
fin
si <non <(direction) = (0)>> alors
  ajouter (direction) à x
  jouer le son [step]
  ajouter (1) à [pas]
fin

3. Gestion des États

// Variable: état = "menu", "jeu", "pause", "fin"
répéter indéfiniment
  si <(état) = [menu]> alors
    [afficher menu]
    si <touche [espace] pressée?> alors
      mettre [état] à [jeu]
    fin
  fin
  si <(état) = [jeu]> alors
    [logique de jeu]
    si <(vies) < (1)> alors
      mettre [état] à [fin]
    fin
  fin
  si <(état) = [pause]> alors
    [afficher pause]
    si <touche [p] pressée?> alors
      mettre [état] à [jeu]
    fin
  fin
fin

Techniques Avancées

1. Scripts Parallèles

Exécution Simultanée

// Script A - Mouvement
quand [drapeau vert] est cliqué
répéter indéfiniment
  avancer de (vitesse) pas
  si <je touche le bord?> alors
    rebondir si le bord est atteint
  fin
fin

// Script B - Rotation (en parallèle)
quand [drapeau vert] est cliqué
répéter indéfiniment
  tourner ↻ de (2) degrés
fin

// Script C - Changement de couleur (en parallèle)
quand [drapeau vert] est cliqué
répéter indéfiniment
  ajouter (1) à l'effet [couleur]
  attendre (0.1) secondes
fin

2. Communication entre Scripts

Messages

// Script émetteur
si <(score) > (100)> alors
  envoyer à tous [niveau suivant]
fin

// Script récepteur
quand je reçois [niveau suivant]
basculer sur l'arrière-plan suivant
ajouter (1) à [niveau]
mettre [vitesse] à ((vitesse) + (1))
dire [Niveau suivant !] pendant (2) secondes

Variables Partagées

// Script A - Modifie la variable
répéter indéfiniment
  si <je touche [Collectible]?> alors
    ajouter (10) à [score global]
  fin
fin

// Script B - Utilise la variable
répéter indéfiniment
  si <(score global) > (highscore)> alors
    mettre [highscore] à (score global)
    dire [Nouveau record !]
  fin
fin

3. Optimisation des Performances

Réduire les Calculs

// ❌ Mauvais - Calcul répétitif
répéter indéfiniment
  si <(distance jusqu'à [Joueur]) < (50)> alors
    // Action
  fin
fin

// ✅ Bon - Calcul périodique
répéter indéfiniment
  mettre [distance] à (distance jusqu'à [Joueur])
  répéter (10) fois
    si <(distance) < (50)> alors
      // Action
    fin
    attendre (0.1) secondes
  fin
fin

Limiter les Clones

// Compteur de clones actifs
si <(nombre_clones) < (20)> alors
  créer un clone de [moi-même]
  ajouter (1) à [nombre_clones]
fin

// Dans le script du clone
quand je commence comme un clone
// ... logique du clone ...
ajouter (-1) à [nombre_clones]
supprimer ce clone

4. Débogage de Scripts

Affichage de Debug

// Mode debug
si <(debug) = (1)> alors
  dire (rejoindre [X:] (rejoindre (abscisse x) (rejoindre [ Y:] (ordonnée y))))
fin

Points d’Arrêt

// Pause conditionnelle
si <(debug_pause) = (1)> alors
  attendre jusqu'à ce que <touche [d] pressée?>
fin

Traçage d’Exécution

// Log des actions
ajouter (rejoindre [Action: ] (action_courante)) à [log]
si <(longueur de [log]) > (50)> alors
  supprimer (1) de [log]
fin

Erreurs Courantes et Solutions

1. Scripts qui ne Démarrent Pas

Problème : Le script ne s’exécute pas

Causes Possibles :

• Pas de bloc chapeau
• Bloc chapeau incorrect
• Condition jamais remplie

Solution :

// ✅ Toujours commencer par un chapeau
quand [drapeau vert] est cliqué
// ... reste du script ...

2. Boucles Infinies

Problème : Le programme se fige

Cause : Boucle sans condition de sortie

Solution :

// ❌ Mauvais
répéter jusqu'à ce que <(x) = (100)>
  // Si x n'atteint jamais exactement 100...
fin

// ✅ Bon
répéter jusqu'à ce que <(x) > (100)>
  ajouter (1) à [x]
fin

3. Variables Non Initialisées

Problème : Comportement imprévisible

Solution :

quand [drapeau vert] est cliqué
// Toujours initialiser les variables
mettre [score] à (0)
mettre [vies] à (3)
mettre [état] à [menu]

4. Conflits entre Scripts

Problème : Scripts qui s’interfèrent

Solution :

// Utiliser des états pour coordonner
si <(état) = [jeu]> alors
  // Logique de jeu seulement
fin

5. Performance Dégradée

Problème : Le projet ralentit

Solutions :

• Réduire le nombre de clones
• Éviter les calculs complexes dans les boucles
• Utiliser des attentes pour espacer les actions
• Supprimer les clones inutiles

Conseils d’Optimisation

1. Structure Modulaire

• Un script par fonction principale
• Séparer l’initialisation de la logique
• Utiliser des messages pour la coordination

2. Gestion Efficace des Ressources

• Limiter le nombre de clones simultanés
• Supprimer les clones hors écran
• Réutiliser les variables temporaires

3. Code Lisible

• Noms de variables descriptifs
• Organisation logique des scripts
• Commentaires avec des blocs personnalisés

4. Tests Réguliers

• Tester chaque fonctionnalité séparément
• Vérifier les cas limites
• Optimiser progressivement

Conclusion

La maîtrise des blocs et scripts est essentielle pour créer des projets Scratch sophistiqués. En comprenant les différents types de blocs, leurs interactions et les patterns de programmation courants, vous pouvez construire des programmes robustes et efficaces.

Rappelez-vous que la programmation est un processus itératif : commencez simple, testez fréquemment, et améliorez progressivement. Chaque projet vous permettra de mieux comprendre comment assembler les blocs pour créer des expériences interactives captivantes.

Avec la pratique, vous développerez une intuition pour choisir les bons blocs et construire des scripts élégants qui donnent vie à vos idées créatives !