Crée un bot Spyfall
Dans cette activité, les makers vont apprendre à créer un bot Discord de jeu “Spyfall” à travers un projet guidé. Ils découvriront également comment créer une flowchart décrivant le comportement attendu d’un programme et des notions de Programmation Orientée Objet.

Objectifs pédagogiques
Compétences techniques
- Créer un bot Discord qui gère un jeu
- Comprendre et utiliser la Programmation Orientée Objet
- Comprendre comment lire la documentation technique d’une bibliothèque
Compétences design
- Créer une flowchart pour définir le comportement attendu d’un programme
Compétences projet
- Mettre en pratique les notions vues lors des précédentes activités du module afin de créer un premier jeu sous forme de bot Discord
La place dans le module
Cette activité vient après l’activité Bases d’un bot Discord et avant l’activité Conception d’un bot Discord
Jour 1
Jour 2
Jour 3
Jour 4
Jour 5
1h
🤩
🤩
30 min
🤩
🤩
30 min
🤩
1h
🤩
Ressources
Ressources utiles tout au long de l’activité
- Code du bot Spyfall fini (pour les anims)
- Lire la documentation Discord
- [Lien externe] Documentation Discord.py
Segments 1 & 2
- Animer un Spyfall (pour les anims, si jamais il faut réexpliquer le jeu)
- Dossier Drive avec les images du jeu
- Les flowcharts (avec un exemple de flowchart)
- Flowchart de Spyfall
- [Lien externe] Whimsical
Segments 3 & 4
Segments 5 & 6
Matériel
- chaque maker doit avoir son propre compte Discord
- chaque maker doit avoir son propre compte Replit
Déroulé de l'activité
Segmentation de l’activité
- Segment 1 (1h) : Programmation (gestion des inscriptions)
- Segment 2 (30 min) : Flowchart du Spyfall
- Segment 3 (30 min) : Découverte de la POO
- Segment 4 (1h) : Programmation (logique du jeu)
- Segment 5 (1h) : Gestion des parties et Personnalisation
- Segment 6 (30 min) : Personnalisation – suite
Détail de l’activité
Segment 1 (1h) Programmation (gestion des inscriptions)
Introduction et rappels (10min)
Accueille tes makers et explique-leur que l’on va apprendre à créer un Spyfall – c’est le jeu que l’on a tous testé au début de ce module !
Si certains ne l’avaient pas testé (par exemple parce qu’ils étaient absents), tu peux demander aux makers présents d’expliquer ce qu’est Spyfall pour tout le monde, ou montrer rapidement le bot une seconde fois.
Tu peux également profiter de ce moment d’introduction pour faire quelques rappels, notamment :
- les imports nécessaires pour un bot Discord
- la création du bot avec l’instruction bot = commands.bot(…)
- l’instruction bot.run() à la fin de son code pour lancer son bot
- les commandes, que l’on reconnaît au fait qu’elles sont précédées du décorateur @bot.command(…)
Bases du bot (20min)
Si tu sens que tes makers sont suffisamment autonomes, demande aux makers de créer un nouveau projet Python sur Replit et de créer les “bases d’un bot”. Il s’agit juste de créer un bot avec un évènement on_ready() qui indique que le bot est prêt et une simple commande “ping” comme on l’a déjà vu !
Si tu penses que tes makers ne sont pas suffisamment autonomes, fais-le avec eux (en partageant ton écran).
Le but de cette partie est de s’assurer que les bases d’un bot Discord sont bien ancrées dans l’esprit des makers.
Profites-en aussi pour demander aux makers d’ajouter les images des cartes sur leur projet (en créant un dossier « images » et en y mettant toutes les images)


Gestion des inscriptions (30min)
Explique aux makers que le bot Spyfall peut être séparé en deux parties bien distinctes :
- la gestion des inscriptions (s’inscrire à une partie / se désinscrire / voir la liste des inscrits)
- la commande !jouer qui lance le jeu
On va commencer par la gestion des inscriptions :
- Demande aux makers comment on pourrait créer la commande !participer. Que doit faire cette commande ? Comment gérer la liste des inscrits ?
Normalement, les makers devraient mentionner l’utilisation d’un tableau ou d’un dictionnaire pour stocker les joueurs inscrits. - Crée avec les makers la commande !participer en les impliquant dans le processus de réflexion ! Pense à bien leur montrer les fonctions append() et remove() pour ajouter / enlever un élément au tableau.
Comme on n’a pas encore la commande !liste, on peut utiliser un print() pour afficher la liste des joueurs et vérifier que l’inscription fonctionne. - Montre qu’en l’état, on peut également lancer la commande depuis les messages privés ! Pour pallier ce problème, on utilisera le décorateur @command.guild_only(). Profites-en pour montrer la page ressource sur les décorateurs (pas besoin d’expliquer chaque décorateur, mais les makers doivent comprendre ce qu’est un décorateur et connaître l’existence de cette page)

Voilà à quoi devrait ressembler la commande !participer
Une fois que la commande !participer a été créée :
- Les makers peuvent maintenant créer la commande !quitter, qui est très similaire à la commande !participer
- Enfin, toujours de manière participative, créez ensemble la commande !liste qui affiche tous les joueurs inscrits. Les notions importantes à mettre en avant ici sont l’utilisation d’une boucle pour itérer à travers tous les inscrits ainsi que le markdown (par exemple \n permet d’indiquer un saut de ligne)

Segment 2 (30 min) Flowchart du Spyfall
Introduction (5min)
Demande aux makers s’ils savent ce qu’est une flowchart. Dans tous les cas, montre-leur un exemple (par exemple ici) en insistant sur les formes et couleurs : les débuts et fin de fonction ont une forme de pilule, les conditions ont une forme de losange…
Explique qu’ils vont devoir créer la flowchart de la commande !jouer sur Spyfall : que se passe-t-il quand quelqu’un lance la commande !jouer ?…
Création de la flowchart (25min)
On essaie de se remémorer tous ensemble de comment fonctionnait le bot Spyfall. Ouvre un document Whimsical et note toutes les “étapes” que mentionnent les makers (“répartir les rôles”, “afficher le message de début de partie”, etc.)
Précise aux makers que la priorité est de définir ce qui doit se passer quand on lance la commande !jouer – il n’est pas nécessaire d’ajouter à la flowchart tout ce qui concerne l’inscription à la partie !
Il est probable que les makers ne pensent pas à toutes les étapes, n’hésite donc pas à relancer le bot (sans faire de partie ensuite) pour que l’on puisse voir ce que le bot envoie comme message et en déduire les étapes manquantes !
À la fin de cette partie, tu devrais avoir une flowchart comme celle-ci :
(Ce document contient la flowchart de base qui nous intéresse, mais aussi une flowchart complète qui détaille également le fonctionnements des commandes pour s’inscrire / se désinscrire / etc.)
Segment 3 (30 min) Découverte de la POO
Introduction (15min)
Demande aux makers s’ils savent ce qu’est la Programmation Orientée Objet et si oui, de l’expliquer.
Explique aux makers qu’il s’agit de définir les structures de données dont on aura besoin, en utilisant cette page ressource :
Insiste sur les notions d’instance, de propriétés (variables) et de méthodes (fonctions). Il est important de prendre du temps sur la Programmation Orientée Objet : c’est un concept qui n’est pas facile à appréhender quand on ne le connaît pas.

- d’un Goomba (ennemi) dans Super Mario Bros → position, direction, marcher(), mourir()...
- d’une pièce dans Tetris → position, controlee_par_le_joueur (booléen pour savoir si le joueur contrôle la pièce), deplacer(), tourner()...
- d’un Creeper dans Minecraft → position, vie, marcher(), exploser()...
Création de la classe Carte (15min)
Expliquer que dans Spyfall, on aura une classe “Carte”. Demander aux makers ce qu’est une “carte” dans le jeu. Vous devriez alors en déduire ensemble la classe Carte :
- propriétés : texte, image
- méthodes : aucune (à part le constructeur)
Maintenant, il va falloir montrer aux makers la syntaxe à utiliser pour créer cette classe. Chaque maker crée alors un fichier carte.py sur son projet Replit (leur expliquer le principe “une classe = un fichier”).
Y créer la classe Carte avec les makers, en expliquant la syntaxe nécessaire et ce qu’est un constructeur.

Une carte dans Spyfall est juste une image accompagnée du nom (texte) du lieu
Tu peux t’aider de la page ressource correspondante pour expliquer la syntaxte aux makers.
Sur notre fichier carte.py, on va également créer deux variables :
- carte_espion, qui contiendra la carte de l’espion
- cartes, un tableau contenant toutes les autres cartes
Profites-en pour montrer comment instancier une carte avec la carte de l’espion, puis crée le tableau “cartes” avec les makers ! (même si ce dernier ne contiendra qu’une ou deux cartes pour commencer)
Enfin, montre comment on peut récupérer ces deux variables dans notre fichier main.py avec un import from carte import cartes, carte_espion.

Cette ligne de code permet de récupérer les variables cartes et carte_espion qui sont sur le fichier carte.py
Segment 4 (1h) Programmation (logique de jeu)
Définition des rôles, des lieux…(30min)
C’est le moment de créer la commande !jouer de notre bot qui lancera la partie !
En se basant sur la flowchart précédemment créée, écrire le code de cette commande :
- Vérification des inscrits : si aucun joueur n’est inscrit, envoyer un message d’erreur et arrêter la commande
- Pensez à préciser que le “if <tableau>” / “if not <tableau>” permet de vérifier si le tableau contient des éléments ou s’il est vide
- On définit les rôles (rappel de la fonction random.randint() ). C’est une étape qui requiert de la réflexion, il faut donc impliquer les makers pour qu’ils réfléchissent à comment on pourrait définir les rôles des joueurs !
- Tu peux par exemple écrire dans le code “espion =” et “detectives =” avec eux pour lancer la réflexion
(“Comment / avec quoi remplir ces variables ?”)
- Tu peux par exemple écrire dans le code “espion =” et “detectives =” avec eux pour lancer la réflexion
- On choisit aléatoirement la carte du lieu – c’est l’occasion de parler de la commande random.choice()
- On définit la durée de la partie en fonction du nombre de joueurs
- Pareil, implique les makers – il y a différentes façon de créer cette partie : avec l’utilisation de if, en créant un tableau contenant les différentes durées possibles, etc.
- Pareil, implique les makers – il y a différentes façon de créer cette partie : avec l’utilisation de if, en créant un tableau contenant les différentes durées possibles, etc.
Création et envoi des messages (30min)
Pour la suite de la commande, il s’agit essentiellement de créer et d’envoyer des messages.
On commence donc par créer le message à envoyer à l’espion. Crée d’abord un simple message (“Tu es l’espion”) envoyé en privé au joueur espion. Puis, avec les makers, intègre au fur et à mesure de la complexité dans le message : ajout de plusieurs lignes de texte en utilisant le caractère spécial \n, utilisation du Markdown pour ajouter du texte en gras, encadré…
Enfin, montre-leur comment envoyer un embed plutôt qu’un simple message pour que ce soit plus joli ! Notamment en ajoutant une image avec embed.set_image()
Profite de toute cette partie pour leur montrer la fiche ressource sur le Markdown et les embed :
Enfin, finir la commande !jouer en ajoutant les dernières étapes que l’on peut retrouver sur la flowchart :
- Envoi d’un message public pour dire que la partie commence (avec l’image montrant tous les lieux possibles)
- Choix aléatoire d’un premier joueur et envoi d’un message public pour dire que c’est le premier joueur
- Enfin, envoi des derniers messages (“Il reste une minute” et “Fin de la partie”) après un certain délai
- Pense à leur montrer l’instruction asyncio.sleep() qui permet d’attendre un certain nombre de secondes avant d’exécuter le reste du code !
Le bot Spyfall est alors fonctionnel ! Les makers peuvent alors profiter des 10 dernières minutes pour le tester 🙂
Segment 5 (1h) Gestion des parties et Personnalisation
Introduction (5min)
Le bot Spyfall est fini !
…mais on peut toujours l’améliorer 😉
Actuellement, on ne peut lancer qu’une partie de Spyfall à la fois. Explique aux makers que l’on va voir comment adapter le Spyfall pour qu’il puisse gérer plusieurs parties en même temps. Une fois qu’on aura découvert ça, les makers pourront personnaliser / améliorer leur jeu de Spyfall comme ils le souhaitent !
Lance le jeu du Plus ou Moins sur au moins deux salons différents et montre qu’il est possible d’avoir plusieurs parties en simultané.
Gestion des parties (25min)
Parcours avec les makers le jeu du Plus ou Moins et explique comment les différentes parties sont gérées. Les notions importantes sont :
- Toute la logique du jeu est contenue dans une classe Jeu (sur le fichier jeu.py) – ainsi on peut instancier plusieurs fois cette classe pour créer plusieurs parties !
- Les commandes sont elles toujours sur le fichier main.py, mais elles ne font qu’appeler la fonction correspondante sur la classe Jeu.
- Le dictionnaire parties se charge de stocker les différentes parties – il s’agit d’un dictionnaire avec comme clé l’identifiant du salon Discord et comme valeur l’instance de la classe Jeu correspondante
- Pense aussi à montrer sur la classe Jeu l’utilisation du mot-clé self pour que les variables et fonctions soient bien liées à l’instance du Jeu.
Autrement, ces variables / fonctions seraient des variables globales ou des variables de classe.
Qu’est-ce que cela veut dire ? Discutes-en avec tes makers 🙂
(une variable d’instance sera propre à chaque instance, alors qu’une variable de classe sera partagée par toutes les instances)
Il faudra coller les fonctions dans la classe Jeu, mais aussi s'assurer qu'elles sont appelées par des commandes qui, elles, seront dans la classe main.py (on peut simplement copier-coller la commande actuelle pour s'en servir comme base !)
Il faudra aussi penser à adapter les fonctions dans la classe Jeu : ajout du mot-clé self, initialisation de la variable "joueurs" dans le constructeur...

Personnalisation (partie 1) (30min)
Les makers auront donc maintenant 1h pour personnaliser / améliorer leur bot Spyfall. Cette partie permet donc aux makers de prendre en main le bot et de l’améliorer.
Prend 5 minutes pour leur montrer à nouveau la documentation Discord.py et comment la parcourir – ils pourront ainsi trouver les informations dont ils ont besoin pour améliorer leur code !
Voici quelques pistes que tu peux proposer aux makers pour personnaliser leur jeu de Spyfall :
- Ajouter des cartes – il reste des images de cartes qui n’ont pas été utilisées dans les images du projet. On peut ainsi ajouter ces cartes au jeu. On peut aussi télécharger de nouvelles images à ajouter à son projet !
- On peut personnaliser les messages envoyés en incluant les pseudos des joueurs, en ajoutant des images pour plus de dynamisme (par exemple, nos messages “Il reste 1 minute” et “Fin de la partie” gagneraient à être accompagnés d’une image)
Voici également quelques pistes pour améliorer le projet sur l’espace d’une heure :
- Ajouter la gestion des parties, comme on vient de le voir ! (Attention, cela peut bien prendre toute l’heure)
- Ajouter une commande !aide listant les commandes du bot
- Dans les messages privés envoyés aux joueurs, ajouter un exemple de question choisi au hasard que les joueurs pourront utiliser s’ils n’ont pas d’inspiration (“Qu’est-ce que tu préfères à propos de cet endroit ?” / “Comment es-tu arrivé.e ici ?” / etc.)
- Ajouter un argument optionnel pour la fonction !jouer qui permettrait de préciser la durée de partie souhaitée
- En plus / à la place de la liste des lieux sous forme d’image, envoyer la liste des lieux sous forme de texte (généré automatiquement à partir des cartes présentes dans le jeu)
Les makers sont donc plus en autonomie sur cette partie. Passe les voir pour s’assurer que tout va bien, et rappelle-leur qu’ils peuvent te demander de l’aide à tout moment.

Afin que tu puisses aider au mieux les makers, tu trouveras ici la liste des tâches à faire pour créer un Spyfall avec gestion des parties :
- On forke le template de partie
- On crée la variable d’environnement avec notre token (on copie le token depuis notre version de base de Spyfall)
- On récupère les images (elles sont présentes ici) ainsi que le fichier carte.py (qui contient notre classe Carte)
- On copie toutes nos commandes dans la classe Jeu, en enlevant les décorateurs (ce sera nos actions) et en ajoutant le paramètre self
- On crée les commandes correspondantes dans le fichier main.py, en redirigeant vers la bonne action à chaque fois. Pour cela, on copie-colle la commande existante et on change simplement le nom de la commande et l’action qui est appelée
- Il faut également initialiser les variables du Jeu dans le constructeur – c’est important pour que les variables soient considérées par le programme comme des variables d’instance et non de classe
(autrement, si la variable « joueurs » est une variable de classe, toutes les instances du jeu auront la même liste de participant.e.s…) - Enfin, il reste à corriger tout ce qui est souligné en rouge dans notre classe Jeu :
- certains imports sont manquants : import discord, import random, import asyncio, et l’import from carte import cartes, carte_espion
- La variable « joueurs » est manquante. On la remet donc dans la classe Jeu. Comme il s’agit maintenant d’une variable de classe, il faudra penser à remplacer joueurs par self.joueurs à chaque endroit où c’est souligné en rouge.
- De même, lancer_timer() doit avoir le paramètre self et on l’appelle donc avec self.lancer_timer(…)
Tu trouveras ici un exemple de Spyfall avec gestion des parties :
Tu seras ainsi plus à même d'aider les makers. De manière générale, garde à l'esprit :
- Les commandes seront présentes sur le fichier main.py, et elles appelleront l'action correspondante dans notre classe Jeu. Par exemple, la commande !jouer appelera l'action jouer()
- Toute la logique de notre jeu sera copiée-collée dans la classe Jeu. Cela implique quelques changements : nos fonctions et variables deviennent des fonctions et variables de classe, donc beaucoup de mots-clé "self" à ajouter

Segment 6 (30 min) Personnalisation – suite
Personnalisation (25min)
Les makers continuent à personnaliser / améliorer leur bot Spyfall. Profite simplement du fait qu’une demie-heure se soit écoulée pour demander à tout le monde si quelqu’un a besoin d’aide, s’il y a des questions…
Déclusion (5min)
Pense à finir cette activité par une déclusion :
- Avez-vous aimé cette activité ?
- Comment l’avez-vous ressenti ? Trop difficile, trop facile ?
- Des remarques ?…
Enfin, tu peux annoncer la suite du programme : on a maintenant toutes les bases pour créer nos propres bots Discord, donc pour l’activité suivante on réfléchira à des idées de bots à créer en groupes de 2-3 !
Tips
Tips truc
machin bidule
Tips truc
machin bidule