Comprendre les Cogs avec discord.py

Dans la partie précédente, on a vu comment créer des commandes hybrides (Partie 6)

Dans cet article, on va apprendre à utiliser les Cogs pour structurer et organiser un bot Discord de manière modulaire.

Les Cogs permettent de séparer les fonctionnalités du bot en différents fichiers, ce qui améliore la lisibilité et la maintenance du code, surtout dans le cas de projets complexes. Voici ce que nous couvrirons :

C’est quoi un Cog ?

Les Cogs sont un moyen efficace d’organiser le code d’un bot Discord en séparant les différentes commandes et événements dans des classes distinctes.

Cela est particulièrement utile dans les projets comportant de nombreuses commandes, comme les bots généralistes.

En structurant le bot avec des Cogs, chaque fonctionnalité peut être isolée dans son propre fichier Python, rendant le projet plus modulaire et facile à maintenir.

Transformer des fichiers de bots en Cogs

Pour illustrer l’utilité des Cogs, imaginons un bot qui contient plusieurs fonctionnalités réparties dans différents fichiers. Par exemple, un fichier games.py contenant des commandes liées aux jeux et un fichier modération.py contenant des commandes de gestion des utilisateurs. Nous allons transformer ces fichiers en Cogs pour mieux les organiser.

Exemple : Transformation du fichier games.py en Cog

Nous avons un fichier games.py qui contient deux commandes :

• Une commande roll, qui simule un lancer de dé, renvoie un nombre entre 1 et 6.
• Une commande hybride pile_ou_face, qui peut être appelée avec un préfixe ou via une commande slash.

Voici comment transformer ce fichier en Cog :

1. Créer une classe GamesCog qui hérite de commands.Cog.
2. Ajouter un constructeur qui prend en paramètre le bot et l’assigne à self.bot.
3. Convertir les commandes en méthodes de classe en ajoutant self comme premier paramètre.
4. Ajouter une méthode setup pour charger le Cog dans le bot.

Voici un extrait du code modifié :

from discord.ext import commands
import random

class GamesCog(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.command()
    async def roll(self, ctx):
        result = random.randint(1, 6)
        await ctx.send(f'{ctx.author} a lancé un dé et obtenu {result}.')

    @commands.command()
    async def pile_ou_face(self, ctx):
        result = random.choice(['pile', 'face'])
        await ctx.send(f'{ctx.author} a obtenu {result}.')

async def setup(bot):
    await bot.add_cog(GamesCog(bot))

Cog de commandes de jeu

Dans ce Cog, nous avons deux commandes de jeu : une pour lancer un dé et une pour jouer à pile ou face. Ces commandes sont regroupées dans une classe GamesCog, ce qui permet de maintenir le code de manière propre et organisée.

Cog de modération

Un autre fichier modération.py contient une commande pour expulser un utilisateur. Voici comment transformer ce fichier en Cog :

1. Créer une classe ModerationCog qui hérite de commands.Cog.
2. Ajouter un décorateur pour vérifier si l’utilisateur a les permissions nécessaires pour expulser un membre.
3. Ajouter une méthode setup pour ajouter ce Cog au bot.

Extrait du code :

from discord.ext import commands
import discord

class ModerationCog(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.command()
    @commands.has_permissions(kick_members=True)
    async def kick(self, ctx, member: discord.Member, reason=None):
        await member.kick(reason=reason)
        await ctx.send(f'{member.display_name} a été exclu du serveur.')

async def setup(bot):
    await bot.add_cog(ModerationCog(bot))

Fichier de chargement de Cogs

Nous avons maintenant deux Cogs : GamesCog et ModerationCog. Pour les intégrer dans notre bot, nous devons créer un fichier principal, start.py, qui va charger ces Cogs et démarrer le bot.

Dans ce fichier, nous créons une classe MyBot qui hérite de commands.Bot. Nous utilisons une boucle pour charger automatiquement les Cogs depuis un dossier. Voici comment procéder :

import discord
from discord.ext import commands

class MyBot(commands.Bot):
    async def setup_hook(self):
        for extension in ['cogs.games', 'cogs.moderation']:
            await self.load_extension(extension)

bot = MyBot(command_prefix="!", intents=discord.Intents.default())

async def main():
    async with bot:
        await bot.start('YOUR_TOKEN_HERE')

bot.run()

Lancement du bot

Pour démarrer le bot, exécutez simplement le fichier start.py. Ce fichier va charger les Cogs définis dans le dossier cogs et démarrer le bot avec les fonctionnalités définies dans les Cogs.

Conclusion

Grâce aux Cogs, nous avons réussi à organiser notre bot Discord de manière modulaire. Cette méthode est idéale pour les projets complexes, car elle facilite la gestion et l’extension du bot. Vous pouvez désormais ajouter autant de Cogs que nécessaire pour enrichir les fonctionnalités de votre bot.

Maintenant que vous savez comment utiliser les Cogs, on peut passer à la partie suivante, l’hébergement d’un bot discord.

Lire la suite du tutoriel bot discord en python avec discord.py (Partie 8)