Variables et Données

Variables et Données dans Scratch 3.0

Les variables et la gestion des données sont essentielles pour créer des projets Scratch interactifs et dynamiques. Ce guide vous apprendra tout ce qu’il faut savoir pour stocker, manipuler et utiliser efficacement les données dans vos programmes.

Comprendre les Variables

Qu’est-ce qu’une Variable ?

Une variable est un conteneur qui stocke une valeur (nombre, texte, ou valeur booléenne) que votre programme peut utiliser et modifier. Pensez à une variable comme à une boîte étiquetée où vous pouvez ranger et récupérer des informations.

Pourquoi Utiliser des Variables ?

1. Mémorisation d’Informations

// Stocker le score du joueur
mettre [score] à (0)
ajouter (10) à [score]  // Le score devient 10

2. Calculs et Logique

// Calculer la vitesse selon le niveau
mettre [vitesse] à ((niveau) * (2))
avancer de (vitesse) pas

3. Communication entre Scripts

// Script A modifie la variable
mettre [état_jeu] à [en_cours]

// Script B réagit au changement
si <(état_jeu) = [en_cours]> alors
  // Logique de jeu active
fin

4. Personnalisation

// Stocker les préférences du joueur
demander [Quel est ton nom ?] et attendre
mettre [nom_joueur] à (réponse)
dire (rejoindre [Bonjour ] (nom_joueur))

Création et Gestion des Variables

Créer une Variable

Méthode Standard

1. Aller dans la catégorie "Variables" (orange)
2. Cliquer sur "Créer une variable"
3. Saisir le nom de la variable
4. Choisir la portée :
   - "Pour tous les sprites" (globale)
   - "Pour ce sprite seulement" (locale)
5. Cliquer "OK"

Conventions de Nommage

// ✅ Bons noms
score
points_de_vie
vitesse_joueur
nombre_ennemis
temps_restant
niveau_actuel

// ❌ Mauvais noms
a
var1
x
truc
qqchose

Types de Variables

Variables Globales

// Accessibles par tous les sprites
score          // Score du jeu
niveau         // Niveau actuel
temps_jeu      // Temps écoulé
état_jeu       // État général (menu, jeu, pause)
highscore      // Meilleur score

Variables Locales

// Spécifiques à un sprite
points_de_vie  // Santé du personnage
vitesse        // Vitesse de déplacement
animation      // État d'animation
direction      // Direction du mouvement
munitions      // Nombre de projectiles

Opérations sur les Variables

Assignation

// Définir une valeur
mettre [score] à (0)
mettre [nom] à [Joueur1]
mettre [actif] à (vrai)
mettre [position_x] à (abscisse x)

Addition et Soustraction

// Modifier la valeur
ajouter (10) à [score]        // score = score + 10
ajouter (-5) à [points_de_vie] // points_de_vie = points_de_vie - 5
ajouter (1) à [compteur]      // Incrémenter
ajouter (-1) à [munitions]    // Décrémenter

Calculs Complexes

// Utiliser des formules
mettre [vitesse] à ((niveau) * (2) + (5))
mettre [distance] à ([sqrt] de (((x1) - (x2)) * ((x1) - (x2)) + ((y1) - (y2)) * ((y1) - (y2))))
mettre [pourcentage] à (((score) / (score_max)) * (100))

Applications Pratiques

1. Système de Score

Score Basique

// Initialisation
quand [drapeau vert] est cliqué
mettre [score] à (0)
montrer la variable [score]

// Gain de points
quand je touche [Pièce]
ajouter (10) à [score]
jouer le son [collect]

// Affichage dynamique
répéter indéfiniment
  dire (rejoindre [Score: ] (score))
  attendre (0.1) secondes
fin

Score Avancé

// Système de multiplicateur
quand [drapeau vert] est cliqué
mettre [score] à (0)
mettre [multiplicateur] à (1)
mettre [combo] à (0)

// Collecte avec combo
quand je touche [Objet]
mettre [points_base] à (10)
mettre [points_bonus] à ((combo) * (2))
mettre [points_total] à ((points_base + points_bonus) * (multiplicateur))
ajouter (points_total) à [score]
ajouter (1) à [combo]

// Affichage détaillé
dire (rejoindre [+] (rejoindre (points_total) (rejoindre [ (x] (rejoindre (multiplicateur) [)]))))

// Reset combo après délai
attendre (3) secondes
mettre [combo] à (0)

2. Système de Santé

Santé Simple

// Initialisation
quand [drapeau vert] est cliqué
mettre [points_de_vie] à (100)
mettre [points_de_vie_max] à (100)

// Dégâts
quand je touche [Ennemi]
ajouter (-20) à [points_de_vie]
si <(points_de_vie) < (0)> alors
  mettre [points_de_vie] à (0)
  envoyer à tous [game over]
fin

// Soins
quand je touche [Potion]
si <(points_de_vie) < (points_de_vie_max)> alors
  ajouter (30) à [points_de_vie]
  si <(points_de_vie) > (points_de_vie_max)> alors
    mettre [points_de_vie] à (points_de_vie_max)
  fin
fin

Barre de Santé Visuelle

// Sprite barre de santé
quand [drapeau vert] est cliqué
aller à x: (-200) y: (150)

répéter indéfiniment
  // Calculer le pourcentage
  mettre [pourcentage_vie] à (((points_de_vie) / (points_de_vie_max)) * (100))

  // Ajuster la taille de la barre
  mettre la taille à (pourcentage_vie) %

  // Changer la couleur selon la santé
  si <(pourcentage_vie) > (60)> alors
    mettre l'effet [couleur] à (70)  // Vert
  fin
  si <<(pourcentage_vie) > (30)> et <(pourcentage_vie) ≤ (60)>> alors
    mettre l'effet [couleur] à (30)  // Jaune
  fin
  si <(pourcentage_vie) ≤ (30)> alors
    mettre l'effet [couleur] à (0)   // Rouge
  fin
fin

3. Gestion des Niveaux

Progression de Niveau

// Variables de niveau
quand [drapeau vert] est cliqué
mettre [niveau] à (1)
mettre [expérience] à (0)
mettre [exp_requise] à (100)

// Gain d'expérience
quand je touche [Ennemi_Vaincu]
mettre [exp_gagnée] à (25)
ajouter (exp_gagnée) à [expérience]
dire (rejoindre [+] (rejoindre (exp_gagnée) [ EXP]))

// Vérification de montée de niveau
si <(expérience) ≥ (exp_requise)> alors
  ajouter (-1 * (exp_requise)) à [expérience]
  ajouter (1) à [niveau]
  mettre [exp_requise] à ((niveau) * (100))
  dire (rejoindre [Niveau ] (rejoindre (niveau) [ !])) pendant (3) secondes
  jouer le son [level_up]
fin

Difficulté Adaptative

// Ajustement selon le niveau
répéter indéfiniment
  // Vitesse des ennemis
  mettre [vitesse_ennemis] à ((niveau) + (2))

  // Fréquence d'apparition
  mettre [délai_spawn] à ((5) - ((niveau) * (0.2)))
  si <(délai_spawn) < (1)> alors
    mettre [délai_spawn] à (1)
  fin

  // Points de vie des ennemis
  mettre [vie_ennemis] à ((niveau) * (10))

  attendre (1) secondes
fin

4. Système d’Inventaire

Inventaire Simple

// Variables d'objets
quand [drapeau vert] est cliqué
mettre [épées] à (0)
mettre [potions] à (0)
mettre [clés] à (0)
mettre [pièces] à (50)

// Collecte d'objets
quand je touche [Épée]
ajouter (1) à [épées]
dire [Épée obtenue !] pendant (2) secondes

quand je touche [Potion]
ajouter (1) à [potions]
dire [Potion obtenue !] pendant (2) secondes

// Utilisation d'objets
quand la touche [p] est pressée
si <(potions) > (0)> alors
  ajouter (-1) à [potions]
  ajouter (50) à [points_de_vie]
  dire [Potion utilisée !] pendant (1) secondes
sinon
  dire [Pas de potions !] pendant (1) secondes
fin

Affichage d’Inventaire

// Sprite interface inventaire
quand [drapeau vert] est cliqué
aller à x: (150) y: (150)

répéter indéfiniment
  mettre [texte_inventaire] à [Inventaire:]
  mettre [texte_inventaire] à (rejoindre (texte_inventaire) (rejoindre [ Épées: ] (épées)))
  mettre [texte_inventaire] à (rejoindre (texte_inventaire) (rejoindre [ Potions: ] (potions)))
  mettre [texte_inventaire] à (rejoindre (texte_inventaire) (rejoindre [ Clés: ] (clés)))
  mettre [texte_inventaire] à (rejoindre (texte_inventaire) (rejoindre [ Pièces: ] (pièces)))

  dire (texte_inventaire)
  attendre (0.5) secondes
fin

5. Système de Temps

Chronomètre

// Temps de jeu
quand [drapeau vert] est cliqué
remettre le minuteur à zéro
mettre [temps_jeu] à (0)

répéter indéfiniment
  mettre [temps_jeu] à (arrondir (minuteur))
  mettre [minutes] à ((temps_jeu) / (60))
  mettre [secondes] à ((temps_jeu) mod (60))

  si <(secondes) < (10)> alors
    mettre [affichage_temps] à (rejoindre (arrondir (minutes)) (rejoindre [:0] (secondes)))
  sinon
    mettre [affichage_temps] à (rejoindre (arrondir (minutes)) (rejoindre [:] (secondes)))
  fin

  dire (rejoindre [Temps: ] (affichage_temps))
  attendre (0.1) secondes
fin

Compte à Rebours

// Temps limité
quand [drapeau vert] est cliqué
mettre [temps_restant] à (60)  // 60 secondes

répéter jusqu'à ce que <(temps_restant) ≤ (0)>
  dire (rejoindre [Temps: ] (temps_restant))
  attendre (1) secondes
  ajouter (-1) à [temps_restant]
fin

dire [Temps écoulé !]
envoyer à tous [fin de partie]

Listes et Tableaux

Créer une Liste

Création

1. Catégorie "Variables"
2. Cliquer "Créer une liste"
3. Nommer la liste (ex: "scores_élevés")
4. Choisir la portée
5. Cliquer "OK"

Opérations de Base

// Ajouter des éléments
ajouter [Joueur1] à [noms_joueurs]
ajouter (1250) à [scores_élevés]
ajouter [niveau1] à [niveaux_débloqués]

// Insérer à une position
insérer [Nouveau] à (1) de [ma_liste]

// Supprimer des éléments
supprimer (1) de [ma_liste]           // Premier élément
supprimer (longueur de [ma_liste]) de [ma_liste]  // Dernier élément
supprimer (tout) de [ma_liste]        // Vider la liste

// Remplacer un élément
remplacer l'élément (2) de [ma_liste] par [Nouvelle valeur]

Applications des Listes

1. Tableau des Scores

// Initialisation
quand [drapeau vert] est cliqué
supprimer (tout) de [top_scores]
ajouter (1000) à [top_scores]
ajouter (800) à [top_scores]
ajouter (600) à [top_scores]
ajouter (400) à [top_scores]
ajouter (200) à [top_scores]

// Nouveau score
définir [ajouter_score] (nouveau_score)
  mettre [position] à (1)
  répéter (longueur de [top_scores]) fois
    si <(nouveau_score) > (élément (position) de [top_scores])> alors
      insérer (nouveau_score) à (position) de [top_scores]
      si <(longueur de [top_scores]) > (5)> alors
        supprimer (6) de [top_scores]
      fin
      arrêter [ce script]
    fin
    ajouter (1) à [position]
  fin
fin

2. Inventaire Avancé

// Système d'objets avec quantités
quand [drapeau vert] est cliqué
supprimer (tout) de [objets]
supprimer (tout) de [quantités]

// Ajouter un objet
définir [ajouter_objet] (nom_objet) (quantité)
  si <[objets] contient (nom_objet)?> alors
    // Objet existe, augmenter la quantité
    mettre [index] à (1)
    répéter (longueur de [objets]) fois
      si <(élément (index) de [objets]) = (nom_objet)> alors
        mettre [ancienne_quantité] à (élément (index) de [quantités])
        remplacer l'élément (index) de [quantités] par ((ancienne_quantité) + (quantité))
        arrêter [ce script]
      fin
      ajouter (1) à [index]
    fin
  sinon
    // Nouvel objet
    ajouter (nom_objet) à [objets]
    ajouter (quantité) à [quantités]
  fin
fin

// Utiliser un objet
définir [utiliser_objet] (nom_objet)
  si <[objets] contient (nom_objet)?> alors
    mettre [index] à (1)
    répéter (longueur de [objets]) fois
      si <(élément (index) de [objets]) = (nom_objet)> alors
        mettre [quantité_actuelle] à (élément (index) de [quantités])
        si <(quantité_actuelle) > (0)> alors
          remplacer l'élément (index) de [quantités] par ((quantité_actuelle) - (1))
          dire (rejoindre (nom_objet) [ utilisé !])
        sinon
          dire (rejoindre [Pas de ] (rejoindre (nom_objet) [ !]))
        fin
        arrêter [ce script]
      fin
      ajouter (1) à [index]
    fin
  fin
fin

3. Système de Dialogue

// Dialogues avec choix multiples
quand [drapeau vert] est cliqué
supprimer (tout) de [dialogues_pnj]
ajouter [Bonjour, aventurier !] à [dialogues_pnj]
ajouter [Que puis-je faire pour toi ?] à [dialogues_pnj]
ajouter [1. Acheter des objets] à [dialogues_pnj]
ajouter [2. Vendre des objets] à [dialogues_pnj]
ajouter [3. Partir] à [dialogues_pnj]

// Affichage du dialogue
quand je reçois [parler_pnj]
mettre [ligne_dialogue] à (1)
répéter (longueur de [dialogues_pnj]) fois
  dire (élément (ligne_dialogue) de [dialogues_pnj]) pendant (3) secondes
  ajouter (1) à [ligne_dialogue]
fin

// Gestion des choix
demander [Votre choix (1, 2 ou 3) :] et attendre
si <(réponse) = [1]> alors
  envoyer à tous [ouvrir_boutique]
fin
si <(réponse) = [2]> alors
  envoyer à tous [vendre_objets]
fin
si <(réponse) = [3]> alors
  dire [À bientôt !] pendant (2) secondes
fin

4. Génération Procédurale

// Génération de niveaux aléatoires
quand [drapeau vert] est cliqué
supprimer (tout) de [carte_niveau]

// Créer une grille 10x10
répéter (100) fois
  mettre [type_case] à (nombre aléatoire entre (1) et (4))
  si <(type_case) = (1)> alors
    ajouter [sol] à [carte_niveau]
  fin
  si <(type_case) = (2)> alors
    ajouter [mur] à [carte_niveau]
  fin
  si <(type_case) = (3)> alors
    ajouter [trésor] à [carte_niveau]
  fin
  si <(type_case) = (4)> alors
    ajouter [ennemi] à [carte_niveau]
  fin
fin

// Affichage de la carte
mettre [x_carte] à (-200)
mettre [y_carte] à (150)
mettre [index_case] à (1)

répéter (10) fois  // Lignes
  répéter (10) fois  // Colonnes
    mettre [type_case] à (élément (index_case) de [carte_niveau])
    aller à x: (x_carte) y: (y_carte)

    si <(type_case) = [sol]> alors
      basculer sur le costume [sol]
    fin
    si <(type_case) = [mur]> alors
      basculer sur le costume [mur]
    fin
    // ... autres types

    estampiller
    ajouter (40) à [x_carte]
    ajouter (1) à [index_case]
  fin
  mettre [x_carte] à (-200)
  ajouter (-30) à [y_carte]
fin

Techniques Avancées

1. Sauvegarde de Données

Sauvegarde Simple

// Préparer les données pour la sauvegarde
définir [sauvegarder_jeu]
  supprimer (tout) de [sauvegarde]
  ajouter (score) à [sauvegarde]
  ajouter (niveau) à [sauvegarde]
  ajouter (points_de_vie) à [sauvegarde]
  ajouter (expérience) à [sauvegarde]
  dire [Jeu sauvegardé !] pendant (2) secondes
fin

// Charger les données
définir [charger_jeu]
  si <(longueur de [sauvegarde]) = (4)> alors
    mettre [score] à (élément (1) de [sauvegarde])
    mettre [niveau] à (élément (2) de [sauvegarde])
    mettre [points_de_vie] à (élément (3) de [sauvegarde])
    mettre [expérience] à (élément (4) de [sauvegarde])
    dire [Jeu chargé !] pendant (2) secondes
  sinon
    dire [Pas de sauvegarde trouvée !] pendant (2) secondes
  fin
fin

2. Structures de Données Complexes

Base de Données d’Objets

// Structure : nom|type|valeur|description
quand [drapeau vert] est cliqué
supprimer (tout) de [base_objets]
ajouter [Épée de fer|arme|25|Une épée solide] à [base_objets]
ajouter [Potion de soin|consommable|50|Restaure 50 PV] à [base_objets]
ajouter [Bouclier magique|armure|15|Réduit les dégâts] à [base_objets]

// Rechercher un objet
définir [chercher_objet] (nom_recherché)
  mettre [index] à (1)
  répéter (longueur de [base_objets]) fois
    mettre [données_objet] à (élément (index) de [base_objets])
    mettre [nom_objet] à (lettre (1) de (données_objet) jusqu'à [|])
    si <(nom_objet) = (nom_recherché)> alors
      dire (rejoindre [Trouvé: ] (données_objet))
      arrêter [ce script]
    fin
    ajouter (1) à [index]
  fin
  dire [Objet non trouvé]
fin

3. Optimisation des Performances

Mise en Cache

// Éviter les calculs répétitifs
mettre [cache_distance] à (-1)
mettre [dernière_position_x] à (abscisse x)
mettre [dernière_position_y] à (ordonnée y)

répéter indéfiniment
  // Recalculer seulement si la position a changé
  si <<non <(abscisse x) = (dernière_position_x)>> ou <non <(ordonnée y) = (dernière_position_y)>>> alors
    mettre [cache_distance] à (distance jusqu'à [Cible])
    mettre [dernière_position_x] à (abscisse x)
    mettre [dernière_position_y] à (ordonnée y)
  fin

  // Utiliser la valeur en cache
  si <(cache_distance) < (50)> alors
    // Action basée sur la distance
  fin
fin

Limitation des Mises à Jour

// Mettre à jour l'affichage moins fréquemment
mettre [compteur_affichage] à (0)
répéter indéfiniment
  ajouter (1) à [compteur_affichage]
  si <((compteur_affichage) mod (10)) = (0)> alors
    // Mise à jour de l'interface toutes les 10 frames
    dire (rejoindre [Score: ] (score))
  fin
fin

Débogage et Résolution de Problèmes

Techniques de Débogage

Affichage des Valeurs

// Mode debug
si <(mode_debug) = (1)> alors
  dire (rejoindre [Var1: ] (rejoindre (variable1) (rejoindre [ Var2: ] (variable2))))
fin

Historique des Changements

// Tracer les modifications
définir [modifier_variable] (nom_var) (nouvelle_valeur)
  ajouter (rejoindre (nom_var) (rejoindre [: ] (rejoindre (ancienne_valeur) (rejoindre [ -> ] (nouvelle_valeur))))) à [historique_debug]
  // Appliquer le changement
  mettre [variable] à (nouvelle_valeur)
fin

Erreurs Courantes

1. Variables Non Initialisées

// ❌ Problème
si <(score) > (100)> alors  // score pourrait être vide
  // Action
fin

// ✅ Solution
quand [drapeau vert] est cliqué
mettre [score] à (0)  // Toujours initialiser

2. Division par Zéro

// ❌ Problème
mettre [résultat] à ((a) / (b))  // b pourrait être 0

// ✅ Solution
si <non <(b) = (0)>> alors
  mettre [résultat] à ((a) / (b))
sinon
  mettre [résultat] à (0)
fin

3. Débordement de Listes

// ❌ Problème
mettre [élément] à (élément (index) de [ma_liste])  // index pourrait être invalide

// ✅ Solution
si <<(index) > (0)> et <(index) ≤ (longueur de [ma_liste])>> alors
  mettre [élément] à (élément (index) de [ma_liste])
sinon
  dire [Index invalide !]
fin

Bonnes Pratiques

Organisation

1. Noms descriptifs : Utilisez des noms clairs et explicites
2. Initialisation : Toujours initialiser les variables au début
3. Portée appropriée : Globale vs locale selon les besoins
4. Documentation : Commentez les variables complexes

Performance

1. Limitation des calculs : Évitez les calculs inutiles dans les boucles
2. Mise en cache : Stockez les résultats coûteux
3. Nettoyage : Supprimez les variables temporaires
4. Optimisation des listes : Limitez la taille des listes

Sécurité

1. Validation : Vérifiez les valeurs avant utilisation
2. Limites : Imposez des bornes aux variables
3. Gestion d’erreurs : Prévoyez les cas d’erreur
4. Cohérence : Maintenez la cohérence des données

Conclusion

Les variables et la gestion des données sont les fondements de la programmation interactive dans Scratch. En maîtrisant ces concepts, vous pouvez créer des projets sophistiqués avec des systèmes de score, des inventaires, des sauvegardes et bien plus encore.

Rappelez-vous que la clé du succès réside dans la planification et l’organisation. Commencez par des systèmes simples, testez fréquemment, et ajoutez progressivement de la complexité. Chaque projet vous permettra de mieux comprendre comment structurer et manipuler efficacement vos données.

Avec ces connaissances, vous êtes maintenant équipé pour créer des expériences de jeu riches et interactives qui captiveront votre audience !