Merge pull request #105 from musix-org/dependabot/npm_and_yarn/v3/nodemon-3.1.6

Bump nodemon from 3.1.5 to 3.1.6

.github/workflows/dependabot_auto-merge.yml

@@ -0,0 +1,23 @@
+name: Dependabot Auto-Merge
+on:
+  pull_request_target:
+    branches:
+      - v1
+      - v2
+      - v3
+
+permissions:
+  pull-requests: write
+  contents: write
+
+jobs:
+  dependabot:
+    name: Dependabot Auto-Merge
+    runs-on: ubuntu-latest
+    if: ${{ github.actor == 'dependabot[bot]' }}
+    steps:
+      - name: Enable auto-merge for Dependabot PRs
+        run: gh pr merge --auto --merge "$PR_URL"
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1 +1,4 @@
 node_modules
+.env
+.vscode
+serviceAccount.json

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019-2024 Musix Org
+Copyright (c) 2020-2024 Musix Org
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1 +1 @@
-# Musix OSS
+# Musix OSS - V3

index.js

@@ -0,0 +1,31 @@
+const { ShardingManager} = require("discord.js");
+const config = require("./src/config/config.js");
+const DiscordWebhook = require("discord-webhook-node");
+
+if (config.devMode) {
+  console.log("- dev mode- ");
+  config.shards = 1;
+}
+
+const manager = new ShardingManager("./src/bot.js", {
+  token: config.token,
+  respawn: config.respawn,
+  totalShards: config.shards,
+});
+
+console.log("- Launching shards -");
+manager.spawn(config.shards, config.shardDelay, config.shardTimeout);
+manager.on("shardCreate", (shard) =>
+  console.log(`- Launched shard ${shard.id} -`)
+);
+
+const oldConsole = {};
+oldConsole.log = console.log;
+console.log = function (arg) {
+  oldConsole.log(arg);
+};
+
+oldConsole.error = console.error;
+console.error = function (arg) {
+  oldConsole.error(arg);
+};

package.json

@@ -0,0 +1,39 @@
+{
+  "name": "musix-oss",
+  "version": "3.11.0",
+  "description": "V3 for Musix the discord music bot",
+  "main": "./index.js",
+  "scripts": {
+    "start": "node --max-old-space-size=3072 index.js",
+    "start:dev": "nodemon"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/musix-org/musix-oss.git"
+  },
+  "author": "Musix Org",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/musix-org/musix-oss/issues",
+    "support": "https://discord.gg/rvHuJtB"
+  },
+  "homepage": "https://musix-org.github.io/",
+  "dependencies": {
+    "@discordjs/opus": "^0.9.0",
+    "discord-webhook-node": "^1.1.8",
+    "discord.js": "^14.16.2",
+    "dotenv": "^16.4.5",
+    "firebase": "^10.13.2",
+    "firebase-admin": "^12.5.0",
+    "he": "^1.2.0",
+    "prism-media": "^1.3.5",
+    "request": "^2.88.2",
+    "simple-youtube-api": "^5.2.1",
+    "spotify-web-api-node": "^5.0.2",
+    "ytdl-core": "^4.11.5",
+    "ytsr": "^3.8.4"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.6"
+  }
+}

src/bot.js

@@ -0,0 +1,14 @@
+const MusicClient = require("./client.js");
+const DiscordWebhook = require("discord-webhook-node");
+const client = new MusicClient({});
+
+const oldConsole = {};
+oldConsole.log = console.log;
+console.log = function (arg) {
+  oldConsole.log(arg);
+};
+
+oldConsole.error = console.error;
+console.error = function (arg) {
+  oldConsole.error(arg);
+};

src/client.js

@@ -0,0 +1,82 @@
+const {
+  Client,
+  Collection,
+  Intents
+} = require("discord.js");
+const admin = require("firebase-admin");
+const serviceAccount = require("./config/serviceAccount.json");
+const fs = require("fs");
+const path = require("path");
+const SpotifyApi = require("spotify-web-api-node");
+const YouTube = require("simple-youtube-api");
+const config = require("./config/config");
+
+const GatewayIntents = new Intents();
+GatewayIntents.add(
+  1 << 0, // GUILDS
+  1 << 7, // GUILD_VOICE_STATES
+  1 << 9, // GUILD_MESSAGES,
+  1 << 15 // MESSAGE_CONTENT
+);
+
+module.exports = class extends Client {
+  constructor() {
+    super({
+      disableMentions: "everyone",
+      disabledEvents: ["TYPING_START"],
+      ws: {
+        intents: GatewayIntents
+      }
+    });
+
+    admin.initializeApp({
+      credential: admin.credential.cert(serviceAccount),
+    });
+    this.commands = new Collection();
+    this.settingCmd = new Collection();
+    this.queue = new Map();
+    this.spotify = new SpotifyApi({
+      id: config.spotify_client_id,
+      secret: config.spotify_client_secret,
+    });
+    this.youtube = new YouTube(config.youtube_api_key);
+    this.config = config;
+    this.funcs = {};
+    this.dispatcher = {};
+    this.messages = require("./config/messages.js");
+    this.db = admin.firestore();
+    this.db.FieldValue = require("firebase-admin").firestore.FieldValue;
+    this.global = {
+      db: {
+        guilds: {},
+      }
+    };
+    this.logs = [];
+
+    fs.readdirSync(path.join(__dirname, "funcs")).forEach((filename) => {
+      this.funcs[filename.slice(0, -3)] = require(`./funcs/${filename}`);
+    });
+
+    const commandFiles = fs
+      .readdirSync(path.join(path.dirname(__dirname), "commands"))
+      .filter((f) => f.endsWith(".js"));
+    for (const file of commandFiles) {
+      const command = require(`../commands/${file}`);
+      command.uses = 0;
+      this.commands.set(command.name, command);
+    }
+    const settingFiles = fs
+      .readdirSync(path.join(path.dirname(__dirname), "commands/settings"))
+      .filter((f) => f.endsWith(".js"));
+    for (const file of settingFiles) {
+      const option = require(`../commands/settings/${file}`);
+      this.settingCmd.set(option.name, option);
+    }
+
+    require("./events/clientEvents/handler.js")(this);
+
+    this.login(this.config.discord_api_token).catch((err) =>
+      console.log("Failed to login: " + err)
+    );
+  }
+};

src/commands/bass.js

@@ -0,0 +1,33 @@
+module.exports = {
+  name: "bass",
+  description: "Boost the bass in your music!",
+  alias: ["none"],
+  usage: "<bass>",
+  permission: "MANAGE_MESSAGES",
+  category: "audio modifiers",
+  execute(msg, args, client, command) {
+    const queue = client.queue.get(msg.guild.id);
+    if (!args[1] && queue)
+      return msg.channel.send(
+        `${client.messages.currentBass}**${queue.bass}**`
+      );
+    const bass = parseFloat(args[1]);
+    if (client.funcs.check(client, msg, command)) {
+      if (queue.nightCore)
+        return msg.channel.send(client.messages.disableNightCore);
+      if (isNaN(bass)) return msg.channel.send(client.messages.validNumber);
+      if (bass > 10) return msg.channel.send(client.messages.maxBass);
+      if (bass < 0) return msg.channel.send(client.messages.positiveBass);
+      queue.bass = bass;
+      client.funcs.end(
+        client,
+        msg,
+        (queue.connection.dispatcher.streamTime + queue.time) / 1000,
+        command
+      );
+      let message;
+      message = client.messages.bassApplied.replace("%BASS%", bass);
+      return msg.channel.send(message);
+    }
+  },
+};

src/commands/help.js

@@ -0,0 +1,39 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+    name: 'help',
+    alias: ["h"],
+    usage: '<command(opt)>',
+    description: 'See the help for Musix.',
+    permission: 'none',
+    category: 'info',
+    execute(msg, args, client, command) {
+        if (args[1]) {
+            if (!client.commands.has(args[1]) || (client.commands.has(args[1]) && client.commands.get(args[1]).omitFromHelp === true && msg.guild.id !== '489083836240494593')) return msg.channel.send('That command does not exist');
+            const command = client.commands.get(args[1]);
+            const embed = new EmbedBuilder()
+                .setTitle(`${client.global.db.guilds[msg.guild.id].prefix}${command.name} ${command.usage}`)
+                .setDescription(command.description)
+                .setFooter({ text:`${client.messages.helpCmdFooter} \`${command.alias.map(a => `${a}, `)}\`` })
+                .setColor(client.config.embedColor)
+            msg.channel.send(embed);
+        } else {
+            const categories = [];
+            for (let i = 0; i < client.commands.size; i++) {
+                if (!categories.includes(client.commands.array()[i].category)) categories.push(client.commands.array()[i].category);
+            }
+            let commands = '';
+            for (let i = 0; i < categories.length; i++) {
+                commands += `**» ${categories[i].toUpperCase()}**\n${client.commands.filter(x => x.category === categories[i] && !x.omitFromHelp).map(x => `\`${x.name}\``).join(', ')}\n`;
+            }
+            let message;
+            message = client.messages.helpFooter.replace("%PREFIX%", client.global.db.guilds[msg.guild.id].prefix);
+            const embed = new EmbedBuilder()
+                .setTitle(`${client.user.username} ${client.messages.helpTitle}`)
+                .setDescription(commands)
+                .setFooter({ text: message })
+                .setColor(client.config.embedColor)
+            msg.channel.send(embed);
+        }
+    }
+};

src/commands/invite.js

@@ -0,0 +1,17 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+    name: 'invite',
+    alias: ["i"],
+    usage: '',
+    description: 'Invite Musix.',
+    permission: 'none',
+    category: 'info',
+    execute(msg, args, client, command) {
+        const embed = new EmbedBuilder()
+            .setTitle(client.messages.inviteTitle)
+            .setURL(client.config.invite)
+            .setColor(client.config.embedColor)
+        msg.channel.send(embed);
+    }
+};

src/commands/loop.js

@@ -0,0 +1,20 @@
+module.exports = {
+    name: 'loop',
+    alias: [],
+    usage: '',
+    description: 'loop the queue.',
+    permission: 'MANAGE_MESSAGES',
+    category: 'music control',
+    async execute(msg, args, client, command) {
+        const queue = client.queue.get(msg.guild.id);
+        if (client.funcs.check(client, msg, command)) {
+            if (!queue.looping) {
+                queue.looping = true;
+                msg.channel.send(client.messages.looping);
+            } else {
+                queue.looping = false;
+                msg.channel.send(client.messages.noLooping);
+            }
+        }
+    }
+};

src/commands/loopsong.js

@@ -0,0 +1,22 @@
+module.exports = {
+    name: 'loopsong',
+    alias: ["none"],
+    usage: '',
+    description: 'loop the currently playing song.',
+    permission: 'MANAGE_MESSAGES',
+    category: 'music control',
+    async execute(msg, args, client, command) {
+        const queue = client.queue.get(msg.guild.id);
+        if (client.funcs.check(client, msg, command)) {
+            if (!queue.songLooping) {
+                queue.songLooping = true;
+                let message;
+                message = client.messages.loopingSong.replace("%TITLE%", queue.songs[0].title);
+                msg.channel.send(message);
+            } else {
+                queue.songLooping = false;
+                msg.channel.send(client.messages.noLoopingSong);
+            }
+        }
+    }
+};

src/commands/lyrics.js

@@ -0,0 +1,37 @@
+const { EmbedBuilder } = require("discord.js");
+const { getLyrics } = require("genius-lyrics-api");
+
+module.exports = {
+  name: "lyrics",
+  alias: ["l"],
+  usage: "<song>",
+  description: "see the lyrics for a song",
+  permission: "none",
+  category: "util",
+  async execute(msg, args, client, prefix, command) {
+    const searchString = args.slice(1).join(" ");
+    const options = {
+      apiKey: client.config.genius_api_key,
+      title: searchString,
+      artist: "",
+      optimizeQuery: true,
+    };
+    const queue = client.queue.get(msg.guild.id);
+    if (queue && !args[1]) options.title = queue.songs[0].title;
+    if (!queue && !args[1])
+      return msg.channel.send(client.messages.lyricsUsage);
+    getLyrics(options).then((lyrics) => {
+      if (lyrics === null)
+        return msg.channel.send(client.messages.noResultsLyrics);
+      for (let i = 0; i < lyrics.length; i += 2000) {
+        let toi = "";
+        toi = lyrics.substring(i, Math.min(lyrics.length, i + 2000));
+        const embed = new EmbedBuilder()
+          .setTitle(client.messages.lyricsTitle)
+          .setDescription(toi)
+          .setColor(client.config.embedColor);
+        msg.channel.send(embed);
+      }
+    });
+  },
+};

src/commands/nightcore.js

@@ -0,0 +1,25 @@
+module.exports = {
+  name: "nightcore",
+  alias: ["nc"],
+  usage: "<true/false>",
+  description: "Change nightcore audio modifier on/off",
+  permission: "MANAGE_MESSAGES",
+  category: "audio modifiers",
+  async execute(msg, args, client, command) {
+    const queue = client.queue.get(msg.guild.id);
+    if (!args[1] && queue)
+      return msg.channel.send(
+        `${client.messages.currentNightCore}**${queue.nightCore}**`
+      );
+    if (client.funcs.check(client, msg, command)) {
+      if (args[1] === "true") {
+        queue.nightCore = true;
+      } else if (args[1] === "false") {
+        queue.nightCore = false;
+      } else return msg.channel.send(client.messages.boolean);
+      let message;
+      message = client.messages.nightCoreApplied.replace("%BOOLEAN%", args[1]);
+      return msg.channel.send(message);
+    }
+  },
+};

src/commands/nowplaying.js

@@ -0,0 +1,48 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+  name: "nowplaying",
+  alias: ["np", "playing"],
+  usage: "",
+  description: "See the currently playing song position and length.",
+  permission: "none",
+  category: "info",
+  async execute(msg, args, client, command) {
+    const queue = client.queue.get(msg.guild.id);
+    if (!queue || !queue.songs[0] || !queue.connection || !queue.connection.dispatcher) return msg.channel.send(client.messages.noServerQueue);
+    let songTime = (queue.songs[0].info.lengthSeconds * 1000).toFixed(0);
+    let completed = (
+      queue.connection.dispatcher.streamTime + queue.time
+    ).toFixed(0);
+    let barlength = 30;
+    let completedpercent = ((completed / songTime) * barlength).toFixed(0);
+    let array = [];
+    for (let i = 0; i < completedpercent - 1; i++) {
+      array.push("⎯");
+    }
+    array.push("🔘");
+    for (let i = 0; i < barlength - completedpercent - 1; i++) {
+      array.push("⎯");
+    }
+    const thumbnail = queue.songs[0].info.thumbnail.thumbnails[4] || queue.songs[0].info.thumbnail.thumbnails[3] || queue.songs[0].info.thumbnail.thumbnails[2] || queue.songs[0].info.thumbnail.thumbnails[1] || queue.songs[0].info.thumbnail.thumbnails[0];
+    const embed = new EmbedBuilder()
+      .setTitle(client.messages.nowPlaying)
+      .setDescription(
+        `${client.messages.nowPlayingDesc} ${
+          queue.songs[0].title
+        }\n\`${array.join("")}\`\n\`${client.funcs.msToTime(
+          completed,
+          "hh:mm:ss"
+        )} / ${client.funcs.msToTime(songTime, "hh:mm:ss")}\`\nchannel: \`${queue.songs[0].info.author.name}\``
+      )
+      .setFooter({ text: `Queued by ${queue.songs[0].author.tag}`})
+      .setURL(queue.songs[0].url)
+      .setThumbnail(thumbnail.url)
+      .setColor(client.config.embedColor);
+    if (queue.nightCore)
+      embed.setDescription(
+        `${client.messages.nowPlayingDesc} ${queue.songs[0].title} \nchannel: \`${queue.songs[0].info.author.name}\``
+      );
+    return msg.channel.send(embed);
+  },
+};

src/commands/pause.js

@@ -0,0 +1,17 @@
+module.exports = {
+	name: 'pause',
+	alias: ["none"],
+	usage: '',
+	description: 'Pause the currently playing music.',
+	permission: 'MANAGE_MESSAGES',
+	category: 'music control',
+	execute(msg, args, client, command) {
+		const queue = client.queue.get(msg.guild.id);
+		if (client.funcs.check(client, msg, command)) {
+			if (queue.paused) return msg.channel.send(client.messages.alreadyPaused);
+			queue.paused = true;
+			queue.connection.dispatcher.pause(true);
+			return msg.channel.send(client.messages.paused);
+		}
+	}
+};

src/commands/play.js

@@ -0,0 +1,401 @@
+const ytdl = require("ytdl-core");
+const ytsr = require("ytsr");
+
+module.exports = {
+  name: "play",
+  alias: ["p", "music"],
+  usage: "<song name>",
+  description: "Play some music.",
+  permission: "none",
+  category: "play",
+  async execute(msg, args, client, command) {
+    const searchString = args.slice(1).join(" ");
+    const url = args[1] ? args[1].replace(/<(.+)>/g, "$1") : "";
+    const queue = client.queue.get(msg.guild.id);
+    const voiceChannel = msg.member.voice.channel;
+    if (
+      client.global.db.guilds[msg.guild.id].blacklist.includes(
+        msg.member.voice.channelID
+      )
+    )
+      return msg.channel.send(client.messages.blackListedVC);
+    if (!queue) {
+      if (!msg.member.voice.channel)
+        return msg.channel.send(client.messages.noVoiceChannel);
+    } else {
+      if (voiceChannel !== queue.voiceChannel)
+        return msg.channel.send(client.messages.wrongVoiceChannel);
+    }
+    if (!args[1]) return msg.channel.send(client.messages.noQuery);
+    if (voiceChannel.full) return msg.channel.send(client.messages.channelFull);
+    if (!voiceChannel.joinable)
+      return msg.channel.send(client.messages.noPermsConnect);
+    if (!voiceChannel.speakable)
+      return msg.channel.send(client.messages.noPermsSpeak);
+    if (ytdl.validateURL(url)) {
+      client.funcs.handleVideo(url, msg, voiceChannel, client, false, "ytdl");
+    } else if (url.match(/^https?:\/\/(open.spotify.com|spotify.com)(.*)$/)) {
+      if (url.includes("playlist")) {
+        const playlistId = url.split("/playlist/")[1].split("?")[0];
+        client.spotify.getPlaylist(playlistId).then(
+          async function (data) {
+              searchPlaylist(data, client, msg, voiceChannel);
+            },
+            function (err) {
+              console.log(err);
+              msg.channel.send(client.messages.noResultsSpotify);
+            }
+        );
+      } else if (url.includes("album")) {
+        const albumId = url.split("/album/")[1].split("?")[0];
+        client.spotify.getAlbumTracks(albumId).then(
+          async function (data) {
+              searchAlbum(data, client, msg, voiceChannel);
+            },
+            function (err) {
+              console.log(err);
+              msg.channel.send(client.messages.noResultsSpotify);
+            }
+        );
+      } else if (url.includes("track")) {
+        return msg.channel.send(client.messages.disabledSpotifySongs);
+        /*const trackId = url.split("/track/")[1].split("?")[0];
+        spotify.searchTracks(trackId)
+          .then(function (data) {
+            console.log(data.body)
+          }, function (err) {
+            console.log('Something went wrong!', err);
+          });*/
+      } else msg.channel.send(client.messages.invalidSpotifyUrl);
+    } else if (
+      url.match(/^https?:\/\/(www.youtube.com|youtube.com)\/playlist(.*)$/)
+    ) {
+      const lmsg = await msg.channel.send(client.messages.loadingSongs);
+      const playlist = await client.youtube.getPlaylist(url).catch((err) => {
+        console.log("err1");
+      });
+      const videos = await playlist.getVideos().catch((err) => {
+        console.log("err2");
+      });
+      for (const video of Object.values(videos)) {
+        const video2 = await client.youtube.getVideoByID(video.id).catch((err) => {
+          console.log("err3");
+        });
+        client.spotify.searchTracks(`track:${video2.name}`).then(
+          function (data) {
+            client.funcs.handleVideo(
+              video2.url,
+              msg,
+              voiceChannel,
+              client,
+              true,
+              "ytdl",
+              data.body.tracks.items[0]
+            );
+          },
+          function (err) {
+            console.log("Something went wrong!", err);
+          }
+        );
+      }
+      const message = client.messages.playlistAdded.replace(
+        "%TITLE%",
+        playlist.title
+      );
+      return lmsg.edit(message);
+    } else {
+      ytsr(
+        searchString, {
+          limit: 5,
+        },
+        function (err, res) {
+          if (err) console.log(err);
+          if (!res.items[0]) return msg.channel.send(client.messages.noResults);
+          const videoResults = res.items.filter(
+            (item) => item.type === "video"
+          );
+          client.spotify.searchTracks(`track:${searchString}`).then(
+            function (data) {
+              client.funcs.handleVideo(
+                videoResults[0].link,
+                msg,
+                voiceChannel,
+                client,
+                false,
+                "ytdl",
+                data.body.tracks.items[0]
+              );
+            },
+            function (err) {
+              console.log(err);
+            }
+          );
+        }
+      );
+    }
+  },
+};
+
+async function searchPlaylist(data, client, msg, voiceChannel) {
+  const lmsg = await msg.channel.send(client.messages.loadingSongs);
+  let failed = 0;
+  for (let i = 0; data.body.tracks.items.length > i; i++) {
+    const track = await data.body.tracks.items[i].track;
+    await client.funcs.sleep(250);
+    ytsr(
+      `${track.artists[0].name} ${track.name} audio`, {
+        limit: 5,
+      },
+      async function (err, res) {
+        if (err) return console.log(err);
+        if (!res.items[0]) {
+          ytsr(
+            `${track.artists[0].name} ${track.name} lyrics`, {
+              limit: 5,
+            },
+            async function (err, res) {
+              if (err) return console.log(err);
+              if (!res.items[0]) {
+                ytsr(
+                  `${track.artists[0].name} ${track.name}`, {
+                    limit: 5,
+                  },
+                  async function (err, res) {
+                    if (err) console.log(err);
+                    if (!res.items[0]) {
+                      failed++;
+                    }
+                    const videoResults = res.items.filter(
+                      (item) => item.type === "video"
+                    );
+                    client.funcs.handleVideo(
+                      videoResults[0].link,
+                      msg,
+                      voiceChannel,
+                      client,
+                      false,
+                      "spotify",
+                      track
+                    );
+                  }
+                );
+                return;
+              }
+              const videoResults = res.items.filter(
+                (item) => item.type === "video"
+              );
+              await client.funcs.handleVideo(
+                videoResults[0].link,
+                msg,
+                voiceChannel,
+                client,
+                true,
+                "spotify",
+                track
+              );
+            }
+          );
+          failed++;
+          return;
+        }
+        const videoResults = res.items.filter((item) => item.type === "video");
+        await client.funcs.handleVideo(
+          videoResults[0].link,
+          msg,
+          voiceChannel,
+          client,
+          true,
+          "spotify",
+          track
+        );
+      }
+    );
+  }
+  let message;
+  if (failed === 0) {
+    message = client.messages.playlistAdded.replace("%TITLE%", data.body.name);
+  } else {
+    message = `${client.messages.playlistAdded.replace(
+      "%TITLE%",
+      data.body.name
+    )}\n${client.messages.failedToLoad + failed}`;
+  }
+  lmsg.edit(message);
+}
+
+async function searchAlbum(data, client, msg, voiceChannel) {
+  const lmsg = await msg.channel.send(client.messages.loadingSongs);
+  let failed = 0;
+  for (let i = 0; data.body.items.length > i; i++) {
+    const track = await data.body.items[i];
+    await client.funcs.sleep(250);
+    ytsr(
+      `${track.artists[0].name} ${track.name} audio`, {
+        limit: 5,
+      },
+      async function (err, res) {
+        if (err) return console.log(err);
+        if (!res.items[0]) {
+          ytsr(
+            `${track.artists[0].name} ${track.name} lyrics`, {
+              limit: 5,
+            },
+            async function (err, res) {
+              if (err) return console.log(err);
+              if (!res.items[0]) {
+                ytsr(
+                  `${track.artists[0].name} ${track.name}`, {
+                    limit: 5,
+                  },
+                  async function (err, res) {
+                    if (err) console.log(err);
+                    if (!res.items[0]) {
+                      failed++;
+                    }
+                    const videoResults = res.items.filter(
+                      (item) => item.type === "video"
+                    );
+                    client.funcs.handleVideo(
+                      videoResults[0].link,
+                      msg,
+                      voiceChannel,
+                      client,
+                      false,
+                      "spotify",
+                      track
+                    );
+                  }
+                );
+                return;
+              }
+              const videoResults = res.items.filter(
+                (item) => item.type === "video"
+              );
+              await client.funcs.handleVideo(
+                videoResults[0].link,
+                msg,
+                voiceChannel,
+                client,
+                true,
+                "spotify",
+                track
+              );
+            }
+          );
+          failed++;
+          return;
+        }
+        const videoResults = res.items.filter((item) => item.type === "video");
+        await client.funcs.handleVideo(
+          videoResults[0].link,
+          msg,
+          voiceChannel,
+          client,
+          true,
+          "spotify",
+          track
+        );
+      }
+    );
+  }
+  let message;
+  if (failed === 0) {
+    message = client.messages.albumAdded.replace(
+      "%TITLE%",
+      "yes taht palylist"
+    );
+  } else {
+    message = `${client.messages.albumAdded.replace(
+      "%TITLE%",
+      "yes taht palylist"
+    )}\n${client.messages.failedToLoad + failed}`;
+  }
+  lmsg.edit(message);
+}
+
+async function searchSong(data, client, msg, voiceChannel) {
+  const lmsg = await msg.channel.send(client.messages.loadingSongs);
+  let failed = 0;
+  for (let i = 0; data.body.tracks.items.length > i; i++) {
+    const track = await data.body.tracks.items[i].track;
+    await client.funcs.sleep(250);
+    ytsr(
+      `${track.artists[0].name} ${track.name} audio`, {
+        limit: 5,
+      },
+      async function (err, res) {
+        if (err) return console.log(err);
+        if (!res.items[0]) {
+          ytsr(
+            `${track.artists[0].name} ${track.name} lyrics`, {
+              limit: 5,
+            },
+            async function (err, res) {
+              if (err) return console.log(err);
+              if (!res.items[0]) {
+                ytsr(
+                  `${track.artists[0].name} ${track.name}`, {
+                    limit: 5,
+                  },
+                  async function (err, res) {
+                    if (err) console.log(err);
+                    if (!res.items[0]) {
+                      failed++;
+                    }
+                    const videoResults = res.items.filter(
+                      (item) => item.type === "video"
+                    );
+                    client.funcs.handleVideo(
+                      videoResults[0].link,
+                      msg,
+                      voiceChannel,
+                      client,
+                      false,
+                      "spotify",
+                      track
+                    );
+                  }
+                );
+                return;
+              }
+              const videoResults = res.items.filter(
+                (item) => item.type === "video"
+              );
+              await client.funcs.handleVideo(
+                videoResults[0].link,
+                msg,
+                voiceChannel,
+                client,
+                true,
+                "spotify",
+                track
+              );
+            }
+          );
+          failed++;
+          return;
+        }
+        const videoResults = res.items.filter((item) => item.type === "video");
+        await client.funcs.handleVideo(
+          videoResults[0].link,
+          msg,
+          voiceChannel,
+          client,
+          true,
+          "spotify",
+          track
+        );
+      }
+    );
+  }
+  let message;
+  if (failed === 0) {
+    message = client.messages.playlistAdded.replace("%TITLE%", data.body.name);
+  } else {
+    message = `${client.messages.playlistAdded.replace(
+      "%TITLE%",
+      data.body.name
+    )}\n${client.messages.failedToLoad + failed}`;
+  }
+  lmsg.edit(message);
+}

src/commands/previous.js

@@ -0,0 +1,17 @@
+module.exports = {
+    name: 'previous',
+    alias: ["prev", "return", "back"],
+    usage: '',
+    description: 'Play the previous song.',
+    permission: 'MANAGE_MESSAGES',
+    category: 'music control',
+    async execute(msg, args, client, command) {
+        const queue = client.queue.get(msg.guild.id)
+        if (client.funcs.check(client, msg, command)) {
+            if (queue.prevSongs.length < 1) return msg.channel.send(client.messages.noPreviousSongs);
+            queue.endReason = "previous";
+            queue.connection.dispatcher.end()
+            msg.channel.send(client.messages.previousSong)
+        }
+    }
+};

src/commands/queue.js

@@ -0,0 +1,29 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+	name: 'queue',
+	alias: ["q", "list", "ls", "songs"],
+	usage: '',
+	description: 'See the queue.',
+	permission: 'none',
+	category: 'info',
+	async execute(msg, args, client, command) {
+		const queue = client.queue.get(msg.guild.id);
+		if (!queue) return msg.channel.send(client.messages.noServerQueue);
+		const page = 1;
+		let queuesongs = queue.songs.slice((page - 1) * 20 + 1, page * 20 + 1);
+		let queuemessage = `${queuesongs.map(song => `**#** ${song.title}`).join('\n')}`
+		const hashs = queuemessage.split('**#**').length;
+		for (let i = 0; i < hashs; i++) {
+			queuemessage = queuemessage.replace('**#**', `**${i + 1}**`);
+		}
+		let message;
+		message = client.messages.queueDesc.replace("%SONG%", queue.songs[0].title);
+		const embed = new EmbedBuilder()
+			.setTitle(client.messages.queueTitle)
+			.setDescription(`${message}\n${queuemessage}`)
+			.setFooter({ text: `${queue.songs.length - 1} ${client.messages.queueFooter}`})
+			.setColor(client.config.embedColor)
+		return msg.channel.send(embed);
+	}
+};

src/commands/remove.js

@@ -0,0 +1,31 @@
+module.exports = {
+  name: "remove",
+  alias: ["rm", "delete", "del"],
+  usage: "<song pos>",
+  description: "Remove a song from the queue",
+  permission: "MANAGE_MESSAGES",
+  category: "music control",
+  execute(msg, args, client, command) {
+    const queue = client.queue.get(msg.guild.id);
+    if (client.funcs.check(client, msg, command)) {
+      if (!args[1]) return msg.channel.send(client.messages.provideASong);
+      const pos = parseInt(args[1]);
+      if (isNaN(pos)) return msg.channel.send(client.messages.validNumber);
+      if (pos < 1) return msg.channel.send(client.messages.noSongs);
+      let message1;
+      let message2;
+      message1 = client.messages.queueLength.replace(
+        "%SONGS%",
+        queue.songs.length - 1
+      );
+      if (pos < 0) return msg.channel.send(client.messages.noSongsInQueue);
+      if (pos >= queue.songs.length) return msg.channel.send(message1);
+      message2 = client.messages.removed.replace(
+        "%SONG%",
+        queue.songs[pos].title
+      );
+      msg.channel.send(message2);
+      return queue.songs.splice(pos, 1);
+    }
+  },
+};

src/commands/replay.js

@@ -0,0 +1,15 @@
+module.exports = {
+    name: 'replay',
+    alias: ["rp"],
+    usage: '',
+    description: 'Replay the currently playing song.',
+    permission: 'MANAGE_MESSAGES',
+    category: 'play',
+    async execute(msg, args, client, command) {
+        const queue = client.queue.get(msg.guild.id);
+        if (client.funcs.check(client, msg, command)) {
+            queue.endReason = "replay";
+            queue.connection.dispatcher.end()
+        }
+    }
+};

src/commands/resume.js

@@ -0,0 +1,17 @@
+module.exports = {
+	name: 'resume',
+	alias: ["continue"],
+	usage: '',
+	description: 'Resume the paused music.',
+	permission: 'MANAGE_MESSAGES',
+	category: 'music control',
+	execute(msg, args, client, command) {
+		const queue = client.queue.get(msg.guild.id);
+		if (client.funcs.check(client, msg, command)) {
+			if (!queue.paused) return msg.channel.send(client.messages.notPaused);
+			queue.paused = false;
+			queue.connection.dispatcher.resume();
+			return msg.channel.send(client.messages.resumed);
+		}
+	}
+};

src/commands/search.js

@@ -0,0 +1,61 @@
+const ytsr = require('ytsr');
+const he = require('he');
+const { EmbedBuilder } = require('discord.js');
+
+module.exports = {
+    name: 'search',
+    alias: ["sr", "find"],
+    usage: '<search word(s)>',
+    description: 'Search the top 10 queryes and choose one.',
+    permission: 'none',
+    category: 'play',
+    async execute(msg, args, client, command) {
+        const searchString = args.slice(1).join(" ");
+        const queue = client.queue.get(msg.guild.id);
+        const voiceChannel = msg.member.voice.channel;
+        if (!queue) {
+            if (!msg.member.voice.channel) return msg.channel.send(client.messages.noVoiceChannel);
+        } else {
+            if (voiceChannel !== queue.voiceChannel) return msg.channel.send(client.messages.wrongVoiceChannel);
+        }
+        if (!args[1]) return msg.channel.send(client.messages.noQuery);
+        if (voiceChannel.full) return msg.channel.send(client.messages.channelFull);
+        if (!voiceChannel.joinable) return msg.channel.send(client.messages.noPermsConnect);
+        if (!voiceChannel.speakable) return msg.channel.send(client.messages.noPermsSpeak);
+        ytsr(searchString, {
+            limit: 20,
+        }, async function (err, res) {
+            if (err) return console.log(err);
+            if (!res.items[0]) return msg.channel.send(client.messages.noResults);
+            const videoResults = res.items.filter(item => item.type === "video");
+            const videos = videoResults.slice(0, 10);
+            let index = 0;
+            const embed = new EmbedBuilder()
+                .setTitle(client.messages.songSelection)
+                .setDescription(`${videos.map(video2 => `**${++index}** ${he.decode(video2.title)} `).join('\n')}`)
+                .setFooter({ text: client.messages.provideANumber })
+                .setColor(client.config.embedColor)
+            msg.channel.send(embed);
+            try {
+                var response = await msg.channel.awaitMessages(message2 => message2.content > 0 && message2.content < 11 && message2.author === msg.author, {
+                    max: 1,
+                    time: 10000,
+                    errors: ['time']
+                });
+            } catch (err) {
+                console.error(err);
+                return msg.channel.send(client.messages.cancellingVideoSelection);
+            }
+            const videoIndex = parseInt(response.first().content) - 1;
+            client.spotify.searchTracks(`track:${videos[videoIndex].title}`)
+                .then(function (data) {
+                    client.funcs.handleVideo(
+                        videos[videoIndex].link, msg, voiceChannel, client, false, "ytdl",
+                        data.body.tracks.items[0]
+                    );
+                }, function (err) {
+                    console.log('Something went wrong!', err);
+                });
+        })
+    }
+};

src/commands/seek.js

@@ -0,0 +1,36 @@
+module.exports = {
+  name: "seek",
+  alias: ["none"],
+  usage: "<point in song (seconds)>",
+  description: "Seek to a specific point in the currently playing song.",
+  permission: "MANAGE_MESSAGES",
+  category: "music control",
+  async execute(msg, args, client, command) {
+    const queue = client.queue.get(msg.guild.id);
+    if (client.funcs.check(client, msg, command)) {
+      if (queue.nightCore)
+        return msg.channel.send(client.messages.disableNightCore);
+      if (!args[1])
+        return msg.channel.send(
+          `${client.messages.correctUsage}\`${
+            client.global.db.guilds[msg.guild.id].prefix
+          }seek ${command.usage}\``
+        );
+      const pos = parseInt(args[1]);
+      if (isNaN(pos)) return msg.channel.send(client.messages.validNumber);
+      if (pos < 0)
+        return msg.channel.send(client.messages.seekingPointPositive);
+      const totalLength = parseInt(queue.songs[0].info.lengthSeconds);
+      let message;
+      if (pos > totalLength) {
+        message = client.messages.seekMax.replace(
+          "%LENGTH%",
+          queue.songs[0].info.lengthSeconds
+        );
+        return msg.channel.send(message);
+      }
+
+      client.funcs.end(client, msg, pos, command);
+    }
+  },
+};

src/commands/settings.js

@@ -0,0 +1,55 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+  name: "settings",
+  alias: ["options", "ops", "preferences"],
+  usage: "<setting> <value(opt)>",
+  description: "Change the server settings for Musix.",
+  permission: "MANAGE_GUILD",
+  category: "util",
+  async execute(msg, args, client, command) {
+    let footer;
+    footer = client.messages.settingsFooter.replace(
+      "%PREFIX%",
+      client.global.db.guilds[msg.guild.id].prefix
+    );
+    const embed = new EmbedBuilder()
+      .setTitle(client.messages.settingsTitle)
+      .addFields(
+        { name: client.messages.settingsPrefix, value: client.messages.settingsPrefixDesc, inline: true },
+        { name: client.messages.settingsVolume, value: client.messages.settingsVolumeDesc, inline: true },
+        { name: client.messages.settingsBlacklist, value: client.messages.settingsBlacklistDesc, inline: true },
+        { name: client.messages.settingsPermissions, value: client.messages.settingsPermissionsDesc, inline: true },
+        { name: client.messages.settingsSetDj, value: client.messages.settingsSetDjDesc, inline: true },
+        { name: client.messages.settingsAnnounceSongs, value: client.messages.settingsAnnounceSongsDesc },
+        { name: client.messages.settingsBass, value: client.messages.settingsBassDesc, inline: true },
+        { name: client.messages.settingsAutoPlay, value: client.messages.settingsAutoPlayDesc, inline: true }
+      )
+      .setFooter({ text: footer })
+      .setAuthor({ name: client.user.username, iconURL: client.user.avatarURL() })
+      .setColor(client.config.embedColor);
+    const permissions = msg.channel.permissionsFor(msg.author);
+    if (msg.author.id !== client.config.devId) {
+      if (!permissions.has(command.permission))
+        return msg.channel.send(client.messages.noPermsManageSettings);
+    }
+    if (args[1]) {
+      const optionName = args[1].toLowerCase();
+      const option =
+        client.settingCmd.get(optionName) ||
+        client.settingCmd.find(
+          (cmd) => cmd.aliases && cmd.aliases.includes(optionName)
+        );
+      if (!option) return msg.channel.send(embed);
+      try {
+        option.execute(msg, args, client);
+      } catch (error) {
+        msg.reply(client.messages.errorExeOpt);
+        console.log(error.toString());
+        console.log(error.stack.replace(/at /g, "**at **"));
+      }
+    } else {
+      return msg.channel.send(embed);
+    }
+  },
+};

src/commands/settings/announcesongs.js

@@ -0,0 +1,17 @@
+module.exports = {
+    name: 'announcesongs',
+    async execute(msg, args, client) {
+        if (!args[2]) return msg.channel.send(`${client.messages.announceSongs} \`${client.global.db.guilds[msg.guild.id].announceSongs}\``);
+        if (args[2] === 'true') {
+            if (!client.global.db.guilds[msg.guild.id].announceSongs) {
+                client.global.db.guilds[msg.guild.id].announceSongs = true;
+                msg.channel.send(client.messages.announceSongsTrue);
+            } else return msg.channel.send(client.messages.announceSongsTrue);
+        } else if (args[2] === 'false') {
+            if (client.global.db.guilds[msg.guild.id].announceSongs) {
+                client.global.db.guilds[msg.guild.id].announceSongs = false;
+                msg.channel.send(client.messages.announceSongsFalse);
+            } else return msg.channel.send(client.messages.announceSongsFalse);
+        } else return msg.channel.send(client.messages.boolean);
+    }
+};

src/commands/settings/autoPlay.js

@@ -0,0 +1,17 @@
+module.exports = {
+    name: 'autoplay',
+    async execute(msg, args, client) {
+        if (!args[2]) return msg.channel.send(`${client.messages.autoPlay} \`${client.global.db.guilds[msg.guild.id].autoPlay}\``);
+        if (args[2] === 'true') {
+            if (!client.global.db.guilds[msg.guild.id].autoPlay) {
+                client.global.db.guilds[msg.guild.id].autoPlay = true;
+                msg.channel.send(client.messages.autoPlayTrue);
+            } else return msg.channel.send(client.messages.autoPlayTrue);
+        } else if (args[2] === 'false') {
+            if (client.global.db.guilds[msg.guild.id].autoPlay) {
+                client.global.db.guilds[msg.guild.id].autoPlay = false;
+                msg.channel.send(client.messages.autoPlayFalse);
+            } else return msg.channel.send(client.messages.autoPlayFalse);
+        } else return msg.channel.send(client.messages.boolean);
+    }
+};

src/commands/settings/bass.js

@@ -0,0 +1,14 @@
+module.exports = {
+    name: 'bass',
+    async execute(msg, args, client) {
+        if (!args[2]) return msg.channel.send(client.messages.currentDefaultBass + client.global.db.guilds[msg.guild.id].bass);
+        if (args[2] === "false") {
+            client.global.db.guilds[msg.guild.id].bass = false;
+            return msg.channel.send(client.messages.bassFalse);
+        }
+        const level = parseInt(args[2]);
+        if (isNaN(level)) return msg.channel.send(client.messages.validNumber);
+        client.global.db.guilds[msg.guild.id].bass = level;
+        msg.channel.send(`${client.messages.bassLevel} ${level}!`);
+    }
+};

src/commands/settings/blacklist.js

@@ -0,0 +1,115 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+  name: "blacklist",
+  async execute(msg, args, client) {
+    let embed;
+    switch (args[2]) {
+      case "add":
+        if (msg.mentions.channels.first()) {
+          if (
+            client.global.db.guilds[msg.guild.id].blacklist.includes(
+              msg.mentions.channels.first().id
+            )
+          )
+            return msg.channel.send(client.messages.channelAlreadyBlackListed);
+        } else if (
+          client.global.db.guilds[msg.guild.id].blacklist.includes(args[3])
+        )
+          return msg.channel.send(client.messages.channelAlreadyBlackListed);
+        if (
+          !msg.guild.channels.cache.get(args[3]) &&
+          !msg.mentions.channels.first()
+        )
+          return msg.channel.send(client.messages.idOrMentionChannel);
+        if (msg.mentions.channels.first()) {
+          client.global.db.guilds[msg.guild.id].blacklist.push(
+            msg.mentions.channels.first().id
+          );
+          let message;
+          message = client.messages.channelAdded.replace(
+            "%CHANNEL%",
+            msg.mentions.channels.first().name
+          );
+          msg.channel.send(message);
+        } else {
+          client.global.db.guilds[msg.guild.id].blacklist.push(args[3]);
+          let message;
+          message = client.messages.channelAdded.replace(
+            "%CHANNEL%",
+            msg.guild.channels.cache.get(args[3]).name
+          );
+          msg.channel.send(message);
+        }
+        break;
+      case "remove":
+        if (msg.mentions.channels.first()) {
+          if (
+            !client.global.db.guilds[msg.guild.id].blacklist.includes(
+              msg.mentions.channels.first().id
+            )
+          )
+            return msg.channel.send(client.messages.channelNotBlackListed);
+          if (
+            client.global.db.guilds[msg.guild.id].blacklist.indexOf(
+              msg.mentions.channels.first().id
+            ) !== -1
+          ) {
+            client.global.db.guilds[msg.guild.id].blacklist.splice(
+              client.global.db.guilds[msg.guild.id].blacklist.indexOf(
+                msg.mentions.channels.first().id
+              ),
+              1
+            );
+            let message;
+            message = client.messages.channelRemoved.replace(
+              "%CHANNEL%",
+              msg.mentions.channels.first().name
+            );
+            msg.channel.send(message);
+          }
+        } else {
+          if (!client.global.db.guilds[msg.guild.id].blacklist.includes(args[3]))
+            return msg.channel.send(client.messages.channelNotBlackListed);
+          if (
+            client.global.db.guilds[msg.guild.id].blacklist.indexOf(args[3]) !==
+            -1
+          ) {
+            client.global.db.guilds[msg.guild.id].blacklist.splice(
+              client.global.db.guilds[msg.guild.id].blacklist.indexOf(args[3]),
+              1
+            );
+            let message;
+            message = client.messages.channelRemoved.replace(
+              "%CHANNEL%",
+              msg.guild.channels.cache.get(args[3]).name
+            );
+            msg.channel.send(message);
+          }
+        }
+        break;
+      case "list":
+        embed = new EmbedBuilder()
+          .setTitle(client.messages.blacklistTitle)
+          .setDescription(
+            `${client.global.db.guilds[msg.guild.id].blacklist
+            .map((c) => `**-** <#${c}>`)
+            .join("\n")}`
+          )
+          .setColor(client.config.embedColor);
+        msg.channel.send(embed);
+        break;
+      case undefined:
+        embed = new EmbedBuilder()
+          .setTitle(client.messages.blacklistTitle)
+          .addFields(
+            { name: "add", value: "Add a channel to the blacklist. (ID or mention)" },
+            { name: "remove", value: "Remove a channel from the blacklist. (ID or mention)" },
+            { name: "list", value: "List the currently blacklisted channels." }
+          )
+          .setColor(client.config.embedColor);
+        msg.channel.send(embed);
+        break;
+    }
+  },
+};

src/commands/settings/permissions.js

@@ -0,0 +1,17 @@
+module.exports = {
+    name: 'permissions',
+    async execute(msg, args, client) {
+        if (!args[2]) return msg.channel.send(`${client.messages.permission} \`${client.global.db.guilds[msg.guild.id].permissions}\``);
+        if (args[2] === 'true') {
+            if (!client.global.db.guilds[msg.guild.id].permissions) {
+                client.global.db.guilds[msg.guild.id].permissions = true;
+                msg.channel.send(client.messages.permissionsSetTrue);
+            } else return msg.channel.send(client.messages.permissionsTrue);
+        } else if (args[2] === 'false') {
+            if (client.global.db.guilds[msg.guild.id].permissions) {
+                client.global.db.guilds[msg.guild.id].permissions = false;
+                msg.channel.send(client.messages.permissionsSetFalse);
+            } else return msg.channel.send(client.messages.permissionsFalse);
+        } else return msg.channel.send(client.messages.boolean);
+    }
+};

src/commands/settings/prefix.js

@@ -0,0 +1,9 @@
+module.exports = {
+    name: 'prefix',
+    async execute(msg, args, client) {
+        if (!args[2]) return msg.channel.send(`${client.messages.currentPrefix} \`${client.global.db.guilds[msg.guild.id].prefix}\``);
+        if (args[2].length > 5) return msg.channel.send(client.messages.prefixMaxLength);
+        client.global.db.guilds[msg.guild.id].prefix = args[2];
+        msg.channel.send(`${client.messages.prefixSet} \`${args[2]}\``);
+    }
+};

src/commands/settings/premium.js

@@ -0,0 +1,27 @@
+module.exports = {
+  name: "premium",
+  async execute(msg, args, client) {
+    if (!args[2])
+      return msg.channel.send(
+        client.messages.premiumState +
+          client.global.db.guilds[msg.guild.id].premium
+      );
+    if (client.global.db.guilds[args[2]].premium === false) {
+      client.global.db.guilds[args[2]].premium = true;
+      let message;
+      message = client.messages.nowPremium.replace(
+        "%GUILD%",
+        client.guilds.cache.get(args[2]).name
+      );
+      msg.channel.send(message);
+    } else if (client.global.db.guilds[args[2]].premium === true) {
+      client.global.db.guilds[args[2]].premium = false;
+      let message;
+      message = client.messages.noMorePremium.replace(
+        "%GUILD%",
+        client.guilds.cache.get(args[2]).name
+      );
+      msg.channel.send(message);
+    }
+  },
+};

src/commands/settings/reset.js

@@ -0,0 +1,18 @@
+module.exports = {
+    name: 'reset',
+    async execute(msg, args, client) {
+        client.global.db.guilds[msg.guild.id] = {
+            prefix: client.config.prefix,
+            defaultVolume: client.config.defaultVolume,
+            permissions: client.config.permissions,
+            dj: client.config.dj,
+            djrole: client.config.djrole,
+            startPlaying: client.config.startPlaying,
+            bass: client.config.bass,
+            blacklist: [],
+            premium: false,
+            autoPlay: client.config.autoPlay,
+        };
+        msg.channel.send(client.messages.reset);
+    }
+};

src/commands/settings/setDj.js

@@ -0,0 +1,30 @@
+module.exports = {
+    name: 'setdj',
+    async execute(msg, args, client) {
+        if (!client.global.db.guilds[msg.guild.id].dj) {
+            if (!client.global.db.guilds[msg.guild.id].permissions) {
+                client.global.db.guilds[msg.guild.id].permissions = true;
+            }
+            if (msg.guild.roles.cache.find(x => x.name === "DJ")) {
+                client.global.db.guilds[msg.guild.id].djrole = msg.guild.roles.cache.find(x => x.name === "DJ").id;
+                msg.channel.send(client.messages.djRoleFound);
+                client.global.db.guilds[msg.guild.id].dj = true;
+            } else {
+                const permissions = msg.channel.permissionsFor(msg.client.user);
+                if (!permissions.has('MANAGE_ROLES')) return msg.channel.send(client.messages.noPermsManageRoles);
+                msg.guild.createRole({
+                        name: 'DJ',
+                    })
+                    .then(role => client.global.db.guilds[msg.guild.id].djrole = role.id)
+                    .catch((error) => {
+                        console.log(error);
+                    })
+                client.global.db.guilds[msg.guild.id].dj = true;
+                msg.channel.send(client.messages.djRoleCreated);
+            }
+        } else {
+            client.global.db.guilds[msg.guild.id].dj = false;
+            msg.channel.send(client.messages.djFalse);
+        }
+    }
+};

src/commands/settings/volume.js

@@ -0,0 +1,10 @@
+module.exports = {
+    name: 'volume',
+    async execute(msg, args, client) {
+        if (!args[2]) return msg.channel.send(`${client.messages.currentDefaultVolume} \`${client.global.db.guilds[msg.guild.id].defaultVolume}\``);
+        if (isNaN(args[2])) return msg.channel.send(client.messages.defaultVolumeNumber);
+        if (args[2].length > 2) return msg.channel.send(client.messages.defaultVolumeMax);
+        client.global.db.guilds[msg.guild.id].defaultVolume = args[2];
+        msg.channel.send(`${client.messages.defaultVolumeSet} \`${args[2]}\``);
+    }
+};

src/commands/shuffle.js

@@ -0,0 +1,15 @@
+module.exports = {
+    name: 'shuffle',
+    alias: ["none"],
+    usage: '',
+    description: 'Shuffle the queue.',
+    permission: 'MANAGE_MESSAGES',
+    category: 'music control',
+    execute(msg, args, client, command) {
+        const queue = client.queue.get(msg.guild.id);
+        if (client.funcs.check(client, msg, command)) {
+            client.funcs.shuffle(queue.songs);
+            msg.channel.send(client.messages.shuffled);
+        }
+    }
+};

src/commands/skip.js

@@ -0,0 +1,63 @@
+module.exports = {
+  name: "skip",
+  alias: ["s", "next"],
+  usage: "",
+  description: "Skip the currently playing song.",
+  permission: "MANAGE_MESSAGES",
+  category: "music control",
+  execute(msg, args, client, command) {
+    const queue = client.queue.get(msg.guild.id);
+    const permissions = msg.channel.permissionsFor(msg.author);
+    if (!queue || !queue.playing)
+      return msg.channel.send(client.messages.noServerQueue);
+    if (msg.author.id !== client.config.devId) {
+      if (msg.member.voice.channel !== queue.voiceChannel)
+        return msg.channel.send(client.messages.wrongVoiceChannel);
+      if (client.global.db.guilds[msg.guild.id].permissions) {
+        if (
+          !msg.member.roles.cache.has(
+            client.global.db.guilds[msg.guild.id].djrole
+          ) ||
+          !permissions.has(command.permission)
+        ) {
+          return vote(queue, msg, client);
+        } else {
+          return skipSong(queue, msg, client);
+        }
+      } else {
+        return skipSong(queue, msg, client);
+      }
+    } else {
+      return skipSong(queue, msg, client);
+    }
+  },
+};
+
+function skipSong(queue, msg, client) {
+  msg.channel.send(client.messages.skipped);
+  queue.endReason = "skip";
+  queue.time = 0;
+  queue.connection.dispatcher.end();
+}
+
+function vote(queue, msg, client) {
+  queue.votesNeeded = Math.floor(queue.voiceChannel.members.size / 2);
+  queue.votesNeeded.toFixed();
+  if (queue.voiceChannel.members.size > 2) {
+    if (queue.voters.includes(msg.member.id))
+      return msg.channel.send(client.messages.alreadyVoted);
+    queue.votes++;
+    queue.voters.push(msg.member.id);
+    if (queue.votes >= queue.votesNeeded) {
+      queue.voters = [];
+      queue.votes = 0;
+      queue.votesNeeded = null;
+      return skipSong(queue, msg, client);
+    } else
+      return msg.channel.send(
+        `${client.messages.notEnoughVotes} ${queue.votes} / ${queue.votesNeeded}!`
+      );
+  } else {
+    return skipSong(queue, msg, client);
+  }
+}

src/commands/skipto.js

@@ -0,0 +1,30 @@
+module.exports = {
+  name: "skipto",
+  alias: ["st"],
+  usage: "<point in queue>",
+  description: "Skip to a point in the queue",
+  permission: "MANAGE_MESSAGES",
+  category: "music control",
+  async execute(msg, args, client, command) {
+    const queue = client.queue.get(msg.guild.id);
+    if (client.funcs.check(client, msg, command)) {
+      if (!args[1])
+        return msg.channel.send(
+          `${client.messages.correctUsage}\`${command.usage}\``
+        );
+      let point = parseInt(args[1]);
+      point = point - 1;
+      if (isNaN(point)) return msg.channel.send(client.messages.validNumber);
+      if (point > queue.songs.length - 1)
+        return msg.channel.send(client.messages.noSongs);
+      if (point < 0) return msg.channel.send(client.messages.cantSkipToCurrent);
+      for (let i = 0; i < point; i++) {
+        queue.prevSongs.push(queue.songs.shift());
+      }
+      msg.channel.send(client.messages.skipped);
+      queue.endReason = "skipto";
+      queue.time = 0;
+      queue.connection.dispatcher.end();
+    }
+  },
+};

src/commands/status.js

@@ -0,0 +1,29 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+    name: 'status',
+    alias: ["stats", "info"],
+    usage: '',
+    description: 'See the current status for Musix.',
+    permission: 'none',
+    category: 'info',
+    execute(msg, args, client, command) {
+        const uptime = client.funcs.msToTime(client.uptime, "dd:hh:mm:ss");
+        msg.channel.send(client.messages.pinging).then(m => {
+            const latency = m.createdTimestamp - msg.createdTimestamp;
+
+            const embed = new EmbedBuilder()
+                .setTitle(client.messages.statusTitle)
+                .addFields(
+                    { name: client.messages.statusField1, value: client.ws.ping, inline: true },
+                    { name: client.messages.statusField2, value: latency, inline: true },
+                    { name: client.messages.statusField3, value: uptime, inline: true },
+                    { name: client.messages.statusField4, value: client.shard.ids },
+                )
+                .setAuthor({ name: client.user.username, iconURL: client.user.avatarURL() })
+                .setColor(client.config.embedColor)
+            m.delete();
+            return msg.channel.send(embed);
+        });
+    }
+};

src/commands/stop.js

@@ -0,0 +1,30 @@
+module.exports = {
+	name: 'stop',
+	description: 'Stop the music and clear the queue.',
+	alias: ["none"],
+	usage: '',
+	permission: 'MANAGE_CHANNELS',
+	category: 'music control',
+	execute(msg, args, client, command) {
+		const queue = client.queue.get(msg.guild.id);
+		if (client.funcs.check(client, msg, command)) {
+			if (msg.content.includes("-force")) {
+				if (queue) {
+					queue.voiceChannel.leave();
+					queue.exists = false;
+				}
+				if (msg.guild.voice.channel) msg.guild.voice.channel.leave();
+				client.queue.delete(msg.guild.id);
+				return msg.channel.send(client.messages.stop);
+			}
+			if (!queue || !queue.playing) {
+				return msg.channel.send(client.messages.noServerQueue);
+			}
+			queue.songs = [];
+			queue.looping = false;
+			queue.endReason = "stop";
+			queue.connection.dispatcher.end();
+			msg.channel.send(client.messages.stop);
+		}
+	}
+};

src/commands/volume.js

@@ -0,0 +1,22 @@
+module.exports = {
+	name: 'volume',
+	description: 'Volume command.',
+	alias: ["none"],
+	usage: '<volume>',
+	cooldown: 5,
+	permission: 'MANAGE_MESSAGES',
+	category: 'music control',
+	execute(msg, args, client, command) {
+		const queue = client.queue.get(msg.guild.id);
+		if (!args[1] && queue) return msg.channel.send(`${client.messages.currentVolume}**${queue.volume}**`);
+		const volume = parseFloat(args[1]);
+		if (client.funcs.check(client, msg, command)) {
+			if (isNaN(volume)) return msg.channel.send(client.messages.validNumber);
+			if (volume > 100) return msg.channel.send(client.messages.maxVolume);
+			if (volume < 0) return msg.channel.send(client.messages.positiveVolume);
+			queue.volume = volume;
+			queue.connection.dispatcher.setVolume(volume / 100);
+			return msg.channel.send(`${client.messages.setVolume}**${volume}**`);
+		}
+	}
+};

src/config/config.js

@@ -0,0 +1,99 @@
+require("dotenv/config");
+
+module.exports = {
+  discord_api_token: process.env.DISCORD_API_TOKEN,
+  bodKey: process.env.BODKEY,
+  youtube_api_key: process.env.YOUTUBE_API_KEY,
+  genius_api_key: process.env.GENIUS_API_KEY,
+  soundcloud_api_key: process.env.SOUNDCLOUD_API_KEY,
+  spotify_access_key: process.env.SPOTIFY_ACCESS_KEY,
+  spotify_client_secret: process.env.SPOTIFY_CLIENT_SECRET,
+  spotify_client_id: process.env.SPOTIFY_CLIENT_ID,
+  spotify_refresh_token: process.env.SPOTIFY_REFRESH_TOKEN,
+  lastfm_api_key: process.env.LASTFM_API_KEY,
+  lastfm_secret: process.env.LASTFM_SECRET,
+  port: 8888,
+  redirectUri: "http://localhost:8888/callback/",
+  testServer: "489111553321336832",
+  primary_test_channel: "617633098296721409",
+  secondary_test_channel: "570531724002328577",
+  devId: "360363051792203779",
+  embedColor: "#b50002",
+  invite: "https://musix-web.herokuapp.com/releases",
+  supportServer: "https://musix-web.herokuapp.com/discord",
+  devMode: false,
+  api: false,
+  saveDB: true,
+  respawn: true,
+  shards: 10,
+  shardDelay: 10000,
+  spawnTimeout: 60000,
+  respawnDelay: 1000,
+  prefix: ">",
+  devPrefix: "-",
+  defaultVolume: 50,
+  permissions: false,
+  dj: false,
+  djrole: null,
+  startPlaying: true,
+  bass: 1,
+  autoPlay: false,
+};
+
+module.exports.streamConfig = {
+  ytdlOptions: {
+    filter: "audio",
+    highWaterMark: 1 << 25,
+    volume: false,
+    requestOptions: {
+      maxRedirects: 4,
+    },
+  },
+  options: {
+    seek: null,
+    bitrate: 1024,
+    volume: 1,
+    type: "converted",
+  },
+};
+
+module.exports.queueConfig = {
+  textChannel: null,
+  voiceChannel: null,
+  connection: null,
+  songs: [],
+  volume: null,
+  bass: null,
+  nightCore: false,
+  playing: false,
+  paused: false,
+  looping: false,
+  songLooping: false,
+  votes: 0,
+  voters: [],
+  votesNeeded: null,
+  time: 0,
+  endReason: null,
+};
+
+module.exports.emojis = {
+  garbage: "🗑️ ",
+  green_check_mark: "<:green_check_mark:674265384777416705> ",
+  loading: "<a:loading:674284196700618783> ",
+  loudSound: ":loud_sound: ",
+  megaPhone: "📣 ",
+  notes: "<a:aNotes:674602408105476106>",
+  pause: "<:pause:674685548610322462> ",
+  previous: "<:reverse:705012312142119012> ",
+  redx: "<:redx:674263474704220182> ",
+  repeat: "<:repeat1:674685561377914892> ",
+  repeatSong: "<:repeatsong:674685573419761716> ",
+  resume: "<:resume:674685585478254603> ",
+  shuffle: "<:shuffle:674685595980791871> ",
+  signal: ":signal_strength: ",
+  skip: "<:skip:674685614221688832> ",
+  speaker: ":speaker: ",
+  stop: "<:stop:674685626108477519> ",
+  stopWatch: ":stopwatch: ",
+  volumeHigh: "<:volumehigh:674685637626167307> ",
+};

src/config/messages.js

@@ -0,0 +1,197 @@
+const {
+  emojis
+} = require("./config.js");
+
+module.exports = {
+  emojis: emojis,
+  albumAdded: emojis.green_check_mark +
+    "Album has been added to the queue!",
+  alreadyPaused: emojis.redx + "The music is already paused!",
+  alreadyVoted: emojis.redx + "You have already voted to skip!",
+  announceSongs: emojis.megaPhone + "Current setting:",
+  announceSongsFalse: emojis.green_check_mark + "announcesongs now set to `false`!",
+  announceSongsTrue: emojis.green_check_mark + "announcesongs now set to `true`!",
+  autoPlay: "Current setting:",
+  autoPlayFalse: emojis.green_check_mark + "autoplay now set to `false`!",
+  autoPlayTrue: emojis.green_check_mark + "autoplay now set to `true`!",
+  bassApplied: emojis.volumeHigh + "The bass level **%BASS%** has been applied!",
+  bassFalse: emojis.green_check_mark + "Bass is now false!",
+  bassLevel: emojis.green_check_mark + "Bass level is now",
+  blacklistTitle: "Currently blacklisted channels:",
+  blackListedVC: emojis.redx +
+    "Your voiceChannel is blacklisted! Please choose another channel!",
+  boolean: emojis.redx + "Please define a boolean! (true/false)",
+  cancellingVideoSelection: emojis.redx + "Cancelling video selection",
+  cantSkipToCurrent: emojis.redx + "You can't skip to the song currently playing!",
+  channelAdded: emojis.green_check_mark + "Channel %CHANNEL% added to the blacklist!",
+  channelAlreadyBlackListed: emojis.redx + "That channel is already blacklisted!",
+  channelFull: emojis.redx + "Your voice channel is full!",
+  channelNotBlackListed: emojis.redx + "That channel is not blacklisted or does not exist!",
+  channelRemoved: emojis.green_check_mark +
+    "Channel %CHANNEL% has been removed from the blacklist!",
+  cmdUsesFooter: "These statistics are from the current uptime.",
+  cmdUsesTitle: "Musix Command Usage During Current Uptime",
+  correctUsage: emojis.redx + "correct usage: ",
+  currentBass: emojis.loudSound + "The current bass is: ",
+  currentDefaultBass: emojis.speaker + "Currect default bass level: ",
+  currentDefaultVolume: emojis.speaker + "Current default volume is:",
+  currentNightCore: emojis.speaker + "Currect Nightcore setting: ",
+  currentPrefix: "Current prefix:",
+  currentVolume: emojis.loudSound + "The current volume is: ",
+  dbSaved: emojis.green_check_mark + "DB Saved!",
+  defaultVolumeMax: emojis.redx +
+    "The default volume must be below `100` for quality and safety resons.",
+  defaultVolumeNumber: emojis.redx +
+    "I'm sorry, But the default volume needs to be a valid __number__.",
+  defaultVolumeSet: emojis.green_check_mark + "Default volume set to:",
+  devMode: emojis.redx +
+    "Dev mode has been turned on! Commands are only available to developer(s)!",
+  disabledSpotifySongs: emojis.redx + "Spotify songs cannot be played currently!",
+  disableNightCore: emojis.redx + "Please disable nightCore in order to use this command!",
+  dispatcherError: "Error with the dispatcher: ",
+  djFalse: emojis.green_check_mark + "`DJ` now set to `false`",
+  djRoleCreated: emojis.green_check_mark +
+    "I did not find a role `DJ` so i have created one for you!",
+  djRoleFound: emojis.green_check_mark +
+    "I found a `DJ` role from this guild! This role is now the DJ role.",
+  error: emojis.redx + "An error occured!.\nError: ",
+  errorConnecting: "Error with connecting to voice channel: ",
+  errorDetected: "Error detected: ",
+  errorDispatcher: emojis.redx +
+    "An error has occured while playing music! The queue has been deleted.\nError: ",
+  errorExe: emojis.redx + "there was an error trying to execute that command!",
+  errorExeOpt: emojis.redx + "there was an error trying to execute that option!",
+  evalTitle: "Evaluation Command",
+  failedToLoad: emojis.redx + "Songs failed to load: ",
+  helpCmdFooter: "Command Alias:",
+  helpFooter: '"%PREFIX%help <command>" to see more information about a command.',
+  helpTitle: "help",
+  idOrMentionChannel: emojis.redx + "Please provide a channel id or mention a channel!",
+  invalidGuild: emojis.redx + "Invalid guild id!",
+  invalidSpotifyUrl: emojis.redx + "That url cannot be played! If you believe this is a mistake please contact support!",
+  inviteTitle: "Invite a release of Musix to your discord server!",
+  joined: emojis.green_check_mark + "Joined",
+  joinSupport: "Join the musix support server: ",
+  keySet: emojis.green_check_mark + "Key set!",
+  leftAlone: "I have left the channel as i was left alone.",
+  loadingSongs: emojis.loading + "Loading song(s)",
+  looping: emojis.repeat + "Looping the queue now!",
+  loopingSong: emojis.repeatSong + "Looping **%TITLE%** now!",
+  lyricsTitle: "Lyrics",
+  lyricsUsage: emojis.redx + "Provide a song to search for!",
+  maxBass: emojis.redx + "The max bass is `10`!",
+  maxVolume: emojis.redx + "The max volume is `100`!",
+  mentionChannel: emojis.redx + "Please mention a channel!",
+  musicCommandsDisabled: emojis.redx +
+    "This channels has been blacklisted! Music commands cannot be used here!",
+  nightCoreApplied: emojis.green_check_mark +
+    "NightCore is now **%BOOLEAN%** this will be applied when the next song starts playing!",
+  noDj: emojis.redx + "You need the `DJ` role to use this command!",
+  noLooping: emojis.repeat + "No longer looping the queue!",
+  noLoopingSong: emojis.repeatSong + "No longer looping the song!",
+  noMorePremium: ":cry: Guild %GUILD% is no longer premium!",
+  noPerms: emojis.redx + `You need the %PERMS% permission to use this command!`,
+  noPermsConnect: emojis.redx +
+    "I cannot connect to your voice channel, make sure I have the proper permissions!",
+  noPermsEmbed: emojis.redx +
+    "I cannot send embeds (Embed links), make sure I have the proper permissions!",
+  noPermsManageRoles: emojis.redx +
+    "I cannot create roles (Manage roles), make sure I have the proper permissions! I will need this permission to create a `DJ` role since i did not find one!",
+  noPermsManageSettings: emojis.redx +
+    "You need the `MANAGE_SERVER` permission to change the settings!",
+  noPermsSpeak: emojis.redx +
+    "I cannot speak in your voice channel, make sure I have the proper permissions!",
+  noPermsUseExternalEmojis: emojis.redx +
+    "I cannot use external emojis, make sure I have the proper permissions!",
+  noPreviousSongs: emojis.redx + "No previous songs!",
+  noQuery: emojis.redx + "you need to use a link or search for a song!",
+  noResults: emojis.redx + "I could not obtain any search results!",
+  noResultsLyrics: emojis.redx + "I could not obtain any results!",
+  noResultsSpotify: emojis.redx +
+    "I could not obtain any results!",
+  noServerQueue: emojis.redx + "There is nothing playing!",
+  noSimilarResults: emojis.redx + "No similar songs found!",
+  noSongs: emojis.redx + "That song does not exist!",
+  noSongsInQueue: emojis.redx + "There are no songs in the queue!",
+  notPremium: emojis.redx + "This is not a premium guild!",
+  nowPlayingDesc: emojis.notes + "**Now playing:**",
+  notAllowed: emojis.redx + "You are not allowed to do that!",
+  notEnoughVotes: emojis.redx + "Not enough votes!",
+  notPaused: emojis.redx + "The music in not paused!",
+  noVoiceChannel: emojis.redx +
+    "I'm sorry but you need to be in a voice channel to play music!",
+  nowPlaying: "__Now playing__",
+  nowPremium: ":tada: Guild %GUILD% is now premium!",
+  paused: emojis.pause + "Paused the music!",
+  permission: "🔒 Permission requirement:",
+  permissionsFalse: emojis.redx + "That value is already `false`!",
+  permissionsSetFalse: emojis.green_check_mark + "Permissions requirement now set to: `false`",
+  permissionsSetTrue: emojis.green_check_mark + "Permissions requirement now set to: `true`",
+  permissionsTrue: emojis.redx + "That value is already `true`!",
+  pinging: emojis.loading + "Pinging...",
+  playlistAdded: emojis.green_check_mark +
+    "Playlist: **%TITLE%** has been added to the queue!",
+  positiveBass: emojis.redx + "The bass needs to be a positive number!",
+  positiveVolume: emojis.redx + "The volume needs to be a positive number!",
+  prefixHere: "My prefix here is: ",
+  prefixMaxLength: "The prefix must be shorter or equal to 5 letters!",
+  prefixSet: emojis.green_check_mark + "New prefix set to:",
+  premiumState: "Premium status: ",
+  previousSong: emojis.previous + "Previous",
+  provideANumber: "Please provide a number ranging from 1-10 to select one of the search results.",
+  provideASong: emojis.redx + "Please provide a song position in queue for me to remove!",
+  queueDeleted: "Queue deleted!",
+  queueDesc: "**Now playing:** %SONG%<a:aNotes:674602408105476106>\n:arrow_down: Next in queue :arrow_down:",
+  queueFooter: "songs in the queue!",
+  queueLength: emojis.redx + "There are only %SONGS% song(s) in the queue!",
+  queueTitle: "__Song queue__",
+  quotaReached: emojis.redx +
+    "Quota reached please try again after midnight Pacific Time (PT)!",
+  reloaded: "All files reloaded!",
+  removed: emojis.garbage + "removed `%SONG%` from the queue!",
+  reset: emojis.green_check_mark + "Reset __all__ guild settings!",
+  restart: "restarting all shards...",
+  resumed: emojis.resume + "Resumed the music!",
+  searchSimilarUsage: emojis.redx + "Correct usage: %USAGE%",
+  seekingPointPositive: emojis.redx + "The seeking point needs to be a positive number!",
+  seekMax: emojis.redx +
+    "The lenght of this song is %LENGTH% seconds! You can't seek further than that!",
+  settingsAnnounceSongs: "announcesongs",
+  settingsAnnounceSongsDesc: "Whether to announce songs that start playing or not.",
+  settingsAutoPlay: "autoplay",
+  settingsAutoPlayDesc: "When the queue ends similar songs will be played.",
+  settingsBass: "bass",
+  settingsBassDesc: "Change the default bass level.",
+  settingsBlacklist: "blacklist",
+  settingsBlacklistDesc: "Blacklist channels that you wan't to block music commands to be executed on or block the bot from joining certain voiceChannels.",
+  settingsFooter: "how to use: %PREFIX%settings <Setting name> <value>",
+  settingsPermissions: "permissions",
+  settingsPermissionsDesc: "Change whether to require permissions to use eg `skip, stop, pause, loop, etc...`",
+  settingsPrefix: "prefix",
+  settingsPrefixDesc: "Change the guild specific prefix. (string)",
+  settingsSetDj: "setdj",
+  settingsSetDjDesc: "Set a DJ role. This will allow chosen users to freely use all Musix commands. This will automatically set the `permissions` settings to true in order for the `DJ` role to have effect!",
+  settingsTitle: "Guild settings for Musix",
+  settingsVolume: "volume",
+  settingsVolumeDesc: "Change the default volume that the bot will start playing at. (number)",
+  setVolume: emojis.volumeHigh + "I set the volume to: ",
+  shuffled: emojis.shuffle + "Queue suffled!",
+  skipped: emojis.skip + "Skipped the song!",
+  songAdded: emojis.green_check_mark + "**%TITLE%** has been added to the queue!",
+  songBlockedWMG: emojis.redx +
+    "This song had been blocked by WMG (Warner Music Groud).\n<:skip:674685614221688832> Skipped to next song.",
+  songsAdded: emojis.green_check_mark + "%AMOUNT% songs added to the queue!",
+  songSelection: "__Song Selection__",
+  startPlaying: emojis.notes + "Start playing: ",
+  statusField1: emojis.signal + "Ping",
+  statusField2: "Latency",
+  statusField3: emojis.stopWatch + "Uptime",
+  statusField4: "Shard: ",
+  statusTitle: "Status for Musix",
+  stop: emojis.stop + "Stopped the music!",
+  tookTooLong: emojis.redx + "Something took too long! Please try again!",
+  validNumber: emojis.redx + "I'm sorry, But you need to enter a valid __number__.",
+  videoUnavailable: emojis.redx + "That video is unavaiable! Please try again.",
+  wrongVoiceChannel: emojis.redx +
+    "I'm sorry but you need to be in the same voice channel as Musix to use this command!",
+};

src/events/clientEvents/guildCreate.js

@@ -0,0 +1,29 @@
+module.exports = {
+  name: "guildcreate",
+  async execute(client, guild) {
+    client.db.collection("guilds").doc(guild.id).set({
+      prefix: client.config.prefix,
+      defaultVolume: client.config.defaultVolume,
+      permissions: client.config.permissions,
+      dj: client.config.dj,
+      djrole: client.config.djrole,
+      startPlaying: client.config.startPlaying,
+      bass: client.config.bass,
+      blacklist: [],
+      premium: false,
+      autoPlay: client.config.autoPlay,
+    });
+    client.global.db.guilds[guild.id] = {
+      prefix: client.config.prefix,
+      defaultVolume: client.config.defaultVolume,
+      permissions: client.config.permissions,
+      dj: client.config.dj,
+      djrole: client.config.djrole,
+      startPlaying: client.config.startPlaying,
+      bass: client.config.bass,
+      blacklist: [],
+      premium: false,
+      autoPlay: client.config.autoPlay,
+    };
+  },
+};

src/events/clientEvents/guildDelete.js

@@ -0,0 +1,6 @@
+module.exports = {
+    name: "guildcreate",
+    async execute(client, guild) {
+        delete client.global.db.guilds[guild.id];
+    },
+};

src/events/clientEvents/handler.js

@@ -0,0 +1,36 @@
+module.exports = function (client) {
+    client.on('ready', () => {
+            require(`./ready.js`).execute(client);
+        }).on('message', (msg) => {
+            require(`./msg.js`).execute(client, msg);
+        }).on('guildCreate', (guild) => {
+            require(`./guildCreate.js`).execute(client, guild);
+        })
+        .on('guildDelete', (guild) => {
+            require(`./guildDelete.js`).execute(client, guild);
+        }).on('voiceStateUpdate', (oldState, newState) => {
+            require(`./voiceStateUpdate.js`).execute(client, oldState, newState);
+        }).on('error', (error) => {
+            console.log(error);
+        }).on('debug', (info) => {
+            if (client.config.devMode) console.log(info);
+        }).on('invalidated', () => {
+            console.log("Client session invalidated! Exiting the process!")
+            process.exit(1);
+        }).on('rateLimit', (rateLimitInfo) => {
+
+        }).on('shardDisconnect', (event, id) => {
+            client.logs.push(`Shard ${id} disconnected event ${event}`);
+        }).on('shardError', (error, shardId) => {
+            client.logs.push(`Shard ${shardId} error ${error}`);
+        }).on('shardReady', (id, unavailableGuilds) => {
+            client.logs.push(`Shard ${id} ready. Unavailable guilds: ${unavailableGuilds || 0}`);
+        }).on('shardReconnecting', (id) => {
+            client.logs.push(`shard ${id} reconnecting.`);
+        }).on('shardResume', (id, replayedEvents) => {
+            client.logs.push(`shard ${id} resume events ${replayedEvents}`);
+        }).on("warn", (info) => {
+            client.logs.push(`Warn! info: ${info}`);
+            console.log(`Warn! info: ${info}`);
+        });
+}

src/events/clientEvents/msg.js

@@ -0,0 +1,41 @@
+module.exports = {
+  name: "message",
+  async execute(client, msg, Discord) {
+    if (msg.author.bot || !msg.guild) return;
+    if (!client.global.db.guilds[msg.guild.id]) client.funcs.checkDB(client);
+    let prefix = client.global.db.guilds[msg.guild.id].prefix || client.config.prefix;
+    const args = msg.content.slice(prefix.length).split(" ");
+    if (client.config.devMode) prefix = client.config.devPrefix;
+    const permission = msg.channel.permissionsFor(client.user);
+    if (!permission.has("SEND_MESSAGES")) return;
+    if (msg.mentions.users.first()) {
+      if (msg.mentions.users.first().id === client.user.id) {
+        if (!args[1] || args[0] !== `@!${client.user.id}>`) return;
+        if (args[1] === "prefix") {
+          if (!args[2])
+            return msg.channel.send(
+              `${client.messages.prefixHere}\`${prefix}\`.`
+            );
+          if (args[2] === "=" && args[3]) return (prefix = args[3]);
+        }
+        args.shift();
+        getCommand(client, args, msg, Discord);
+      }
+    }
+    if (!msg.content.startsWith(prefix)) return;
+    getCommand(client, args, msg, Discord);
+  },
+};
+
+function getCommand(client, args, msg) {
+  if (!args[0]) return;
+  const commandName = args[0].toLowerCase();
+  if (commandName === "none") return;
+  const command =
+    client.commands.get(commandName) ||
+    client.commands.find(
+      (cmd) => cmd.alias && cmd.alias.includes(commandName)
+    );
+  if (!command) return;
+  client.funcs.exe(msg, args, client, command);
+}

src/events/clientEvents/ready.js

@@ -0,0 +1,45 @@
+module.exports = {
+  name: "ready",
+  async execute(client, Discord) {
+    const remoteMusixGuildsData = await client.funcs.dbget(
+      "guilds",
+      null,
+      client
+    );
+    remoteMusixGuildsData.forEach((guildData) => {
+      client.global.db.guilds[guildData.id] = guildData.d;
+    });
+    if (client.config.devMode) {
+      client.guilds.cache.forEach((guild) => {
+        client.global.db.guilds[guild.id] = {
+          prefix: client.config.devPrefix,
+          defaultVolume: client.config.defaultVolume,
+          permissions: client.config.permissions,
+          dj: client.config.dj,
+          djrole: client.config.djrole,
+          startPlaying: client.config.startPlaying,
+          bass: client.config.bass,
+          blacklist: [],
+          premium: true,
+          autoPlay: client.config.autoPlay,
+        };
+      });
+    }
+    console.log(`- DB Set - Shard: ${client.shard.ids} -`);
+    client.user.setActivity(`@${client.user.username} help | 🎶`, {
+      type: "LISTENING",
+    });
+    client.user.setStatus("online");
+    client.funcs.getSpotifyKey(client);
+    console.log(`- Activated - Shard: ${client.shard.ids} -`);
+    setInterval(() => {
+      if (!client.config.devMode) client.funcs.checkDB(client);
+    }, 60000);
+    setInterval(async () => {
+      client.funcs.saveDB(client);
+    }, 1800000);
+    setInterval(() => {
+      client.funcs.getSpotifyKey(client);
+    }, 3600000);
+  },
+};

src/events/clientEvents/voiceStateUpdate.js

@@ -0,0 +1,34 @@
+module.exports = {
+    name: 'voiceStateUpdate',
+    async execute(client, oldState, newState) {
+        if (oldState.channel === null) return newState.setSelfDeaf(true);
+        let change = false;
+        const queue = client.queue.get(newState.guild.id);
+        if (!queue) return;
+        if (newState.member.id === client.user.id && oldState.member.id === client.user.id) {
+            if (newState.member.voice.channel === null) {
+                queue.songs = [];
+                queue.looping = false;
+                queue.endReason = "manual disconnect";
+                return client.queue.delete(newState.guild.id);
+            }
+            if (newState.member.voice.channel !== queue.voiceChannel) {
+                change = true;
+                queue.voiceChannel = newState.member.voice.channel;
+                queue.connection = newState.connection;
+            }
+        }
+        if (oldState.channel.members.size === 1 && oldState.channel === queue.voiceChannel || change) {
+            setTimeout(() => {
+                if (!queue || !queue.connection.dispatcher || queue.connection.dispatcher === null) return;
+                if (queue.voiceChannel.members.size === 1) {
+                    queue.textChannel.send(client.messages.leftAlone);
+                    queue.songs = [];
+                    queue.looping = false;
+                    queue.endReason = "Timeout";
+                    queue.connection.dispatcher.end();
+                }
+            }, 120000);
+        }
+    }
+}

src/events/connectionEvents/handler.js

@@ -0,0 +1,21 @@
+module.exports = function (client, connection) {
+    connection.on("authenticated", () => {
+        if (client.config.devMode) console.log("Voice connection initiated.");
+    }).on("debug", (message) => {
+        if (client.config.devMode) console.log(message);
+    }).on("disconnect", () => {
+        if (client.config.devMode) console.log("Voice connection disconnected.");
+    }).on("error", (error) => {
+        console.log(error);
+    }).on("failed", (error) => {
+        if (client.config.devMode) console.log(error);
+    }).on("newSession", () => {
+        if (client.config.devMode) console.log("New voice session id received!");
+    }).on("ready", () => {
+        if (client.config.devMode) console.log("Voice connection ready.");
+    }).on("reconnecting", () => {
+        if (client.config.devMode) console.log("Voice connection reconnecting.");
+    }).on("warn", (warning) => {
+        console.log(`Voice connection warning: ${warning}`);
+    })
+}

src/events/dispatcherEvents/error.js

@@ -0,0 +1,14 @@
+module.exports = {
+    async execute(client, error, guild) {
+        const queue = client.queue.get(guild.id);
+        console.log(error);
+        /*if (error = "Error: input stream: This video contains content from WMG, who has blocked it on copyright grounds.") {
+            queue.endReason = "skip";
+            queue.connection.dispatcher.end();
+            return queue.textChannel.send(client.messages.songBlockedWMG);
+        }*/
+        queue.voiceChannel.leave();
+        client.queue.delete(guild.id);
+        return queue.textChannel.send(client.messages.errorDispatcher + `\`${error}\``);
+    },
+};

src/events/dispatcherEvents/finish.js

@@ -0,0 +1,95 @@
+const similarSongs = require("similar-songs");
+const ytdl = require("ytdl-core");
+
+module.exports = {
+  async execute(client, guild) {
+    const queue = client.queue.get(guild.id);
+    queue.playing = false;
+    if (queue.endReason === "seek") {
+      return (queue.playing = true);
+    }
+
+    if (!queue.songLooping) {
+      if (queue.looping) {
+        queue.songs.push(queue.songs[0]);
+      }
+
+      queue.time = 0;
+      queue.votes = 0;
+      queue.voters = [];
+      if (queue.endReason !== "replay") {
+        if (queue.endReason === "previous")
+          queue.songs.unshift(queue.prevSongs.pop());
+        if (queue.endReason !== "previous")
+          queue.prevSongs.push(queue.songs.shift());
+        if (
+          client.global.db.guilds[guild.id].autoPlay &&
+          !queue.songs[0] &&
+          queue.endReason !== "stop"
+        ) {
+          if (queue.prevSongs.length > 0)
+            return findSimilar(client, queue, queue.prevSongs, guild);
+        }
+      }
+    }
+    client.funcs.play(guild, queue.songs[0], client, 0, true);
+  },
+};
+
+function findSimilar(client, queue, prevSongs, guild) {
+  let retries = 0;
+  const query =
+    prevSongs[Math.floor(Math.random() * Math.floor(prevSongs.length))];
+  if (!query || !query.track) return findSimilar(client, queue, prevSongs, guild);
+  similarSongs.find({
+      title: query.track.name,
+      artist: query.track.artists[0].name,
+      limit: 10,
+      lastfmAPIKey: client.config.lastfm_api_key,
+      lastfmAPISecret: client.config.lastfm_secret,
+      youtubeAPIKey: client.config.youtube_api_key,
+    },
+    async function (err, songs) {
+      if (err) {
+        if (
+          err.message ==
+          'The request cannot be completed because you have exceeded your <a href="/youtube/v3/getting-started#quota">quota</a>.'
+        ) {
+          queue.voiceChannel.leave();
+          queue.exists = false;
+          client.queue.delete(guild.id);
+          queue.textChannel.send(client.messages.quotaReached);
+          return;
+        }
+        console.log(err.message);
+        queue.voiceChannel.leave();
+        queue.exists = false;
+        client.queue.delete(guild.id);
+        return queue.textChannel.send(client.messages.error);
+      }
+      if (songs[0]) {
+        const random = Math.floor(Math.random() * Math.floor(songs.length));
+        const songInfo = await ytdl.getInfo(
+          `https://www.youtube.com/watch?v=${songs[random].youtubeId}`
+        );
+        queue.songs.push({
+          title: songInfo.videoDetails.title,
+          url: `https://www.youtube.com/watch?v=${songs[random].youtubeId}`,
+          author: client.user,
+          type: "ytdl",
+          info: songInfo.videoDetails,
+          track: query.track,
+        });
+        client.funcs.play(guild, queue.songs[0], client, 0, true);
+      } else {
+        if (prevSongs.length > 4 && retries < 6) {
+          findSimilar(client, queue, prevSongs, guild);
+          retries++;
+          return;
+        }
+        queue.textChannel.send(client.messages.noSimilarResults);
+        client.funcs.play(guild, queue.songs[0], client, 0, true);
+      }
+    }
+  );
+}

src/events/dispatcherEvents/handler.js

@@ -0,0 +1,16 @@
+module.exports = function (client, dispatcher, queue, guild) {
+    dispatcher.on("finish", () => {
+            if (client.config.devMode) console.log("Dispatcher finish.");
+            require("./finish").execute(client, guild);
+        })
+        .on("start", () => {
+            if (client.config.devMode) console.log("Dispatcher start.");
+            queue.endReason = null;
+            dispatcher.player.streamingData.pausedTime = 0;
+        })
+        .on("error", (error) => {
+            require("./error").execute(client, error, guild);
+        }).on("debug", (info) => {
+            if (client.config.devMode) console.log(info);
+        })
+}

src/funcs/check.js

@@ -0,0 +1,34 @@
+module.exports = function (client, msg, command) {
+  const queue = client.queue.get(msg.guild.id);
+  const permissions = msg.channel.permissionsFor(msg.author);
+  if (!queue || !queue.playing && command.name !== "stop") {
+    msg.channel.send(client.messages.noServerQueue);
+    return false;
+  }
+  if (msg.author.id !== client.config.devId) {
+    if (msg.member.voice.channel !== queue.voiceChannel) {
+      msg.channel.send(client.messages.wrongVoiceChannel);
+      return false;
+    }
+    if (client.global.db.guilds[msg.guild.id].permissions === true) {
+      if (client.global.db.guilds[msg.guild.id].dj) {
+        if (
+          !msg.member.roles.cache.has(
+            client.global.db.guilds[msg.guild.id].djrole
+          )
+        ) {
+          msg.channel.send(client.messages.noDj);
+          return false;
+        } else return true;
+      } else if (!permissions.has(command.permission)) {
+        let message;
+        message = client.messages.noPerms.replace(
+          "%PERMS%",
+          command.permissions
+        );
+        msg.channel.send(message);
+        return false;
+      } else return true;
+    } else return true;
+  } else return true;
+};

src/funcs/checkDB.js

@@ -0,0 +1,52 @@
+module.exports = async function (client) {
+  client.guilds.cache.forEach((guild) => {
+    if (!client.global.db.guilds[guild.id]) {
+      client.db.collection("guilds").doc(guild.id).set({
+        prefix: client.config.prefix,
+        defaultVolume: client.config.defaultVolume,
+        permissions: client.config.permissions,
+        dj: client.config.dj,
+        djrole: client.config.djrole,
+        startPlaying: client.config.startPlaying,
+        bass: client.config.bass,
+        blacklist: [],
+        premium: false,
+        autoPlay: client.config.autoPlay,
+      });
+      client.global.db.guilds[guild.id] = {
+        prefix: client.config.prefix,
+        defaultVolume: client.config.defaultVolume,
+        permissions: client.config.permissions,
+        dj: client.config.dj,
+        djrole: client.config.djrole,
+        startPlaying: client.config.startPlaying,
+        bass: client.config.bass,
+        blacklist: [],
+        premium: false,
+        autoPlay: client.config.autoPlay,
+      };
+      return;
+    }
+    if (!client.global.db.guilds[guild.id].prefix)
+      client.global.db.guilds[guild.id].prefix = client.config.prefix;
+    if (!client.global.db.guilds[guild.id].defaultVolume)
+      client.global.db.guilds[guild.id].defaultVolume =
+      client.config.defaultVolume;
+    if (!client.global.db.guilds[guild.id].permissions)
+      client.global.db.guilds[guild.id].permissions = client.config.permissions;
+    if (!client.global.db.guilds[guild.id].dj)
+      client.global.db.guilds[guild.id].dj = client.config.dj;
+    if (!client.global.db.guilds[guild.id].djrole)
+      client.global.db.guilds[guild.id].djrole = client.config.djrole;
+    if (!client.global.db.guilds[guild.id].startPlaying)
+      client.global.db.guilds[guild.id].startPlaying =
+      client.config.startPlaying;
+    if (!client.global.db.guilds[guild.id].bass)
+      client.global.db.guilds[guild.id].bass = client.config.bass;
+    if (!client.global.db.guilds[guild.id].blacklist)
+      client.global.db.guilds[guild.id].blacklist = [];
+    if (!client.global.db.guilds[guild.id].premium)
+      client.global.db.guilds[guild.id].premium = false;
+    if (!client.global.db.guilds[guild.id].autoPlay) client.global.db.guilds[guild.id].autoPlay = client.config.autoPlay
+  });
+};

src/funcs/dbget.js

@@ -0,0 +1,22 @@
+module.exports = async function (collection, doc, client) {
+    if (doc) {
+        let d = await client.db.collection(collection).doc(doc).get().catch(err => {
+            console.log('Error getting document', err);
+            return 'error';
+        });
+        return d.data();
+    } else {
+        let d = await client.db.collection(collection).get().catch(err => {
+            console.log('Error getting document', err);
+            return 'error';
+        });
+        let finalD = [];
+        d.forEach(doc => {
+            finalD.push({
+                id: doc.id,
+                d: doc.data(),
+            });
+        });
+        return finalD;
+    }
+};

src/funcs/end.js

@@ -0,0 +1,12 @@
+module.exports = async function (client, msg, pos, command) {
+  const seek = parseInt(pos);
+  const queue = client.queue.get(msg.guild.id);
+  if (command.name === "seek") {
+    queue.time = seek * 1000;
+  } else {
+    queue.time = queue.connection.dispatcher.streamTime + queue.time;
+  }
+  queue.connection.dispatcher.end();
+  queue.endReason = "seek";
+  client.funcs.play(msg.guild, queue.songs[0], client, seek, false);
+};

src/funcs/exe.js

@@ -0,0 +1,20 @@
+module.exports = function (msg, args, client, command) {
+  const permissions = msg.channel.permissionsFor(client.user);
+  if (!permissions.has("EMBED_LINKS"))
+    return msg.channel.send(client.messages.noPermsEmbed);
+  if (!permissions.has("USE_EXTERNAL_EMOJIS"))
+    return msg.channel.send(client.messages.noPermsUseExternalEmojis);
+  if (
+    command.category === "music" &&
+    client.global.db.guilds[msg.guild.id].blacklist.includes(msg.channel.id)
+  )
+    return msg.channel.send(client.messages.musicCommandsDisabled);
+  try {
+    command.uses++;
+    command.execute(msg, args, client, command);
+  } catch (error) {
+    msg.reply(client.messages.errorExe);
+    console.log(error.toString());
+    console.log(error.stack.replace(/at /g, "**at **"));
+  }
+};

src/funcs/getSpotifyKey.js

@@ -0,0 +1,28 @@
+module.exports = async function (client) {
+
+    const request = require("request");
+
+    const refresh_token = client.config.spotify_refresh_token;
+    const authOptions = {
+        url: "https://accounts.spotify.com/api/token",
+        headers: {
+            Authorization: "Basic " +
+                new Buffer(client.config.spotify_client_id + ":" + client.config.spotify_client_secret).toString("base64"),
+        },
+        form: {
+            grant_type: "refresh_token",
+            refresh_token: refresh_token,
+        },
+        json: true,
+    };
+
+    request.post(authOptions, function (error, response, body) {
+        if (!error && response.statusCode === 200) {
+            client.spotify.setAccessToken(body.access_token);
+            client.config.spotify_access_key = body.access_token
+            if (client.config.devMode) console.log("- Spotify access token set -");
+        } else {
+            console.log("An error occured whilst getting spotify access key");
+        }
+    });
+};

src/funcs/handleVideo.js

@@ -0,0 +1,69 @@
+const ytdl = require("ytdl-core");
+
+module.exports = async function (
+  resource,
+  msg,
+  voiceChannel,
+  client,
+  playlist,
+  type,
+  spotifyTrackData
+) {
+  const songInfo = await ytdl.getInfo(resource).catch(err => console.log(err));
+  const song = {
+    title: songInfo.videoDetails.title,
+    url: resource,
+    author: msg.author,
+    type: type,
+    info: songInfo.videoDetails,
+    track: spotifyTrackData
+  };
+
+  const queue = client.queue.get(msg.guild.id);
+
+  if (queue) {
+    queue.songs.push(song);
+    queue.textChannel = msg.channel;
+    if (playlist) return;
+    let message;
+    message = client.messages.songAdded.replace("%TITLE%", song.title);
+    return msg.channel.send(message);
+  }
+
+  const construct = {
+    textChannel: msg.channel,
+    voiceChannel: voiceChannel,
+    connection: null,
+    songs: [],
+    prevSongs: [],
+    volume: client.global.db.guilds[msg.guild.id].defaultVolume,
+    bass: client.global.db.guilds[msg.guild.id].bass,
+    nightCore: false,
+    playing: false,
+    paused: false,
+    looping: false,
+    songLooping: false,
+    votes: 0,
+    voters: [],
+    votesNeeded: null,
+    time: 0,
+    endReason: null,
+    exists: true
+  };
+
+  construct.songs.push(song);
+
+  client.queue.set(msg.guild.id, construct);
+
+  try {
+    const connection = await voiceChannel.join();
+    construct.connection = connection;
+    require("../../events/connectionEvents/handler")(client, connection);
+    client.funcs.play(msg.guild, construct.songs[0], client, 0, true);
+  } catch (error) {
+    client.queue.delete(msg.guild.id);
+    console.log(error);
+    return msg.channel.send(client.messages.error + error);
+  }
+  return;
+};

src/funcs/msToTime.js

@@ -0,0 +1,17 @@
+module.exports = function msToTime(duration, format) {
+    var seconds = Math.floor((duration / 1000) % 60),
+        minutes = Math.floor((duration / (1000 * 60)) % 60),
+        hours = Math.floor((duration / (1000 * 60 * 60)) % 24),
+        days = Math.floor((duration / (1000 * 60 * 60 * 24)) % 24);
+
+    days = (days < 10) ? "0" + days : days;
+    hours = (hours < 10) ? "0" + hours : hours;
+    minutes = (minutes < 10) ? "0" + minutes : minutes;
+    seconds = (seconds < 10) ? "0" + seconds : seconds;
+
+    if (format === "hh:mm:ss") {
+        return `${hours}:${minutes}:${seconds}`;
+    } else if (format === "dd:hh:mm:ss") {
+        return `${days}:${hours}:${minutes}:${seconds}`;
+    }
+}

src/funcs/play.js

@@ -0,0 +1,94 @@
+const {
+  Readable: ReadableStream
+} = require("stream");
+const ytdl = require("ytdl-core");
+const {
+  streamConfig
+} = require("../config/config.js");
+const prism = require("prism-media");
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = async function (guild, song, client, seek, play) {
+  const queue = client.queue.get(guild.id);
+  if (!song) {
+    queue.voiceChannel.leave();
+    queue.exists = false;
+    client.queue.delete(guild.id);
+    return;
+  }
+  setTimeout(() => {
+    if (!queue.playing && queue.exists) {
+      queue.textChannel.send(client.messages.tookTooLong);
+      queue.voiceChannel.leave();
+      client.queue.delete(guild.id);
+      return;
+    }
+  }, 30000);
+
+  streamConfig.options.seek = seek;
+
+  let input = song.url;
+  if (song.type === "ytdl" || song.type === "spotify")
+    input = ytdl(song.url, streamConfig.ytdlOptions)
+    //.on('info', (info, format) => console.log(format))
+    .on("error", (error) => {
+      console.log(error)
+      queue.voiceChannel.leave();
+      client.queue.delete(guild.id);
+      queue.textChannel.send(client.messages.videoUnavailable)
+    });
+
+  const ffmpegArgs = [
+    "-analyzeduration",
+    "0",
+    "-loglevel",
+    "0",
+    "-f",
+    "s16le",
+    "-ar",
+    "48000",
+    "-ac",
+    "2",
+    "-af",
+    `bass=g=${queue.bass}`,
+  ];
+  client.funcs.sleep(500);
+  if (queue.nightCore) {
+    ffmpegArgs.push("-af");
+    ffmpegArgs.push("asetrate=52920");
+  }
+
+  const isStream = input instanceof ReadableStream;
+
+  const args = isStream ? ffmpegArgs.slice() : ["-i", input, ...ffmpegArgs];
+  args.unshift("-ss", String(seek));
+
+  const transcoder = new prism.FFmpeg({
+    args: args,
+  });
+
+  const stream = input.pipe(transcoder).on("error", (error) => {
+    console.log(error);
+  });
+
+  const dispatcher = queue.connection.play(stream, streamConfig.options)
+
+  dispatcher.setVolume(queue.volume / 100);
+
+  require("../events/dispatcherEvents/handler")(client, dispatcher, queue, guild);
+
+  if ((client.global.db.guilds[guild.id].startPlaying && play) || play) {
+    if (song.type !== "ytdl" && song.type !== "spotify") return;
+    const embed = new EmbedBuilder()
+      .setTitle(`${client.messages.startPlaying}**${song.title}**`)
+      .setDescription(
+        `Song duration: \`${client.funcs.msToTime(
+          queue.songs[0].info.lengthSeconds * 1000,
+          "hh:mm:ss"
+        )}\``
+      )
+      .setColor(client.config.embedColor);
+    queue.textChannel.send(embed);
+  }
+  queue.playing = true;
+};

src/funcs/saveDB.js

@@ -0,0 +1,19 @@
+module.exports = async function (client) {
+  if (client.config.saveDB && !client.config.devMode) {
+    //console.log('DB saved');
+    client.guilds.cache.forEach((guild) => {
+      client.db.collection("guilds").doc(guild.id).set({
+        prefix: client.global.db.guilds[guild.id].prefix,
+        defaultVolume: client.global.db.guilds[guild.id].defaultVolume,
+        permissions: client.global.db.guilds[guild.id].permissions,
+        dj: client.global.db.guilds[guild.id].dj,
+        djrole: client.global.db.guilds[guild.id].djrole,
+        startPlaying: client.global.db.guilds[guild.id].startPlaying,
+        bass: client.global.db.guilds[guild.id].bass,
+        blacklist: client.global.db.guilds[guild.id].blacklist,
+        premium: client.global.db.guilds[guild.id].premium,
+        autoPlay: client.global.db.guilds[guild.id].autoPlay
+      });
+    });
+  }
+};

src/funcs/shuffle.js

@@ -0,0 +1,11 @@
+module.exports = function (a) {
+    for (let i = a.length - 1; i > 1; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        if (i === 0 || j === 0) {
+            // J or I is 0. It works like this so hands off!
+        } else {
+            [a[i], a[j]] = [a[j], a[i]];
+        }
+    }
+    return a;
+};

src/funcs/sleep.js

@@ -0,0 +1,3 @@
+module.exports = function (milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+};

src/funcs/urlMatch.js

@@ -0,0 +1,17 @@
+module.exports = async function (client, msg, youtube, voiceChannel, url) {
+    if (url.match(/^https?:\/\/(www.youtube.com|youtube.com)\/playlist(.*)$/)) {
+        const lmsg = await msg.channel.send(client.messages.loadingSongs);
+        const playlist = await youtube.getPlaylist(url);
+        const videos = await playlist.getVideos();
+        for (const video of Object.values(videos)) {
+            const video2 = await youtube.getVideoByID(video.id);
+            await client.funcs.handleVideo(video2.url, msg, voiceChannel, client, true);
+        }
+        let message;
+        message = client.messages.playlistAdded.replace("%TITLE%", playlist.title);
+        lmsg.edit(message);
+        return true;
+    } else {
+        return false;
+    }
+};