Source: Scratch Wiki en français


Scratch devine ton nom d'utilisateur


Voilà un tutoriel ou cette fois, tout tournera autour d'un seul bloc mais il va être expliqué en détails ce qu'il est possible de faire avec. Voici un rapide aperçu de ce que nous allons faire :

  • Scratch va tenter de deviner le nom d'utilisateur de l'utilisateur du projet ;
  • 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 ;
  • À la fin, le joueur a l'occasion de répondre que Scratch s'est trompé, bien que cela est probablement faux.

Si cela peut vous intéresser en sachant ce que nous allons faire, après avoir lu ce cours résumé, vous pouvez maintenant découvrir le tutoriel commençant ci-dessous. Nous allons procéder en créant un nouveau projet.

La base du projet

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

(nom d'utilisateur)

Mais un projet n'étant constitué que du script ci-dessous serait plutôt simple.

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

C'est pourquoi il va être proposé d'utiliser premièrement des questions/réponses. L'utilisateur du projet se sentira plus impliqué dans le programme, c'est toujours plus agréable que de voir uniquement notre nom d'utilisateur s'afficher automatiquement. Ensuite, un point d'interrogation est donc le bienvenu, afin de poser une question, et pour cela il est possible d'utiliser un bloc pour regrouper. Voici le résultat :

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

Il ne faut pas oublier de laisser un espace avant le point d'interrogation.

Hésitation

Scratch doit maintenant procéder par étapes. Il va maintenant falloir ajouter ce programme dans ton script actuel :

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

Toujours sans oublier le fameux espace avant le point d'interrogation.

Comme ça, le sprite pourra donner l'impression de deviner par étape le pseudonyme. D'abord la première lettre, la deuxième si vous le souhaitez dans votre projet (mais là, ce n'est pas forcément utile de montrer le script, il aurait simplement été le même en changeant "lettre 1" en "lettre 2" et en changeant aussi le mot dans la question)...

Erreur

Nous sommes donc déjà arrivé à réaliser ce programme (si vous vous êtes contenté de la première lettre) :

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

Nous allons ajouter une erreur, comme ça, le programme sera plus réaliste et permettra à l'utilisateur de pouvoir donner une autre et deuxième réponse. Disons qu'il va se tromper sur une lettre aléatoire. Ainsi, pour faire cela, nous allons utiliser une liste. Il y a d'autres moyens, mais celui-ci est l'un des plus logique à mettre en place. Attention, il est par contre long, le voici à la suite :

mettre [lettre v] à [1]
répéter (longueur de (nom d'utilisateur)) fois
ajouter (lettre (lettre) de (nom d'utilisateur)) à [liste v]
ajouter (1) à [lettre v]::variables
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] à (regrouper (lettre) et (élément (1 v) de [liste v])
supprimer l'élément (1) de [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, avec le mot "Zelda", cela donnera :

  • Z = 1
  • E = 2
  • L = 3
  • D = 4
  • A = 5

Passons à la seconde boucle de ce script. Cette fois-ci, 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])

Nous pouvons aussi rajouter des chiffres, des symboles, etc. et changer le "26" par la même occasion.

Maintenant, le sprite devrait sans aucun problème prononcer l'erreur en utilisant le script que nous avons fait. Ce script sera de même utile :

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

Désormais, ajoutons ce script créé au programme déjà présent :

quand le drapeau vert pressé
demander (regrouper (lettre (1) de (nom d'utilisateur)) et [ 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 (1) à [lettre v]::variables
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] à (regrouper (lettre) et (élément (1 v) de [liste v])
supprimer l'élément (1 v) de [liste v]
end
demander (regrouper (lettre) et [ ?]) et attendre
demander (regrouper (nom d'utilisateur) et [ ?]) et attendre

Voilà ! Reprenons l'exemple de "Zelda", le sprite 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 alors le nom sans erreur)

Réponse de l'utilisateur

Créons désormais un script permettant à l'utilisateur de donner une reponse. Deux façons de procéder : la manière oui/non, et la manière liste acceptant un plus grand nombre de réponses et étant donc plus ouverte.

Manière oui/non

Avec cette méthode, plus rapide, seules les réponses "oui" et "non" seront prises en compte. C'est assez facile à faire, 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 sprite 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 sprite si la réponse est négative :: grey) pendant (5) secondes // voilà, vous avez compris
end

Par exemple, si nous voulons créer un script permettant au joueur de répondre "oui" ou "non" à la question posée, par exemple : "Aimez-vous les bonbons ?". Si le joueur répond oui, alors le sprite pourrait répondre que lui aussi, il aime les bonbons et nous pouvons aussi ajouter du "caractère" à la réponse avec des "Ah" et "Oh" au début de la phrase. Si l'utilisateur répond alors non, le sprite pourrait dire chacun ses goûts. Ce ne sont que des exemples de réponses, celles-ci sont bien sûr personnalisables.

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

Procédons de cette façon pour chaque question du sprite dans notre script actuel. Pour gagner du temps, aller dans la section "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 (regrouper (lettre (1) de (nom d'utilisateur)) et [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 (1) à [lettre v]::variables
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] à (regrouper (lettre) et (élément (1 v) de [liste v])
supprimer l'élément (1 v) de [liste v]
end
question (regrouper (lettre) et [ ?]) si oui [Ah bon ??? Il me semblait avoir faux.] si non [C'est ce qu'il me semblait.] :: custom
question (regrouper (nom d'utilisateur) et [ ?]) si oui [Génial !] si non [Menteur !] :: custom

Nous sommes désolé pour les scripts trop longs qui ne sont pas visibles en entier, vous pouvez par contre voir le reste de la zone en glissant avec votre ponteur de souris ou avec votre doigt sur certains appareils.

Par contre, cette manière ne permet qu'un nombre très limité de réponses. La seconde donne plus de liberté à l'utilisateur.

Manière liste

Il faut alors créer deux listes : une pour les réponses affirmatives ainsi qu'une autre pour les réponses négatives. Il est possible les remplir en inscrivant (en utilisant le bloc pour ajouter un élement ou en faisant l'action directement sur l'interface de la liste) 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...". Il faut changer 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. Nous pouvons encore ensuite rajouter un petit script de cette façon, pour qu'un utilisateur 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

À moins que vous ne souhaitez pas améliorer ce script (en ajoutant certaines possibilités mises en place de différentes façons), ce que nous voulions dire dans ce tutoriel a été dit ! Vous pouvez essayer, pour voir si le projet fonctionne bien. Si ce n'est pas le cas, vérifiez que tout le script a été écrit correctement.


Ci-dessus est un projet qui met en oeuvre de nombreuses choses que nous avons expliquées dans ce tutoriel. Pour un fonctionnement optimal du projet, veuillez l'utiliser sur sa page du site Scratch ici.

Cet article fait partie de la catégorie des tutos
Tous les articles de cette catégorie :