Go Packers

src/bot.ts

@@ -5,18 +5,21 @@ import {Settings, Shortcut} from './models';
 import container from './inversify.config';
 import Command from './commands';
 import debug from './utils/debug';
+import NaturalLanguage from './services/natural-language-commands';
 import handleGuildCreate from './events/guild-create';
 import handleVoiceStateUpdate from './events/voice-state-update';
 
 @injectable()
 export default class {
   private readonly client: Client;
+  private readonly naturalLanguage: NaturalLanguage;
   private readonly token: string;
   private readonly clientId: string;
   private readonly commands!: Collection<string, Command>;
 
-  constructor(@inject(TYPES.Client) client: Client, @inject(TYPES.Config.DISCORD_TOKEN) token: string, @inject(TYPES.Config.DISCORD_CLIENT_ID) clientId: string) {
+  constructor(@inject(TYPES.Client) client: Client, @inject(TYPES.Services.NaturalLanguage) naturalLanguage: NaturalLanguage, @inject(TYPES.Config.DISCORD_TOKEN) token: string, @inject(TYPES.Config.DISCORD_CLIENT_ID) clientId: string) {
     this.client = client;
+    this.naturalLanguage = naturalLanguage;
     this.token = token;
     this.clientId = clientId;
     this.commands = new Collection();
@@ -41,10 +44,8 @@ export default class {
         return this.client.emit('guildCreate', msg.guild);
       }
 
-      if (msg.content.startsWith('say') && msg.content.endsWith('muse')) {
+      if (await this.naturalLanguage.execute(msg)) {
-        const res = msg.content.slice(3, msg.content.indexOf('muse')).trim();
+        // Natural language command handled message
-
-        await msg.channel.send(res);
         return;
       }
 

src/inversify.config.ts

@@ -21,6 +21,7 @@ import QueueManager from './managers/queue';
 
 // Helpers
 import GetSongs from './services/get-songs';
+import NaturalLanguage from './services/natural-language-commands';
 
 // Comands
 import Command from './commands';
@@ -49,6 +50,7 @@ container.bind<QueueManager>(TYPES.Managers.Queue).to(QueueManager).inSingletonS
 
 // Helpers
 container.bind<GetSongs>(TYPES.Services.GetSongs).to(GetSongs).inSingletonScope();
+container.bind<NaturalLanguage>(TYPES.Services.NaturalLanguage).to(NaturalLanguage).inSingletonScope();
 
 // Commands
 container.bind<Command>(TYPES.Command).to(Clear).inSingletonScope();

src/services/natural-language-commands.ts

@@ -0,0 +1,76 @@
+import {inject, injectable} from 'inversify';
+import {Message} from 'discord.js';
+import {TYPES} from '../types';
+import PlayerManager from '../managers/player';
+import QueueManager from '../managers/queue';
+import {getMostPopularVoiceChannel} from '../utils/channels';
+
+@injectable()
+export default class {
+  private readonly playerManager: PlayerManager;
+  private readonly queueManager: QueueManager;
+
+  constructor(@inject(TYPES.Managers.Player) playerManager: PlayerManager, @inject(TYPES.Managers.Queue) queueManager: QueueManager) {
+    this.playerManager = playerManager;
+    this.queueManager = queueManager;
+  }
+
+  async execute(msg: Message): Promise<boolean> {
+    if (msg.content.startsWith('say') && msg.content.endsWith('muse')) {
+      const res = msg.content.slice(3, msg.content.indexOf('muse')).trim();
+
+      await msg.channel.send(res);
+      return true;
+    }
+
+    if (msg.content.includes('packers')) {
+      const queue = this.queueManager.get(msg.guild!.id);
+      const player = this.playerManager.get(msg.guild!.id);
+
+      const [channel, n] = getMostPopularVoiceChannel(msg.guild!);
+
+      await msg.channel.send('GO PACKERS GO!!!');
+
+      if (!player.voiceConnection && n === 0) {
+        return false;
+      }
+
+      if (!player.voiceConnection) {
+        await player.connect(channel);
+      }
+
+      const isPlaying = queue.getCurrent();
+      let oldPosition = 0;
+
+      queue.add({title: 'GO PACKERS!', artist: 'Unknown', url: 'https://www.youtube.com/watch?v=qkdtID7mY3E', length: 204, playlist: null, isLive: false});
+
+      if (isPlaying) {
+        oldPosition = player.getPosition();
+        queue.forward();
+      }
+
+      await player.seek(8);
+
+      return new Promise((resolve, reject) => {
+        try {
+          setTimeout(async () => {
+            if (isPlaying) {
+              queue.back();
+
+              await player.seek(oldPosition);
+            } else {
+              queue.forward();
+              player.disconnect();
+            }
+
+            resolve(true);
+          }, 10000);
+        } catch (error) {
+          reject(error);
+        }
+      });
+    }
+
+    return false;
+  }
+}

src/services/player.ts

@@ -68,12 +68,8 @@ export default class {
       throw new Error('Seek position is outside the range of the song.');
     }
 
-    if (await this.isCached(currentSong.url)) {
+    const stream = await this.getStream(currentSong.url, {seek: positionSeconds});
-      this.dispatcher = this.voiceConnection.play(this.getCachedPath(currentSong.url), {seek: positionSeconds});
+    this.dispatcher = this.voiceConnection.play(stream, {type: 'webm/opus'});
-    } else {
-      const stream = await this.getStream(currentSong.url, {seek: positionSeconds});
-      this.dispatcher = this.voiceConnection.play(stream, {type: 'webm/opus'});
-    }
 
     this.attachListeners();
     this.startTrackingPosition(positionSeconds);
@@ -107,12 +103,8 @@ export default class {
       return;
     }
 
-    if (await this.isCached(currentSong.url)) {
+    const stream = await this.getStream(currentSong.url);
-      this.dispatcher = this.voiceConnection.play(this.getCachedPath(currentSong.url));
+    this.dispatcher = this.voiceConnection.play(stream, {type: 'webm/opus'});
-    } else {
-      const stream = await this.getStream(currentSong.url);
-      this.dispatcher = this.voiceConnection.play(stream, {type: 'webm/opus'});
-    }
 
     this.attachListeners();
 
@@ -154,67 +146,77 @@ export default class {
     }
   }
 
-  private async getStream(url: string, options: {seek?: number} = {}): Promise<Readable|string> {
+  private async getStream(url: string, options: {seek?: number} = {}): Promise<Readable> {
     const cachedPath = this.getCachedPath(url);
 
+    let ffmpegInput = '';
+    const ffmpegInputOptions = [];
+    let shouldCacheVideo = false;
+
     if (await this.isCached(url)) {
-      return cachedPath;
+      ffmpegInput = cachedPath;
-    }
+    } else {
+      // Not yet cached, must download
+      const info = await ytdl.getInfo(url);
 
-    // Not yet cached, must download
+      const {formats} = info;
-    const info = await ytdl.getInfo(url);
 
-    const {formats} = info;
+      const filter = (format: ytdl.videoFormat): boolean => format.codecs === 'opus' && format.container === 'webm' && format.audioSampleRate !== undefined && parseInt(format.audioSampleRate, 10) === 48000;
 
-    const filter = (format: ytdl.videoFormat): boolean => format.codecs === 'opus' && format.container === 'webm' && format.audioSampleRate !== undefined && parseInt(format.audioSampleRate, 10) === 48000;
+      let format = formats.find(filter);
 
-    let format = formats.find(filter);
+      const nextBestFormat = (formats: ytdl.videoFormat[]): ytdl.videoFormat | undefined => {
+        if (formats[0].live) {
+          formats = formats.sort((a, b) => (b as any).audioBitrate - (a as any).audioBitrate); // Bad typings
 
-    const nextBestFormat = (formats: ytdl.videoFormat[]): ytdl.videoFormat | undefined => {
+          return formats.find(format => [128, 127, 120, 96, 95, 94, 93].includes(parseInt(format.itag as unknown as string, 10))); // Bad typings
-      if (formats[0].live) {
+        }
-        formats = formats.sort((a, b) => (b as any).audioBitrate - (a as any).audioBitrate); // Bad typings
 
-        return formats.find(format => [128, 127, 120, 96, 95, 94, 93].includes(parseInt(format.itag as unknown as string, 10))); // Bad typings
+        formats = formats
-      }
+          .filter(format => format.averageBitrate)
-
+          .sort((a, b) => b.averageBitrate - a.averageBitrate);
-      formats = formats
+        return formats.find(format => !format.bitrate) ?? formats[0];
-        .filter(format => format.averageBitrate)
+      };
-        .sort((a, b) => b.averageBitrate - a.averageBitrate);
-      return formats.find(format => !format.bitrate) ?? formats[0];
-    };
-
-    if (!format) {
-      format = nextBestFormat(info.formats);
 
       if (!format) {
-        // If still no format is found, throw
+        format = nextBestFormat(info.formats);
-        throw new Error('Can\'t find suitable format.');
+
+        if (!format) {
+          // If still no format is found, throw
+          throw new Error('Can\'t find suitable format.');
+        }
       }
+
+      ffmpegInput = format.url;
+
+      // Don't cache livestreams or long videos
+      const MAX_CACHE_LENGTH_SECONDS = 30 * 60; // 30 minutes
+      shouldCacheVideo = !info.player_response.videoDetails.isLiveContent && parseInt(info.length_seconds, 10) < MAX_CACHE_LENGTH_SECONDS;
+
+      ffmpegInputOptions.push(...[
+        '-reconnect',
+        '1',
+        '-reconnect_streamed',
+        '1',
+        '-reconnect_delay_max',
+        '5'
+      ]);
     }
 
-    const inputOptions = [
+    // Add seek parameter if necessary
-      '-reconnect',
-      '1',
-      '-reconnect_streamed',
-      '1',
-      '-reconnect_delay_max',
-      '5'
-    ];
-
     if (options.seek) {
-      inputOptions.push('-ss', options.seek.toString());
+      ffmpegInputOptions.push('-ss', options.seek.toString());
     }
 
-    const youtubeStream = ffmpeg(format.url).inputOptions(inputOptions).noVideo().audioCodec('libopus').outputFormat('webm').pipe() as PassThrough;
+    // Create stream and pipe to capacitor
+    const youtubeStream = ffmpeg(ffmpegInput).inputOptions(ffmpegInputOptions).noVideo().audioCodec('libopus').outputFormat('webm').pipe() as PassThrough;
 
     const capacitor = new WriteStream();
 
     youtubeStream.pipe(capacitor);
 
-    // Don't cache livestreams or long videos
+    // Cache video if necessary
-    const MAX_CACHE_LENGTH_SECONDS = 30 * 60; // 30 minutes
+    if (shouldCacheVideo) {
-
-    if (!info.player_response.videoDetails.isLiveContent && parseInt(info.length_seconds, 10) < MAX_CACHE_LENGTH_SECONDS) {
       const cacheTempPath = this.getCachedPathTemp(url);
       const cacheStream = createWriteStream(cacheTempPath);
 

src/types.ts

@@ -18,6 +18,7 @@ export const TYPES = {
     Queue: Symbol('QueueManager')
   },
   Services: {
-    GetSongs: Symbol('GetSongs')
+    GetSongs: Symbol('GetSongs'),
+    NaturalLanguage: Symbol('NaturalLanguage')
   }
 };