Un bot musical avec discord js

52 commentaires Connaissances de dev, Histoires de dev Dev14 août 20206 octobre 2021Discord, DiscordJS, music

Cet article remplace mon précédent article « Un music bot avec Discord.js en 5 minutes ! » qui utilisait un paquet npm devenu aujourd’hui obsolète.
Je vous propose donc de suivre cette nouvelle méthode afin de créer vous même votre propre bot musical.
L’avantage de cette technique est que vous contrôlez tout de A à Z, tout n’est plus fait de façon automatique comme dans le précédent tuto.

Comme mon précédent article, je vous laisse suivre le tuto « Discord Js: Créer votre propre bot » afin d’avoir une base de travail.

Sans plus attendre, initialisons notre projet !

Bob l'éponge et son bot musical — Place à la musique !

Installation des dépendances

Avant toute chose, discord.js demande au minimum la version 16.6.0 de node, pensez à bien l’installer avant de vous lancer dans le projet !

Tout d’abords, rendons nous dans le dossier de notre bot que vous obtenez après avoir suivi le tuto « Discord Js: Créer votre propre bot« .

Une fois à l’intérieur, nous allons installer les dépendances nécessaire pour que tout fonctionne:

npm install discord.js ffmpeg fluent-ffmpeg ffmpeg-static @discordjs/opus ytdl-core --save

Configuration

Nous allons déplacer les constantes de configuration dans un fichier qui s’appellera config.json et que l’on placera à côté de notre fichier index.js.
On va donc y définir deux valeurs: prefix et token.
Prefix correspond au caractère devant préfixer les commandes du bot pour être reconnues.
Token correspond au token discord obtenu pendant la création du bot sur le site de discord.

Voici le contenu du fichier config.json:

{
  "prefix": "&",
  "token": "votre-token"
}

Place au code de notre bot musical

Tout se passe désormais dans le fichier index.js.
Dans un premier temps, importons les dépendances dont nous aurons besoin:

const Discord = require('discord.js');

/// DÉBUT NOUVEAU 
const { Client, Intents } = require('discord.js');

const { prefix, token} = require('./config.json');
const ytdl = require('ytdl-core');

const client = new Discord.Client({ intents: [Intents.FLAGS.GUILDS, Intents.FLAGS.GUILD_MESSAGES] });
/// FIN NOUVEAU

Puis nous allons devoir traiter les différentes commandes de l’utilisateur, pour cela on reprend notre code (celui du ping) existant et on l’améliore:

client.on('message', msg => {
  if (msg.content === 'ping') {
    msg.reply('pong');
  }
});

Deviens donc dans un premiers temps:

client.on('message', msg => {
     if (msg.author.bot) return;
     if (!msg.content.startsWith(prefix)) return;

});

Ici on ignore le message si celui viens de notre bot ou si il ne commence pas par notre préfixe.
On créer ensuite une constante représentant la queue du serveur discord grâce à l’id de la guild que l’on récupère sur le message:

const serverQueue = queue.get(message.guild.id);

On continue en en traitant les différentes commandes de notre bot:

if (message.content.startsWith(`${prefix}play`)) {
    // Code pour la commande play
    return;
} else if (message.content.startsWith(`${prefix}skip`)) {
    // Code pour la commande skip
    return;
} else if (message.content.startsWith(`${prefix}stop`)) {
    // Code pour la commande skip
    return;
} else {
    message.channel.send("Vous avez entrez une commande invalide !");
}

Nous remplirons par la suite le code pour chaque commande, préparons avant ça la variable qui représentera la queue de musique.
On créer donc une variable queue de type map:

const Discord = require("discord.js");
const { prefix, token } = require("./config.json");
const ytdl = require("ytdl-core");

const client = new Discord.Client();

// NOUVEAU
const queue = new Map();

Pour information, un objet de type map est itérable dans l’ordre d’arrivé de ses éléments. C’est parfait dans le cas d’une queue de musique à lire !
Vous pouvez consulter la documentation à cette adresse.

Créons ensuite une fonction qui sera appelée lorsque le bot devra jouer une musique. Dans un premier temps, vérifions deux points:

L’utilisateur est bien dans un salon vocal
Le bot possède bien les permissions de se connecter au salon vocal et d’y parler

Voici ce que cela donne:

async function execute(message, serverQueue) {
  const args = message.content.split(" "); // On récupère les arguments dans le message pour la suite

  const voiceChannel = message.member.voice.channel;
  if (!voiceChannel) // Si l'utilisateur n'est pas dans un salon vocal
    return message.channel.send(
      "Vous devez être dans un salon vocal!"
    );
  const permissions = voiceChannel.permissionsFor(message.client.user); // On récupère les permissions du bot pour le salon vocal
  if (!permissions.has("CONNECT") || !permissions.has("SPEAK")) { // Si le bot n'a pas les permissions
    return message.channel.send(
      "J'ai besoin des permissions pour rejoindre le salon et pour y jouer de la musique!"
    );
  }
}

On continue, toujours dans la fonction execute, on récupère les informations de la musique passé en argument dans le message.
On utilise le paquet ytdl pour récupérer les infos de youtube.
Seuls le titre et l’url de la vidéo nous intéresse, on les stock donc dans une variable song:

const songInfo = await ytdl.getInfo(args[1]);
const song = {
 title: songInfo.videoDetails.title,
 url: songInfo.videoDetails.video_url,
};

Nous ajoutons ensuite la musique à notre queue de musique, voyons d’abord le cas où serverQueue existe:

if (!serverQueue) {

}else {
 serverQueue.songs.push(song);
 console.log(serverQueue.songs);
 return message.channel.send(`${song.title} has been added to the queue!`);
}

Maintenant si serverQueue n’existe pas, on le créer, on l’ajoute à la queue global et on push la musique dedans.
Ensuite on connecte le bot au salon vocal et on lance la musique:

const queueConstruct = {
 textChannel: message.channel,
 voiceChannel: voiceChannel,
 connection: null,
 songs: [],
 volume: 1,
 playing: true,
};

// On ajoute la queue du serveur dans la queue globale:
queue.set(message.guild.id, queueConstruct);
// On y ajoute la musique
queueContruct.songs.push(song);

try {
 // On connecte le bot au salon vocal et on sauvegarde l'objet connection
 var connection = await voiceChannel.join();
 queueContruct.connection = connection;
 // On lance la musique
 play(message.guild, queueContruct.songs[0]);
} catch (err) {
 //On affiche les messages d'erreur si le bot ne réussi pas à se connecter, on supprime également la queue de lecture
 console.log(err);
 queue.delete(message.guild.id);
 return message.channel.send(err);
}

Jouer une musique

On va implémenter la fonction appelé lorsque l’utilisateur tape la commande play.
Tout d’abord on va compléter le passage où l’on surveille les différentes commandes tapées par l’utilisateur en y rajoutant nos appels de fonction:

if (message.content.startsWith(`${prefix}play`)) {
    execute(message, serverQueue); // On appel execute qui soit initialise et lance la musique soit ajoute à la queue la musique
    return;
  } else if (message.content.startsWith(`${prefix}skip`)) {
    skip(message, serverQueue); // Permettra de passer à la musique suivante
    return;
  } else if (message.content.startsWith(`${prefix}stop`)) {
    stop(message, serverQueue); // Permettra de stopper la lecture
    return;
  } else {
    message.channel.send("You need to enter a valid command!");
  }

Voici le contenu de la fonction play:

function play(guild, song) {
  const serverQueue = queue.get(guild.id); // On récupère la queue de lecture
  if (!song) { // Si la musique que l'utilisateur veux lancer n'existe pas on annule tout et on supprime la queue de lecture
    serverQueue.voiceChannel.leave();
    queue.delete(guild.id);
    return;
  }

// On lance la musique 
  const dispatcher = serverQueue.connection
    .play(ytdl(song.url, { filter: 'audioonly' }))
    .on("finish", () => { // On écoute l'événement de fin de musique
      serverQueue.songs.shift(); // On passe à la musique suivante quand la courante se termine 
      play(guild, serverQueue.songs[0]);
    })
    .on("error", error => console.error(error));
  dispatcher.setVolume(serverQueue.volume); // On définie le volume
  serverQueue.textChannel.send(`Démarrage de la musique: **${song.title}**`);
}

Passer une musique

C’est maintenant le tour de la fonction skip:

function skip(message, serverQueue) {
  if (!message.member.voice.channel) // on vérifie que l'utilisateur est bien dans un salon vocal pour skip
    return message.channel.send(
      "Vous devez être dans un salon vocal pour passer une musique!"
    );
  if (!serverQueue) // On vérifie si une musique est en cours
    return message.channel.send("Aucune lecture de musique en cours !");
  serverQueue.connection.dispatcher.end(); // On termine la musique courante, ce qui lance la suivante grâce à l'écoute d'événement finish
}

Stopper la lecture

La fonction stop enfin ! Elle est quasiment la même que celle pour passer une musique.
On vide juste la liste des musique avant de terminer la courante:

function stop(message, serverQueue) {
 if (!message.member.voice.channel) // on vérifie que l'utilisateur est bien dans un salon vocal pour skip
    return message.channel.send(
      "Vous devez être dans un salon vocal pour stopper la lecture!"
    );
  if (!serverQueue) // On vérifie si une musique est en cours
    return message.channel.send("Aucune lecture de musique en cours !");
    serverQueue.songs = [];
    serverQueue.connection.dispatcher.end();
}

Conclusion

Au final voici le code que l’on obtiens pour notre bot musical:

const Discord         = require("discord.js");
const { Client, Intents } = require('discord.js');
const {prefix, token} = require("./config.json");
const ytdl            = require("ytdl-core");

const client = new Client({ intents: [Intents.FLAGS.GUILDS, Intents.FLAGS.GUILD_MESSAGES] });

const queue = new Map();

client.once("ready", () => {
        console.log("Ready!");
});

client.once("reconnecting", () => {
        console.log("Reconnecting!");
});

client.once("disconnect", () => {
        console.log("Disconnect!");
});

client.on("message", async message => {
        if (message.author.bot) {
                return;
        }
        if (!message.content.startsWith(prefix)) {
                return;
        }

        const serverQueue = queue.get(message.guild.id);

        if (message.content.startsWith(`${prefix}play`)) {
                execute(message, serverQueue); // On appel execute qui soit initialise et lance la musique soit ajoute à la queue la musique
                return;
        }
        else if (message.content.startsWith(`${prefix}skip`)) {
                skip(message, serverQueue); // Permettra de passer à la musique suivante
                return;
        }
        else if (message.content.startsWith(`${prefix}stop`)) {
                stop(message, serverQueue); // Permettra de stopper la lecture
                return;
        }
        else {
                message.channel.send("You need to enter a valid command!");
        }

});

async function execute(message, serverQueue) {
        const args = message.content.split(" "); // On récupère les arguments dans le message pour la suite

        const voiceChannel = message.member.voice.channel;
        if (!voiceChannel) // Si l'utilisateur n'est pas dans un salon vocal
        {
                return message.channel.send(
                    "Vous devez être dans un salon vocal!"
                );
        }
        const permissions = voiceChannel.permissionsFor(message.client.user); // On récupère les permissions du bot pour le salon vocal
        if (!permissions.has("CONNECT") || !permissions.has("SPEAK")) { // Si le bot n'a pas les permissions
                return message.channel.send(
                    "J'ai besoin des permissions pour rejoindre le salon et pour y jouer de la musique!"
                );
        }

        const songInfo = await ytdl.getInfo(args[1]);
        const song     = {
                title: songInfo.videoDetails.title,
                url  : songInfo.videoDetails.video_url,
        };

        if (!serverQueue) {
                const queueConstruct = {
                        textChannel : message.channel,
                        voiceChannel: voiceChannel,
                        connection  : null,
                        songs       : [],
                        volume      : 1,
                        playing     : true,
                };

                // On ajoute la queue du serveur dans la queue globale:
                queue.set(message.guild.id, queueConstruct);
                // On y ajoute la musique
                queueConstruct.songs.push(song);

                try {
                        // On connecte le bot au salon vocal et on sauvegarde l'objet connection
                        var connection           = await voiceChannel.join();
                        queueConstruct.connection = connection;
                        // On lance la musique
                        play(message.guild, queueConstruct.songs[0]);
                }
                catch (err) {
                        //On affiche les messages d'erreur si le bot ne réussi pas à se connecter, on supprime également la queue de lecture
                        console.log(err);
                        queue.delete(message.guild.id);
                        return message.channel.send(err);
                }
        }
        else {
                serverQueue.songs.push(song);
                console.log(serverQueue.songs);
                return message.channel.send(`${song.title} has been added to the queue!`);
        }

}

function skip(message, serverQueue) {
        if (!message.member.voice.channel) // on vérifie que l'utilisateur est bien dans un salon vocal pour skip
        {
                return message.channel.send(
                    "Vous devez être dans un salon vocal pour passer une musique!"
                );
        }
        if (!serverQueue) // On vérifie si une musique est en cours
        {
                return message.channel.send("Aucune lecture de musique en cours !");
        }
        serverQueue.connection.dispatcher.end(); // On termine la musique courante, ce qui lance la suivante grâce à l'écoute d'événement
                                                 // finish
}

function stop(message, serverQueue) {
        if (!message.member.voice.channel) // on vérifie que l'utilisateur est bien dans un salon vocal pour skip
        {
                return message.channel.send(
                    "Vous devez être dans un salon vocal pour stopper la lecture!"
                );
        }
        if (!serverQueue) // On vérifie si une musique est en cours
        {
                return message.channel.send("Aucune lecture de musique en cours !");
        }
        serverQueue.songs = [];
        serverQueue.connection.dispatcher.end();
}

function play(guild, song) {
        console.log(song);
        const serverQueue = queue.get(guild.id); // On récupère la queue de lecture
        if (!song) { // Si la musique que l'utilisateur veux lancer n'existe pas on annule tout et on supprime la queue de lecture
                serverQueue.voiceChannel.leave();
                queue.delete(guild.id);
                return;
        }
        // On lance la musique
        const dispatcher = serverQueue.connection
            .play(ytdl(song.url, { filter: 'audioonly' }))
            .on("finish", () => { // On écoute l'événement de fin de musique
                    serverQueue.songs.shift(); // On passe à la musique suivante quand la courante se termine
                    play(guild, serverQueue.songs[0]);
            })
            .on("error", error => console.error(error));
        dispatcher.setVolume(1); // On définie le volume
        serverQueue.textChannel.send(`Démarrage de la musique: **${song.title}**`);
}

client.login(token);

Sources

Articles récents