DEV Community: Nir

Writing a 'music quiz' command for your discord.js bot (Updated March 2020)

Nir — Sat, 09 Nov 2019 13:22:00 +0000

If you stumbled upon Discord bots, you've probably seen that some of them offer music commands that let you play music directly from Youtube. I've written a guide on how to write a play command.
But in this guide, I will walk you through writing a music trivia(quiz) command. The popular Discord bot MEE6 offers a similar command part of its premium subscription, but we are going to write a better one for free!

If you don't feel like going through this guide, the code is available here

Prerequisites

You need to have a solid knowledge of JavaScript(ES6 features) and discord.js(we will be using its master branch).
Also, this guide assumes you have a working bot because I'm going to walk you through writing the music trivia command solely.
This guide is about setting up a bot.
You need to install Git as well(No need if you have a Mac).
Install the dependencies required for this command by running this in your terminal:
npm install github:discordjs/discord.js#master github:discordjs/Commando ffmpeg-static node-opus simple-youtube-api ytdl-core@latest

Flowchart

The command will work like this:

Bot folders structure

You should(and the code in this guide assumes that) put your commands inside a 'commands' folder. In that folder, you should divide commands by groups(music, guild, gifs, etc...). The music trivia command should be located inside a music folder(so its commands/music/musictrivia.js).
We get the songs data from a JSON file that needs to be located inside a 'music' folder that is inside a 'resources' folder in the root of the project. If that confuses you just take a look at my bot structure on GitHub. The data for the JSON file is here, you can modify it(add more songs or change the existing ones).

Code

If you don't wanna go through the explanations, you can view the full code on my Master-Bot's GitHub repo

In your index.js(or server.js however you called it) extend the 'Guild' structure in order for it to hold our queue:

const { Structures } = require('discord.js'); // add this require on top

Structures.extend('Guild', Guild => {
  class MusicGuild extends Guild {
    constructor(client, data) {
      super(client, data);
// musicData should be here if you followed my play command tutorial, don't copy it if you haven't
      this.musicData = {
        queue: [],
        isPlaying: false,
        nowPlaying: null,
        songDispatcher: null
      };
      this.triviaData = {
        isTriviaRunning: false,
        wasTriviaEndCalled: false,
        triviaQueue: [],
        triviaScore: new Map()
      };
    }
  }
  return MusicGuild;
});

We will start by importing the dependencies we installed earlier:

const { Command } = require('discord.js-commando'); // import only the Command class
const { MessageEmbed } = require('discord.js'); // import only the MessageEmbed class 
const ytdl = require('ytdl-core');
const fs = require('fs');

Create the MusicTriviaCommand class:

module.exports = class MusicTriviaCommand extends Command {
  constructor(client) {
    super(client, {
      name: 'music-trivia',
      memberName: 'music-trivia',
      aliases: ['music-quiz', 'start-quiz'],
      group: 'music',
      description: 'Engage in a music quiz with your friends!',
      guildOnly: true,
      clientPermissions: ['SPEAK', 'CONNECT'],
      throttling: {
        usages: 1,
        duration: 10
      },
      args: [
        {
          key: 'numberOfSongs',
          prompt: 'What is the number of songs you want the quiz to have?',
          type: 'integer',
          default: 5,
          max: 15
        }
      ]
    });
  } // this bracket closes the constructor

Now let's get into the 'run' method(discord.js-commando related):

  async run(message, { numberOfSongs }) {
    // check if user is in a voice channel
    var voiceChannel = message.member.voice.channel;
    if (!voiceChannel)
      return message.say('Please join a voice channel and try again');
    if (message.guild.musicData.isPlaying === true)
      return message.channel.send('A quiz or a song is already running');
    message.guild.musicData.isPlaying = true;
    message.guild.triviaData.isTriviaRunning = true;
    // fetch link array from txt file
    const jsonSongs = fs.readFileSync(
      'resources/music/musictrivia.json',
      'utf8'
    );
    var videoDataArray = JSON.parse(jsonSongs).songs;
    // get random numberOfSongs videos from array
    const randomXVideoLinks = this.getRandom(videoDataArray, numberOfSongs); // get x random urls
    // create and send info embed
    const infoEmbed = new MessageEmbed()
      .setColor('#ff7373')
      .setTitle('Starting Music Quiz')
      .setDescription(
        `Get ready! There are ${numberOfSongs} songs, you have 30 seconds to guess either the singer/band or the name of the song. Good luck!
        You can end the trivia at any point by using the end-trivia command`
      );
    message.say(infoEmbed);

Construct an object for each song, then loop through each user in the channel and set him a score of 0. After that call the playQuizSong method with the queue:

    for (let i = 0; i < randomXVideoLinks.length; i++) {
      const song = {
        url: randomXVideoLinks[i].url,
        singer: randomXVideoLinks[i].singer,
        title: randomXVideoLinks[i].title,
        voiceChannel
      };
      message.guild.triviaData.triviaQueue.push(song);
    }
    const channelInfo = Array.from(
      message.member.voice.channel.members.entries()
    );
    channelInfo.forEach(user => {
      if (user[1].user.bot) return;
      message.guild.triviaData.triviaScore.set(user[1].user.username, 0);
    });
    this.playQuizSong(message.guild.triviaData.triviaQueue, message);
  } // closing bracket of the 'run' method

Now we're going to have a look at the playQuizSong function. If you've taken a look at the flowchart you've seen that it starts playing a song, creates a MessageCollector(listens to incoming messages and decides what to do with them) for 30 seconds. When the collector stops it shifts the queue by 1 song and checks if there are songs left in the queue. if there are more songs, it calls playQuizSong again until there are no songs left.
The collector may stop for 2 reasons:

Timeout (30 seconds passed)
Both the singer/band and song name were guessed

Note that wherever collector.stop() is called, the 'finish' event is emitted and you should "jump" to the code starting from collector.on('finish' ..)

There are code comments explaining the "why's" and "how's" along the way:

  playQuizSong(queue, message) {
    queue[0].voiceChannel.join().then(connection => {
      const dispatcher = connection
        .play(
          ytdl(queue[0].url, {
            quality: 'highestaudio',
            highWaterMark: 1024 * 1024 * 1024 // download part of the song to prevent stutter
          })
        )
        .on('start', () => {
          message.guild.musicData.songDispatcher = dispatcher;
          dispatcher.setVolume(message.guild.musicData.volume);
          let songNameFound = false;
          let songSingerFound = false;

          const filter = m =>
            message.guild.triviaData.triviaScore.has(m.author.username);
          const collector = message.channel.createMessageCollector(filter, { // creates a message collector for 30 seconds
            time: 30000
          });

          collector.on('collect', m => { // this event is emitted whenever a message is sent to the channel
            if (!message.guild.triviaData.triviaScore.has(m.author.username)) // don't process messages sent by users who are not participating
              return;
            if (m.content.startsWith(this.client.commandPrefix)) return; // don't process commands
            // if user guessed song name
            if (m.content.toLowerCase() === queue[0].title.toLowerCase()) {
              if (songNameFound) return; // if song name already found
              songNameFound = true;

              if (songNameFound && songSingerFound) {
                message.guild.triviaData.triviaScore.set(
                  m.author.username,
                  message.guild.triviaData.triviaScore.get(m.author.username) +
                    1
                );
                m.react('☑');
                return collector.stop(); // stop the collector if both song and singer were found
              }
              message.guild.triviaData.triviaScore.set(
                m.author.username,
                message.guild.triviaData.triviaScore.get(m.author.username) + 1
              );
              m.react('☑');
            }
            // if user guessed singer
            else if (
              m.content.toLowerCase() === queue[0].singer.toLowerCase()
            ) {
              if (songSingerFound) return;
              songSingerFound = true;
              if (songNameFound && songSingerFound) {
                message.guild.triviaData.triviaScore.set(
                  m.author.username,
                  message.guild.triviaData.triviaScore.get(m.author.username) +
                    1
                );
                m.react('☑');
                return collector.stop();
              }

              message.guild.triviaData.triviaScore.set(
                m.author.username,
                message.guild.triviaData.triviaScore.get(m.author.username) + 1
              );
              m.react('☑');
            } else if ( // this checks if the user entered both the singer and the song name in different orders
              m.content.toLowerCase() ===
                queue[0].singer.toLowerCase() +
                  ' ' +
                  queue[0].title.toLowerCase() ||
              m.content.toLowerCase() ===
                queue[0].title.toLowerCase() +
                  ' ' +
                  queue[0].singer.toLowerCase()
            ) {
              if (
                (songSingerFound && !songNameFound) ||
                (songNameFound && !songSingerFound)
              ) {
                message.guild.triviaData.triviaScore.set(
                  m.author.username,
                  message.guild.triviaData.triviaScore.get(m.author.username) +
                    1
                );
                m.react('☑');
                return collector.stop();
              }
              message.guild.triviaData.triviaScore.set(
                m.author.username,
                message.guild.triviaData.triviaScore.get(m.author.username) + 2
              );
              m.react('☑');
              return collector.stop();
            } else {
              // wrong answer
              return m.react('❌');
            }
          });

          collector.on('end', () => {
            /*
            The reason for this if statement is that we don't want to get an
            empty embed returned via chat by the bot if end-trivia command was 
            called
            */
            if (message.guild.triviaData.wasTriviaEndCalled) {
              message.guild.triviaData.wasTriviaEndCalled = false;
              return;
            }
            // sort the score Map before displaying points, so the display will be in order
            const sortedScoreMap = new Map(
              [...message.guild.triviaData.triviaScore.entries()].sort(
                (a, b) => b[1] - a[1]
              )
            );

            const song = `${this.capitalize_Words(
              queue[0].singer
            )}: ${this.capitalize_Words(queue[0].title)}`;
            // display an embed with the previous song and score
            const embed = new MessageEmbed()
              .setColor('#ff7373')
              .setTitle(`The song was:  ${song}`)
              .setDescription(
                this.getLeaderBoard(Array.from(sortedScoreMap.entries()))
              );

            message.channel.send(embed);
            queue.shift();
            dispatcher.end();
            return;
          });
        })
        .on('finish', () => { // emitted when a song ends
          if (queue.length >= 1) { // if there are more songs, continue
            return this.playQuizSong(queue, message);
          } else { // no more songs left
            if (message.guild.triviaData.wasTriviaEndCalled) { // if the end-trivia command was called
              message.guild.musicData.isPlaying = false;
              message.guild.triviaData.isTriviaRunning = false;
              message.guild.me.voice.channel.leave();
              return;
            }
            const sortedScoreMap = new Map( // sort final score Map
              [...message.guild.triviaData.triviaScore.entries()].sort(
                (a, b) => b[1] - a[1]
              )
            );
            // display results embed
            const embed = new MessageEmbed()
              .setColor('#ff7373')
              .setTitle(`Music Quiz Results:`)
              .setDescription(
                this.getLeaderBoard(Array.from(sortedScoreMap.entries()))
              );
            message.channel.send(embed);
            message.guild.musicData.isPlaying = false;
            message.guild.triviaData.isTriviaRunning = false;
            message.guild.triviaData.triviaScore.clear();
            message.guild.me.voice.channel.leave();
            return;
          }
        });
    });
  }

Below the playQuizCommand function add these 3 functions we used:

 // this method was called when we wanted to get 5 random songs from the JSON file
  getRandom(arr, n) {
    var result = new Array(n),
      len = arr.length,
      taken = new Array(len);
    if (n > len)
      throw new RangeError('getRandom: more elements taken than available');
    while (n--) {
      var x = Math.floor(Math.random() * len);
      result[n] = arr[x in taken ? taken[x] : x];
      taken[x] = --len in taken ? taken[len] : len;
    }
    return result;
  }

  getLeaderBoard(arr) {
    if (!arr) return;
    let leaderBoard = '';

    leaderBoard = `👑   **${arr[0][0]}:** ${arr[0][1]}  points`;

    if (arr.length > 1) {
      for (let i = 1; i < arr.length; i++) {
        leaderBoard =
          leaderBoard + `\n\n   ${i + 1}: ${arr[i][0]}: ${arr[i][1]}  points`;
      }
    }
    return leaderBoard;
  }
  // https://www.w3resource.com/javascript-exercises/javascript-string-exercise-9.php
  capitalize_Words(str) {
    return str.replace(/\w\S*/g, function(txt) {
      return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
    });
  }
};

End music trivia command

There is also a command that is used for stopping the trivia, I'm not gonna go through it because it's very simple. View its code here

That's it!

We just went through writing a music trivia command! If you have a question/clarification/issue please comment down below or open an issue in the bot's GitHub repository :)

How to set up a Discord music bot (Updated December 2021)

Nir — Fri, 13 Sep 2019 17:32:42 +0000

Setting up a music bot isn't easy since it requires lots of different things to be installed. In this guide I will list all the requirements and provide you with the code you need. Make sure you follow all the steps :)

Let's start!

Create a bot

First we need to create the bot, go here and make sure you're logged in. Click on New Application and give your bot a name.
Go to the "Bot" tab on the left and click Add Bot under the "BUILD-A-BOT" tab. Copy the token and save it because we will need it for later.
Copy the Application ID under the "General Information" tab and save it for later as well.

Now click on the "OAuth2" tab and then on "URL Generator". Under "Scopes", check "bot" and on "applications.commands". Under "Bot Permissions", check "Administrator". Now copy the URL under "Generated URL" and paste it into your browser in order to invite your newly created bot to your Discord server!

Code Editor

A code editor let's us write and modify code. The code editor I use and recommend is Visual Studio Code.
You can also use other great editors like Sublime Text and Atom.

Node.js and npm

Node.js is a JavaScript runtime. It basically lets us run JavaScript code on our machine. We also use its package ecosystem, npm, which we will discuss next.
Download Node.js from its official website (LTS or latest).
To check if you installed it correctly, open your terminal(cmd or bash depending on which OS you are using), and run node -v, you should get a number back. If you're struggling with installing Node, check out this guide.
nom comes installed with Node.js, we will use npm later to install dependencies.

Git

Git is an open source version control system. It helps developers to manage projects by keeping track of the entire history of a project and makes it easy to add features without worrying about breaking the entire codebase. We will use Git in order to obtain code for our bot from GitHub. GitHub is a hosting service for Git repositories. You can learn more about Git and Github from this superb article.

If you're on Windows, install Git from here. For macOS users, install Xcode and then hit git --version, it'll prompt you to install it. If you're using Linux based OS, hit sudo dnf install git-all or sudo apt install git-all for debian.

Java 13

Download Java 13 from here, make sure you download the correct one for your Operating System.

Cloning the repository

Go to your terminal(cmd, git bash or bash), you probably see on the left that you are now in your user folder(C:\Users/"username"). Enter cd Desktop to go to your Desktop. Then 'git clone https://github.com/galnir/Master-Bot'. You are cloning(copying) the repository from GitHub so you can use its code.

Getting Lavalink

Download the latest Lavalink jar file from here (under assets). Place the jar file in the root directory of the project (same folder as index.js and package.json)

Application.yml

Create a file named application.yml in the same folder you placed the jar file from before. Copy everything from this example to your application.yml

Tokens

For everything to function we need the following tokens:

The bots discord ID (saved from the first section)
The bots token (saved from the first section)
A Spotify client ID
A Spotify client secret

In order to generate the last 2 tokens you need to create a Spotify account and login to the dev dashboard
After you login, simply create an app and copy the client ID and secret.

Config.json

In the root directory of the project create a file named config.json and have it look like this:

{
  "client_id": "the-bots-discord-id",
  "token": "Your-Bot-Token",
  "lava_host": "0.0.0.0",
  "lava_pass": "youshallnotpass",
  "spotify_client_id": "get-it-from-spotify-dev",
  "spotify_client_secret": "get-it-from-spotify-dev"
}

Put every token you generated in its place surrounded by quotes

Running the bot

Open a terminal in the root directory of the project and run java -jar Lavalink.jar.
Now open another terminal instance in the same folder and run node index.js

After running both commands you should be able to run music commands using the new Slash feature! Simply type / in a text channel and you should see the command list!

If you have any questions/issues you can comment here or open an issue in the repo. Also don't forget to leave a star in the repo if you found it helpful :)

Bot Repo: https://github.com/galnir/Master-Bot
Cover image by Malte Wingen :)

Writing a music command for your discord.js bot (Updated March 2020)

Nir — Sat, 25 May 2019 12:19:43 +0000

Edit Nov 20: This guide is outdated because the play command code changes all the time. I recommend cloning my bot which is on GitHub if you're looking for a music bot with features like saved playlists

If you need a guide on how to set up a bot, please read this

Discord is a popular voice and chat app for gamers and non-gamers who use it to communicate with their friends without paying for a voice server like before.

Almost every big server has a Discord bot, which can be used for managing it, administrative commands like ban and kick, gifs and playing music. So why pay for a music bot when you can create one for free?

No time or energy to read this guide? Just clone my music bot from Github, follow the Prerequisites section, hit npm install and you'll have a working music bot!

This guide assumes you have a basic Discord bot that uses Commando already set up. If the bot does not use discord.js-commando, I highly recommend you to read this guide as Commando makes your life so much easier, and it's required for this guide.

The code for the music command is available here.

Prerequisites

Make sure ffmpeg, python 2.7, and Node(v12 atleast!) are installed.
Obtain a Youtube API key here.

Installing packages

Let's install the packages we're going to work with:
npm:

npm install discordjs/discord.js discordjs/Commando ffmpeg-static node-opus simple-youtube-api ytdl-core

yarn:

yarn add discordjs/discord.js discordjs/Commando ffmpeg-static node-opus simple-youtube-api ytdl-core@latest

Index.js (your main file)

Before we get to play.js, we need to extend the 'Guild' class so we could add a property that will hold our song queue. That will allow the bot to play music at multiple servers at a time.
To do that we'll import 'Structures' at the top of index.js, and use it to extend the 'Guild' class:

// your index.js should look similar to this:
const { CommandoClient } = require('discord.js-commando');
const { Structures } = require('discord.js');
const path = require('path');
const { prefix, token } = require('./config.json');
// It's vital this is before the initiation of the client
Structures.extend('Guild', Guild => {
  class MusicGuild extends Guild {
    constructor(client, data) {
      super(client, data);
      this.musicData = {
        queue: [],
        isPlaying: false,
        volume: 1,
        songDispatcher: null
      };
    }
  }
  return MusicGuild;
});
const client = new CommandoClient({
  commandPrefix: prefix,
  owner: 'your-discord-user-id',
  unknownCommandResponse: false
});

client.registry
  .registerDefaultTypes()
  .registerGroups([
    ['music', 'Music Command Group']
  ])
  .registerDefaultGroups()
  .registerDefaultCommands()
  .registerCommandsIn(path.join(__dirname, 'commands'));

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

client.login(token);

play.js

In your 'commands' folder, create a folder named music and inside it create play.js.
We'll start with importing packages and our Youtube API key:

const { Command } = require('discord.js-commando');
const { MessageEmbed } = require('discord.js');
const Youtube = require('simple-youtube-api');
const ytdl = require('ytdl-core');
const { youtubeAPI } = require('../../config.json');
const youtube = new Youtube(youtubeAPI);

Next we'll declare the 'PlayCommand' class which extends 'Command':

module.exports = class PlayCommand extends Command {
  constructor(client) {
    super(client, {
      name: 'play', 
      memberName: 'play',
      group: 'music', // this means the folder the file is inside
      description: 'Play any song or playlist from youtube',
      guildOnly: true, // make this command available only in servers not dm's
      clientPermissions: ['SPEAK', 'CONNECT'],
      args: [
        {
          key: 'query', // here we name the variable that will hold the input
          prompt: 'What song would you like to listen to?', // send this msg if
          // the user hasn't provided any arg or if the arg was not a string
          type: 'string',
          validate: query => query.length > 0 && query.length < 200 
        }
      ]
    });
  }

Every command starts with the run method(the code you want the bot to run when the command is used):

  async run(message, { query }) {
    // don't let users run this command if they are not in a voice channel
    var voiceChannel = message.member.voice.channel;
    if (!voiceChannel) return message.say('Join a channel and try again');

Users have 3 options when running this command:

Run it with a song name
Run it with a Youtube URL(any kind of URL)
Run it with a Youtube playlist URL

For example:

!play Darude Sandstorm
!play https://www.youtube.com/watch?v=y6120QOlsfU (and other url kinds)
!play https://www.youtube.com/playlist?list=PLuUrokoVSxlfUJuJB_D8j_wsFR4exaEmy

In order to do that we will write an if statement that checks against regex for any type of a Youtube URL. If the input matches the regex, we will apply different logic than the one we will apply on queries by song names.

First of all check if query is a playlist URL:

    if (
      query.match(
        /^(?!.*\?.*\bv=)https:\/\/www\.youtube\.com\/.*\?.*\blist=.*$/
      )
    ) {
      try {
        const playlist = await youtube.getPlaylist(query); // get playlist data 
        const videosObj = await playlist.getVideos(); // songs data object
        //const videos = Object.entries(videosObj); // turn the object to array
        // iterate through the videos array and make a song object out of each vid
        for (let i = 0; i < videosObj.length; i++) { 
          const video = await videosObj[i].fetch();

          const url = `https://www.youtube.com/watch?v=${video.raw.id}`;
          const title = video.raw.snippet.title;
          let duration = this.formatDuration(video.duration);
          const thumbnail = video.thumbnails.high.url;
          if (duration == '00:00') duration = 'Live Stream';
          const song = {
            url,
            title,
            duration,
            thumbnail,
            voiceChannel
          };

          message.guild.musicData.queue.push(song); // if you remember, the queue lives in the guild object so each server has its own queue

        }
        if (message.guild.musicData.isPlaying == false) { // if nothing is playing
          message.guild.musicData.isPlaying = true;
          return this.playSong(message.guild.musicData.queue, message); // play the playlist
        } else if (message.guild.musicData.isPlaying == true) { // if something is already playing
          return message.say(
            `Playlist - :musical_note:  ${playlist.title} :musical_note: has been added to queue`
          );
        }
      } catch (err) {
        console.error(err);
        return message.say('Playlist is either private or it does not exist');
      }
    }

Youtube URL regex:

    if (query.match(/^(http(s)?:\/\/)?((w){3}.)?youtu(be|.be)?(\.com)?\/.+/)) {
      const url = query; // temp variable
      try {
        query = query
          .replace(/(>|<)/gi, '')
          .split(/(vi\/|v=|\/v\/|youtu\.be\/|\/embed\/)/);
        const id = query[2].split(/[^0-9a-z_\-]/i)[0];
        const video = await youtube.getVideoByID(id);
        const title = video.title;
        let duration = this.formatDuration(video.duration);
        const thumbnail = video.thumbnails.high.url;
        if (duration == '00:00') duration = 'Live Stream';
        const song = {
          url,
          title,
          duration,
          thumbnail,
          voiceChannel
        };
        message.guild.musicData.queue.push(song);
        if (
          message.guild.musicData.isPlaying == false ||
          typeof message.guild.musicData.isPlaying == 'undefined'
        ) {
          message.guild.musicData.isPlaying = true;
          return this.playSong(message.guild.musicData.queue, message);
        } else if (message.guild.musicData.isPlaying == true) {
          return message.say(`${song.title} added to queue`);
        }
      } catch (err) {
        console.error(err);
        return message.say('Something went wrong, please try again later');
      }
    }

If the user has entered a song name as an argument:

    try {
      // search for the song and get 5 results back
      const videos = await youtube.searchVideos(query, 5);
      if (videos.length < 5) {
        return message.say(
          `I had some trouble finding what you were looking for, please try again or be more specific`
        );
      }
      const vidNameArr = [];
      // create an array that contains the result titles
      for (let i = 0; i < videos.length; i++) {
        vidNameArr.push(`${i + 1}: ${videos[i].title}`);
      }
      vidNameArr.push('exit'); // push 'exit' string as it will be an option
      // create and display an embed which will present the user the 5 results
      // so he can choose his desired result
      const embed = new MessageEmbed()
        .setColor('#e9f931')
        .setTitle('Choose a song by commenting a number between 1 and 5')
        .addField('Song 1', vidNameArr[0])
        .addField('Song 2', vidNameArr[1])
        .addField('Song 3', vidNameArr[2])
        .addField('Song 4', vidNameArr[3])
        .addField('Song 5', vidNameArr[4])
        .addField('Exit', 'exit'); // user can reply with 'exit' if none matches
      var songEmbed = await message.say({ embed });
      try {
        // wait 1 minute for the user's response
        var response = await message.channel.awaitMessages(
          msg => (msg.content > 0 && msg.content < 6) || msg.content === 'exit',
          {
            max: 1,
            maxProcessed: 1,
            time: 60000,
            errors: ['time']
          }
        );
        // assign videoIndex to user's response
        var videoIndex = parseInt(response.first().content);
      } catch (err) {
        console.error(err);
        songEmbed.delete();
        return message.say(
          'Please try again and enter a number between 1 and 5 or exit'
        );
      }
      // if the user responded with 'exit', cancel the command
      if (response.first().content === 'exit') return songEmbed.delete();
      try {
        // get video data from the API
        var video = await youtube.getVideoByID(videos[videoIndex - 1].id);
      } catch (err) {
        console.error(err);
        songEmbed.delete();
        return message.say(
          'An error has occured when trying to get the video ID from youtube'
        );
      }
      const url = `https://www.youtube.com/watch?v=${video.raw.id}`;
      const title = video.title;
      let duration = this.formatDuration(video.duration);
      const thumbnail = video.thumbnails.high.url;
        if (duration == '00:00') duration = 'Live Stream';
        const song = {
          url,
          title,
          duration,
          thumbnail,
          voiceChannel
        };

        message.guild.musicData.queue.push(song);

        if (message.guild.musicData.isPlaying == false) {
          message.guild.musicData.isPlaying = true;
          songEmbed.delete(); // delete the selection embed
          this.playSong(message.guild.musicData.queue, message);
        } else if (message.guild.musicData.isPlaying == true) {
          songEmbed.delete();
          // add the song to queue if one is already playing
          return message.say(`${song.title} added to queue`);
        }
    } catch (err) {
      // if something went wrong when calling the api:
      console.error(err);
      if (songEmbed) {
        songEmbed.delete();
      }
      return message.say(
        'Something went wrong with searching the video you requested :('
      );
    }
  }

So what's that playSong function we called multiple times above? This function takes the queue and the message object as arguments. When called, it tells the bot to join the user's channel and start playing music!

// this is inside the PlayCommand class
  playSong(queue, message) {
    let voiceChannel;
    queue[0].voiceChannel
      .join() // join the user's voice channel
      .then(connection => {
        const dispatcher = connection
          .play(
            ytdl(queue[0].url, { // pass the url to .ytdl()
              quality: 'highestaudio',
              // download part of the song before playing it
              // helps reduces stuttering
              highWaterMark: 1024 * 1024 * 10
            })
          )
          .on('start', () => {
            // the following line is essential to other commands like skip
            message.guild.musicData.songDispatcher = dispatcher;
            dispatcher.setVolume(message.guild.musicData.volume);
            voiceChannel = queue[0].voiceChannel;
            // display the current playing song as a nice little embed
            const videoEmbed = new MessageEmbed()
              .setThumbnail(queue[0].thumbnail) // song thumbnail
              .setColor('#e9f931')
              .addField('Now Playing:', queue[0].title)
              .addField('Duration:', queue[0].duration);
            // also display next song title, if there is one in queue
            if (queue[1]) videoEmbed.addField('Next Song:', queue[1].title);
            message.say(videoEmbed); // send the embed to chat
            return queue.shift(); //  dequeue the song
          })
          .on('finish', () => { // this event fires when the song has ended
            if (queue.length >= 1) { // if there are more songs in queue
              return this.playSong(queue, message); // continue playing
            } else { // else if there are no more songs in queue
              message.guild.musicData.isPlaying = false;
              return voiceChannel.leave(); // leave the voice channel
            }
          })
          .on('error', e => {
            message.say('Cannot play song');
            message.guild.musicData.queue.length = 0;
            message.guild.musicData.isPlaying = false;
            message.guild.musicData.nowPlaying = null;
            console.error(e);
            return voiceChannel.leave();
          });
      })
      .catch(e => {
        console.error(e);
        return voiceChannel.leave();
      });
  }

formatDuration function:

  formatDuration(durationObj) {
    const duration = `${durationObj.hours ? durationObj.hours + ':' : ''}${
      durationObj.minutes ? durationObj.minutes : '00'
    }:${
      durationObj.seconds < 10
        ? '0' + durationObj.seconds
        : durationObj.seconds
        ? durationObj.seconds
        : '00'
    }`;
    return duration;
  }

That's it!

You can check out other music commands on the bot's repo

If you're running into issues, either comment down below or open an issue in the bot's GitHub repository.

I've also written a guide on writing a music quiz(trivia) command, you can check it out here