De Scratch Wiki en Français


Scratch devine ton username

Hey ! Cette fois, sur ce tutoriel, tout tournera autour d'un seul bloc. Voici un rapide aperçu de ce que nous allons faire :

  • Scratch va tenter de deviner le nom d'utilisateur du joueur
  • Il commencera par trouver la première lettre, voire la deuxième
  • Après un bref instant de réflexion, il trouvera plus ou moins le pseudonyme, se trompant d'une lettre
  • A la fin, le joueur a l'occasion de répondre que Scratch s'est trompé, bien que ce soit probablement faux X)

Et voilà ! Si ça t'intéresse, tu peux lire la suite ! Sinon... ben... pourquoi avoir lu cet article ?

La base du projet

Autant le révéler tout de suite, c'est autour de ce bloc que le projet tournera, donc :

(nom d'utilisateur)

Mais un projet n'étant constitué que de cela :

quand le drapeau vert pressé
dire (nom d'utilisateur)

Serait assez... incomplet, disons ^^

C'est pourquoi je te propose déjà d'utiliser les questions/réponses. Le joueur se sent plus impliqué dans le programme, c'est toujours plus agréable. Ensuite, un point d'interrogation est le bienvenu, et pour cela tu peux utiliser un regroupe. Voici le résultat :

quand le drapeau vert pressé
demander (regroupe (nom d'utilisateur) [ ?]) et attendre

N'oublie pas l'espace avant le point d'interrogation !

Hésitation

Scratch doit maintenant procéder par étapes. Ajoute donc ce groupe dans ton script :

demander (regroupe (lettre (1) de (nom d'utilisateur)) [ est-elle la première lettre ?]) et attendre

Toujours sans oublier l'espace.

Comme ça, le lutin va donner l'impression de deviner par étape le pseudonyme. D'abord la première lettre, la deuxième si tu le souhaites (mais là, c'est inutile de te montrer le script, non ?).

Erreur

On en est donc à ça (si tu t'es contenté de la première lettre) :

quand le drapeau vert pressé
demander (regroupe (lettre (1) de (nom d'utilisateur)) [ est-elle la première lettre ?]) et attendre
demander (regroupe (nom d'utilisateur) [ ?]) et attendre

On va ajouter une erreur, comme ça, le programme sera plus réaliste. Disons qu'il va se tromper sur une lettre aléatoire. On va utiliser une liste. Il y a d'autres moyens, mais celui-là est la premier auquel j'ai pensé X) Attention, il est long, donc...

mettre [lettre v] à [1]
répéter (longueur de (nom d'utilisateur)) fois
ajouter (lettre (lettre) de (nom d'utilisateur)) à [liste v]
ajouter à [lettre v] (1)
end
remplacer l'élément (nombre aléatoire entre (1) et (longueur de [liste v])) de la liste [liste v] par [a]
mettre [lettre v] à []
répéter (longueur de (liste)) fois
mettre [lettre v] à (regroupe (lettre) (élément (1 v) de [liste v])
supprimer l'élément (1 v) de la liste [liste v]
end

Détaillons ce script :

La variable lettre sera "recyclée", dans ce script. C'est-à-dire que nous l'utiliserons pour différentes utilités :

  • La première fois, elle sert de compteur, elle permet de basculer d'une lettre à une autre dans le nom d'utilisateur.
  • Ensuite, on s'en sert pour regrouper le contenu de la liste en une seule variable.

Dans la première boucle, nous allons :

  • Décomposer le nom d'utilisateur.
  • Inscrire chaque lettre dans une ligne de la liste lui correspondant.

Par exemple, dans "Zelda", cela donnera :

  • Z = 1
  • E = 2
  • L = 3
  • etc...

Passons à la seconde boucle. Cette fois, l'objectif est de :

  • Regrouper tous les éléments de la liste en une seule entrée.
  • Vider la liste au fur et à mesure.

Et enfin, entre les deux boucles, nous choisissons un élément au hasard dans la liste et le remplaçons par "a" à l'aide de ce bloc :

remplacer l'élément (nombre aléatoire entre (1) et (longueur de [liste v])) de la liste [liste v] par [a]

Mais au lieu de mettre "a", dans la petite entrée à la fin, nous pouvons mettre une lettre de l'alphabet au hasard :

(lettre (nombre aléatoire entre (1) et (26)) de [azertyuiopqsdfghjklmwxcvbn])

On peut rajouter des chiffres, des symboles, etc... et changer le "26" par la même occasion !

Maintenant, le lutin doit (bien évidemment) prononcer l'erreur ! Ce script sera utile :

demander (regroupe (lettre) [ ?]) et attendre

Désormais, ajoutons ce script créé au programme :

quand le drapeau vert pressé
demander (regroupe (lettre (1) de (nom d'utilisateur)) [ est-elle la première lettre ?]) et attendre
mettre [lettre v] à [1]
répéter (longueur de (nom d'utilisateur)) fois
ajouter (lettre (lettre) de (nom d'utilisateur)) à [liste v]
ajouter à [lettre v] (1)
end
remplacer l'élément (nombre aléatoire entre (1) et (longueur de [liste v])) de la liste [liste v] par [a]
mettre [lettre v] à []
répéter (longueur de (liste)) fois
mettre [lettre v] à (regroupe (lettre) (élément (1 v) de [liste v])
supprimer l'élément (1 v) de la liste [liste v]
end
demander (regroupe (lettre) [ ?]) et attendre
demander (regroupe (nom d'utilisateur) [ ?]) et attendre

Voilà ! Reprenons l'exemple de "Zelda", le lutin dira peut-être donc :

  • z est-elle la première lettre ? (en effet, la première lettre est un z)
  • zalda ? (il a compté la deuxième lettre et l'a changée par le "a")
  • zelda ? (voilà, il dit le nom sans erreur)

Réponse de l'utilisateur

Créons désormais un script de réponse de l'utilisateur. Deux façons de procéder : la manière oui/non, et la manière liste.

Manière oui/non

Avec cette méthode, plus rapide, seules les réponses "oui" et "non" seront prises en compte. C'est très facile, voici le petit script à intégrer après chaque "demander".

demander (phrase :: operators) et attendre // ce bloc "phrase" n'existe pas
si <(réponse) = [oui]> alors
dire (réponse du lutin si la réponse est affirmative :: grey) pendant (5) secondes // là encore, un bloc inexistant
end
si <(réponse) = [non]> alors
dire (réponse du lutin si la réponse est négative :: grey) pendant (5) secondes // voilà, vous avez compris
end

Par exemple, je veux créer un script permettant au joueur de répondre "oui" ou "non" à la question "Aimez-vous les bonbons ?" (oui, je suis à cours d'idées). Si le joueur répond oui, alors le lutin répond que lui aussi, il aime les bonbons. Si le joueur répond non, le lutin dit que chacun ses goûts.

demander [Aimez-vous les bonbons ?] et attendre // La question
si <(réponse) = [oui]> alors
dire [Moi aussi !] pendant (5) secondes // Réponse du lutin si le joueur aime
end
si <(réponse) = [non]> alors
dire [Chacun ses goûts !] pendant (5) secondes // Réponse du lutin si le joueur n'aime pas
end

Procédons de cette façon pour chaque question du lutin dans notre script actuel. Pour gagner du temps, va dans "Ajouter Bloc", et crée ce bloc :

question [question] si oui [réponse oui] si non [réponse non] :: custom

C'est bon ? Maintenant, définis la commande de cette façon :

définir question [question] si oui [réponse oui] si non [réponse non]
demander (question) et attendre
si <(réponse) = [oui]> alors
dire (réponse oui) pendant (5) secondes
end
si <(réponse) = [non]> alors
dire (réponse non) pendant (5) secondes
end

Retournons à notre code :

quand le drapeau vert pressé
question (regroupe (lettre (1) de (nom d'utilisateur)) [est-elle la première lettre ?]) si oui [Ouf, je le savais !] si non [Quoi ? N'importe quoi, je suis sûr que c'est ça !] :: custom
mettre [lettre v] à [1]
répéter (longueur de (nom d'utilisateur)) fois
ajouter (lettre (lettre) de (nom d'utilisateur)) à [liste v]
ajouter à [lettre v] (1)
end
remplacer l'élément (nombre aléatoire entre (1) et (longueur de [liste v])) de la liste [liste v] par [a]
mettre [lettre v] à []
répéter (longueur de (liste)) fois
mettre [lettre v] à (regroupe (lettre) (élément (1 v) de [liste v])
supprimer l'élément (1 v) de la liste [liste v]
end
question (regroupe (lettre) [ ?]) si oui [Ah bon ??? Il me semblait avoir faux.] si non [C'est ce qu'il me semblait.] :: custom
question (regroupe (nom d'utilisateur) [ ?]) si oui [Génial !] si non [Menteur !] :: custom

Désolée des éléments coupés...

Mais cette manière ne permet qu'un nombre très limité de réponses. Voyons la seconde...

Manière liste

Crée deux listes : réponses affirmatives, réponses négatives. Tu peux les remplir en inscrivant dans chacune une dizaine de réponses affirmatives et négatives. Cela peut donner :

Réponses affirmatives :

  • Oui
  • Ouais
  • Oui !
  • Mouais
  • Oui.
  • Yes
  • Yes !
  • C'est ça
  • C'est vrai
  • etc...

Réponses négatives :

  • Non
  • Nan
  • Pas du tout !
  • C'est faux
  • Non !
  • Non.
  • etc...

Et voyons un peu le bloc créé "demander, etc...". Change le code de cette façon :

définir question [question] si oui [réponse oui] si non [réponse non]
demander (question) et attendre
si <[réponses affirmatives v] contient (réponse)> alors
dire (réponse oui) pendant (5) secondes
end
si <[réponses négatives v] contient (réponse)> alors
dire (réponse non) pendant (5) secondes
end

Grâce au script précédent, elle a l'air simple, mais elle plus longue à faire. Tu peux ensuite rajouter un petit script de cette façon, pour qu'un joueur ayant dit une réponse inconnue ne se retrouve pas sans aucune réponse en retour :

définir question [question] si oui [réponse oui] si non [réponse non]
demander (question) et attendre
si <[réponses affirmatives v] contient (réponse)> alors
dire (réponse oui) pendant (5) secondes
end
si <[réponses négatives v] contient (réponse)> alors
dire (réponse non) pendant (5) secondes
end
si <<non <[réponses affirmatives v] contient (réponse)>> et <non <[réponses négatives v] contient (réponse)>>> alors
dire [Réponse inconnue ; propose-la dans les commentaires !] pendant (5) secondes

Résultat

A moins que tu ne souhaites améliorer ce script (ce que je te conseille ;) ), tu as fini ! Tu peux essayer, pour voir si le projet marche bien. Si ce n'est pas le cas, vérifie que tu as bien écrit tout le script !

Cet article fait partie de la catégorie des tutos
Tous les articles de cette catégorie:
Enquête.png
Enquête de Satisfaction

Nous effectuons pour le moment des enquêtes de satisfaction. Nous aimerions entendre ce que vous pensez à propos du Wiki.

Pour répondre à l'enquête, cliquez ici.