mrmBot-Matrix/utils/soundplayer.js

import * as logger from "./logger.js";
import fetch from "node-fetch";
import fs from "fs";
import format from "format-duration";
import { Manager, Rest } from "lavacord";

let nodes;

export const players = new Map();
export const queues = new Map();
export const skipVotes = new Map();

export let manager;
export let status = false;
export let connected = false;

export async function checkStatus() {
  const json = await fs.promises.readFile("./servers.json", { encoding: "utf8" });
  nodes = JSON.parse(json).lava;
  const newNodes = [];
  for (const node of nodes) {
    try {
      const response = await fetch(`http://${node.host}:${node.port}/version`, { headers: { Authorization: node.password } }).then(res => res.text());
      if (response) newNodes.push(node);
    } catch {
      logger.error(`Failed to get status of Lavalink node ${node.host}.`);
    }
  }
  nodes = newNodes;
  status = newNodes.length === 0 ? true : false;
  return status;
}

export async function connect(client) {
  manager = new Manager(nodes, {
    user: client.user.id,
    shards: client.shards.size || 1,
    send: (packet) => {
      const guild = client.guilds.get(packet.d.guild_id);
      if (!guild) return;
      return guild.shard.sendWS(packet.op, packet.d);
    }
  });
  const { length } = await manager.connect();
  logger.log(`Successfully connected to ${length} Lavalink node(s).`);
  connected = true;
  manager.on("error", (error, node) => {
    logger.error(`An error occurred on Lavalink node ${node}: ${error}`);
  });
  return length;
}

export async function play(client, sound, message, music = false) {
  if (!manager) return "The sound commands are still starting up!";
  if (!message.channel.guild) return "This command only works in servers!";
  if (!message.member.voiceState.channelID) return "You need to be in a voice channel first!";
  if (!message.channel.guild.permissionsOf(client.user.id).has("voiceConnect")) return "I can't join this voice channel!";
  const voiceChannel = message.channel.guild.channels.get(message.member.voiceState.channelID);
  if (!voiceChannel.permissionsOf(client.user.id).has("voiceConnect")) return "I don't have permission to join this voice channel!";
  const player = players.get(message.channel.guild.id);
  if (!music && manager.voiceStates.has(message.channel.guild.id) && (player && player.type === "music")) return "I can't play a sound effect while playing music!";
  const node = manager.idealNodes[0];
  if (!music && !nodes.filter(obj => obj.host === node.host)[0].local) {
    sound = sound.replace(/\.\//, "https://raw.githubusercontent.com/esmBot/esmBot/master/");
  }
  const { tracks, playlistInfo } = await Rest.load(node, sound);
  const oldQueue = queues.get(voiceChannel.guild.id);
  if (!tracks || tracks.length === 0) return "I couldn't find that song!";
  if (music) {
    const sortedTracks = tracks.map((val) => { return val.track; });
    const playlistTracks = playlistInfo.selectedTrack !== undefined ? sortedTracks : [sortedTracks[0]];
    queues.set(voiceChannel.guild.id, oldQueue ? [...oldQueue, ...playlistTracks] : playlistTracks);
  }
  const connection = await manager.join({
    guild: voiceChannel.guild.id,
    channel: voiceChannel.id,
    node: node.id
  });

  if (oldQueue && music) {
    return `Your ${playlistInfo.name ? "playlist" : "tune"} \`${playlistInfo.name ? playlistInfo.name : tracks[0].info.title}\` has been added to the queue!`;
  } else {
    nextSong(client, message, connection, tracks[0].track, tracks[0].info, music, voiceChannel, player ? player.loop : false);
    return;
  }
}

export async function nextSong(client, message, connection, track, info, music, voiceChannel, loop = false, lastTrack = null) {
  skipVotes.delete(voiceChannel.guild.id);
  const parts = Math.floor((0 / info.length) * 10);
  let playingMessage;
  if (!music && players.get(voiceChannel.guild.id)) {
    const playMessage = players.get(voiceChannel.guild.id).playMessage;
    try {
      players.delete(voiceChannel.guild.id);
      playMessage.delete();
    } catch {
      // no-op
    }
  }
  if (music && lastTrack === track && players.get(voiceChannel.guild.id)) {
    playingMessage = players.get(voiceChannel.guild.id).playMessage;
  } else {
    playingMessage = await client.createMessage(message.channel.id, !music ? "🔊 Playing sound..." : {
      "embed": {
        "color": 16711680,
        "author": {
          "name": "Now Playing",
          "icon_url": client.user.avatarURL
        },
        "fields": [{
          "name": "ℹ️ Title:",
          "value": info.title !== "" ? info.title : "(blank)"
        },
        {
          "name": "🎤 Artist:",
          "value": info.author !== "" ? info.author : "(blank)"
        },
        {
          "name": "💬 Channel:",
          "value": voiceChannel.name
        },
        {
          "name": `${"▬".repeat(parts)}🔘${"▬".repeat(10 - parts)}`,
          "value": `0:00/${info.isStream ? "∞" : format(info.length)}`
        }]
      }
    });
  }
  connection.removeAllListeners("error");
  connection.removeAllListeners("end");
  await connection.play(track);
  await connection.volume(75);
  players.set(voiceChannel.guild.id, { player: connection, type: music ? "music" : "sound", host: message.author.id, voiceChannel: voiceChannel, originalChannel: message.channel, loop: loop, playMessage: playingMessage });
  connection.once("error", (error) => {
    if (playingMessage.channel.messages.get(playingMessage.id)) playingMessage.delete();
    const playMessage = players.get(voiceChannel.guild.id).playMessage;
    if (playMessage.channel.messages.get(playMessage.id)) playMessage.delete();
    manager.leave(voiceChannel.guild.id);
    connection.removeAllListeners("end");
    connection.destroy();
    players.delete(voiceChannel.guild.id);
    queues.delete(voiceChannel.guild.id);
    logger.error(error);
  });
  connection.on("end", async (data) => {
    if (data.reason === "REPLACED") return;
    const queue = queues.get(voiceChannel.guild.id);
    const player = players.get(voiceChannel.guild.id);
    let newQueue;
    if (player && player.loop) {
      queue.push(queue.shift());
      newQueue = queue;
    } else {
      newQueue = queue ? queue.slice(1) : [];
    }
    queues.set(voiceChannel.guild.id, newQueue);
    if (newQueue.length === 0) {
      manager.leave(voiceChannel.guild.id);
      connection.destroy();
      players.delete(voiceChannel.guild.id);
      queues.delete(voiceChannel.guild.id);
      skipVotes.delete(voiceChannel.guild.id);
      if (music) await client.createMessage(message.channel.id, "🔊 The current voice channel session has ended.");
      try {
        if (playingMessage.channel.messages.get(playingMessage.id)) await playingMessage.delete();
        if (player && player.playMessage.channel.messages.get(player.playMessage.id)) await player.playMessage.delete();
      } catch {
        // no-op
      }
    } else {
      const newTrack = await Rest.decode(connection.node, newQueue[0]);
      nextSong(client, message, connection, newQueue[0], newTrack, music, voiceChannel, player.loop, track);
      try {
        if (newQueue[0] !== track && playingMessage.channel.messages.get(playingMessage.id)) await playingMessage.delete();
        if (newQueue[0] !== track && player.playMessage.channel.messages.get(player.playMessage.id)) await player.playMessage.delete();
      } catch {
        // no-op
      }
    }
  });
}