318 lines
8.8 KiB
TypeScript
318 lines
8.8 KiB
TypeScript
import { fullIDMatcher } from '@squeebot/core/lib/common';
|
|
import { logger } from '@squeebot/core/lib/core';
|
|
import {
|
|
Plugin,
|
|
Configurable,
|
|
EventListener,
|
|
DependencyLoad
|
|
} from '@squeebot/core/lib/plugin';
|
|
|
|
import { IMessage, MessageResolver } from '@squeebot/core/lib/types';
|
|
import { Readable } from 'stream';
|
|
|
|
import ytdl from 'ytdl-core';
|
|
import ytsr, { Video } from 'ytsr';
|
|
|
|
import { Client, Message, VoiceChannel, VoiceConnection } from 'discord.js';
|
|
|
|
interface Configuration {
|
|
control: string[];
|
|
voice?: string;
|
|
leaveAfter?: number;
|
|
}
|
|
|
|
interface Cached {
|
|
playing: boolean;
|
|
config: Configuration;
|
|
readable: Readable;
|
|
url: string;
|
|
connection?: VoiceConnection;
|
|
queue: string[];
|
|
}
|
|
|
|
/*
|
|
Discord config example: {
|
|
"control": ["discord/testing/s:<guild id>/*"],
|
|
"voice": "<voice channel id>",
|
|
}
|
|
*/
|
|
|
|
@Configurable({
|
|
youtube: true,
|
|
discord: [],
|
|
icecast: [],
|
|
})
|
|
class JukeboxPlugin extends Plugin {
|
|
public cache: Cached[] = [];
|
|
|
|
@EventListener('pluginUnload')
|
|
public unloadEventHandler(plugin: string | Plugin): void {
|
|
if (plugin === this.name || plugin === this) {
|
|
this.emit('pluginUnloaded', this);
|
|
}
|
|
}
|
|
|
|
getConfigByMessage(msg: IMessage): Configuration | null {
|
|
const rm = msg.fullRoomID;
|
|
if (!rm) {
|
|
return null;
|
|
}
|
|
|
|
for (const cfg of this.config.get('discord', []) as Configuration[]) {
|
|
let roomMatch = false;
|
|
for (const room of cfg.control) {
|
|
if (fullIDMatcher(rm, room)) {
|
|
roomMatch = true;
|
|
}
|
|
}
|
|
if (!roomMatch) {
|
|
continue;
|
|
}
|
|
return cfg;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
getCachedConfig(cfg: Configuration): Cached | null {
|
|
for (const ch of this.cache) {
|
|
if (ch.config === cfg) {
|
|
return ch;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async getStream(link: string): Promise<Readable> {
|
|
if (link.indexOf('http') !== 0) {
|
|
const search = await ytsr(link, { limit: 1 });
|
|
link = (search.items[0] as Video).link;
|
|
}
|
|
return ytdl(link, { quality: 'highestaudio', dlChunkSize: 0 });
|
|
}
|
|
|
|
async playToDiscord(discord: Client, cfg: Configuration, link: string, msg: IMessage): Promise<void> {
|
|
const cached = this.getCachedConfig(cfg);
|
|
if (cached && cached.readable) {
|
|
cached.readable.destroy();
|
|
}
|
|
|
|
let channel;
|
|
if (!cfg.voice) {
|
|
const member = (msg.data as Message).member;
|
|
if (member && member.voice) {
|
|
const avc = member.voice.channel;
|
|
if (avc && avc.joinable) {
|
|
channel = avc;
|
|
}
|
|
}
|
|
} else {
|
|
channel = await discord.channels.fetch(cfg.voice as string);
|
|
}
|
|
|
|
if (!channel || channel.type !== 'voice') {
|
|
throw new Error('Invalid voice channel.');
|
|
}
|
|
|
|
const vc = await (channel as VoiceChannel).join();
|
|
const str = await this.getStream(link);
|
|
vc.play(str).on('finish', () => {
|
|
str.destroy();
|
|
|
|
const cacheCurrent = this.getCachedConfig(cfg);
|
|
if (!cacheCurrent) {
|
|
vc.disconnect();
|
|
return;
|
|
}
|
|
|
|
cacheCurrent.playing = false;
|
|
|
|
if (!cacheCurrent.queue || !cacheCurrent.queue.length) {
|
|
vc.disconnect();
|
|
cacheCurrent.connection = undefined;
|
|
return;
|
|
}
|
|
|
|
const next = cacheCurrent.queue.shift() as string;
|
|
this.playToDiscord(discord, cfg, next, msg).catch((e) => {
|
|
logger.error('[%s] Autoplay threw an error:', this.name, e.stack);
|
|
msg.resolve('Playing of the next track in the queue failed.');
|
|
});
|
|
});
|
|
|
|
if (cached) {
|
|
cached.playing = true;
|
|
cached.readable = str;
|
|
cached.url = link;
|
|
cached.connection = vc;
|
|
} else {
|
|
this.cache.push({
|
|
playing: true,
|
|
readable: str,
|
|
url: link,
|
|
config: cfg,
|
|
connection: vc,
|
|
queue: [],
|
|
});
|
|
}
|
|
}
|
|
|
|
@DependencyLoad('simplecommands')
|
|
addCommands(cmd: any): void {
|
|
const roomsWithJukeboxes = [];
|
|
for (const cfg of this.config.get('discord', []) as Configuration[]) {
|
|
roomsWithJukeboxes.push(...cfg.control);
|
|
}
|
|
cmd.registerCommand([{
|
|
name: 'play',
|
|
plugin: this.name,
|
|
execute: async (msg: IMessage, msr: MessageResolver, spec: any, prefix: string, ...simplified: any[]): Promise<boolean> => {
|
|
if (!simplified[0]) {
|
|
msg.resolve('Please provide an URL or search term to play!');
|
|
return true;
|
|
}
|
|
|
|
const vcConfig = this.getConfigByMessage(msg);
|
|
if (!vcConfig) {
|
|
msg.resolve('This channel has no configuration for jukeboxes.');
|
|
return true;
|
|
}
|
|
|
|
if (msg.source.type !== 'DiscordProtocol') {
|
|
msg.resolve('Currently, only Discord is supported.');
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
await this.playToDiscord((msg.source as any).client, vcConfig, simplified.join(' '), msg);
|
|
} catch (e) {
|
|
msg.resolve('Something went wrong!');
|
|
logger.error('[%s] Threw an error:', this.name, e.stack);
|
|
}
|
|
return true;
|
|
},
|
|
source: roomsWithJukeboxes,
|
|
usage: '<url>',
|
|
description: 'Play something',
|
|
},
|
|
{
|
|
name: 'stop',
|
|
plugin: this.name,
|
|
execute: async (msg: IMessage, msr: MessageResolver, spec: any, prefix: string, ...simplified: any[]): Promise<boolean> => {
|
|
const vcConfig = this.getConfigByMessage(msg);
|
|
if (!vcConfig) {
|
|
msg.resolve('This channel has no configuration for jukeboxes.');
|
|
return true;
|
|
}
|
|
|
|
if (msg.source.type !== 'DiscordProtocol') {
|
|
msg.resolve('Currently, only Discord is supported.');
|
|
return true;
|
|
}
|
|
|
|
const cached = this.getCachedConfig(vcConfig);
|
|
if (cached && cached.playing) {
|
|
cached.playing = false;
|
|
cached.readable.destroy();
|
|
if (cached.connection) {
|
|
try {
|
|
cached.connection.disconnect();
|
|
cached.connection = undefined;
|
|
} catch (e) {}
|
|
}
|
|
msg.resolve('Stopped currently playing.');
|
|
}
|
|
return true;
|
|
},
|
|
source: roomsWithJukeboxes,
|
|
description: 'Stop the currently playing track',
|
|
},
|
|
{
|
|
name: 'enqueue',
|
|
plugin: this.name,
|
|
execute: async (msg: IMessage, msr: MessageResolver, spec: any, prefix: string, ...simplified: any[]): Promise<boolean> => {
|
|
if (!simplified[0]) {
|
|
msg.resolve('Please provide an URL or search term to play!');
|
|
return true;
|
|
}
|
|
|
|
const vcConfig = this.getConfigByMessage(msg);
|
|
if (!vcConfig) {
|
|
msg.resolve('This channel has no configuration for jukeboxes.');
|
|
return true;
|
|
}
|
|
|
|
if (msg.source.type !== 'DiscordProtocol') {
|
|
msg.resolve('Currently, only Discord is supported.');
|
|
return true;
|
|
}
|
|
|
|
const track = simplified.join(' ');
|
|
const cached = this.getCachedConfig(vcConfig);
|
|
if (cached && cached.playing) {
|
|
cached.queue.push(track);
|
|
} else {
|
|
try {
|
|
await this.playToDiscord((msg.source as any).client, vcConfig, track, msg);
|
|
} catch (e) {
|
|
msg.resolve('Something went wrong!');
|
|
logger.error('[%s] Threw an error:', this.name, e.stack);
|
|
}
|
|
}
|
|
return true;
|
|
},
|
|
source: roomsWithJukeboxes,
|
|
usage: '<url>',
|
|
description: 'Queue a track',
|
|
aliases: ['queue'],
|
|
},
|
|
{
|
|
name: 'skip',
|
|
plugin: this.name,
|
|
execute: async (msg: IMessage, msr: MessageResolver, spec: any, prefix: string, ...simplified: any[]): Promise<boolean> => {
|
|
const vcConfig = this.getConfigByMessage(msg);
|
|
if (!vcConfig) {
|
|
msg.resolve('This channel has no configuration for jukeboxes.');
|
|
return true;
|
|
}
|
|
|
|
if (msg.source.type !== 'DiscordProtocol') {
|
|
msg.resolve('Currently, only Discord is supported.');
|
|
return true;
|
|
}
|
|
|
|
const cached = this.getCachedConfig(vcConfig);
|
|
if (cached) {
|
|
if (cached.playing) {
|
|
cached.readable.destroy();
|
|
cached.playing = false;
|
|
if (cached.connection) {
|
|
try {
|
|
cached.connection.disconnect();
|
|
cached.connection = undefined;
|
|
} catch (e) {}
|
|
}
|
|
}
|
|
if (cached.queue.length) {
|
|
const next = cached.queue.shift() as string;
|
|
try {
|
|
await this.playToDiscord((msg.source as any).client, vcConfig, next, msg);
|
|
} catch (e) {
|
|
msg.resolve('Something went wrong!');
|
|
logger.error('[%s] Threw an error:', this.name, e.stack);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
msg.resolve('The queue is empty.');
|
|
return true;
|
|
},
|
|
aliases: ['next'],
|
|
source: roomsWithJukeboxes,
|
|
description: 'Skip the current track',
|
|
}]);
|
|
}
|
|
}
|
|
|
|
module.exports = JukeboxPlugin;
|