MixQueue implemented in MixPlayer.

play_at is now _skip_to

cogs/music.py

@@ -15,6 +15,7 @@ import lavalink
 from discord.ext import commands
 
 from .utils.mixplayer.mixplayer import MixPlayer
+from .utils import checks
 from lavasettings import *
 
 time_rx = re.compile('[0-9]+')
@@ -132,19 +133,17 @@ class Music:
 
         await player.play_now(requester=ctx.author.id, track=track)
 
-    @commands.command(name='playat', aliases=['pa'])
+    @commands.command(name='skipto', aliases=['st'])
     @commands.guild_only()
-    async def _playat(self, ctx, index: int):
+    @checks.is_DJ()
+    async def _skip_to(self, ctx, index: int):
         """ Plays the queue from a specific point. Disregards tracks before the index. """
         player = self.bot.lavalink.players.get(ctx.guild.id)
-
         if index < 1:
             return await ctx.send('Invalid specified index.')
-
         if len(player.queue) < index:
             return await ctx.send('This index exceeds the queue\'s length.')
-
-        await player.play_at(index-1)
+        await player.skip_to(index-1)
 
     @commands.command(name='seek')
     @commands.guild_only()

cogs/utils/mixplayer/mixplayer.py

@@ -10,7 +10,7 @@ from lavalink.Events import QueueEndEvent, TrackExceptionEvent, TrackEndEvent, T
 
 '''
 
-Version of lavalink.py's DefaultPlayer with a custom queue(mixqueue)
+Version of lavalink.py's DefaultPlayer with a custom queue(mixqueue).
 
 '''
 
@@ -30,7 +30,6 @@ class MixPlayer(BasePlayer):
 
         self.queue = MixQueue()
         self.current = None
-        self.previous = None
 
     @property
     def is_playing(self):
@@ -82,25 +81,37 @@ class MixPlayer(BasePlayer):
 
     def add(self, requester: int, track: dict):
         """ Adds a track to the queue. """
-        #self.queue.append(AudioTrack().build(track, requester))
-        self.queue.add_song(requester, AudioTrack().build(track, requester))
+        self.queue.add_track(requester, AudioTrack().build(track, requester))
 
     def add_next(self, requester: int, track: dict):
         """ Adds a track to beginning of the queue """
-        #self.queue.insert(0, AudioTrack().build(track, requester))
-        self.queue.add_next_song(AudioTrack().build(track, requester))
+        self.queue.add_next_track(AudioTrack().build(track, requester))
 
     def add_at(self, index: int, requester: int, track: dict):
         """ Adds a track at a specific index in the queue. """
-        #self.queue.insert(min(index, len(self.queue) - 1), AudioTrack().build(track, requester))
-        self.queue.add_song(requester, AudioTrack().build(track, requester), index)
+        self.queue.add_track(requester, AudioTrack().build(track, requester), index)
+
+    def move_user_track(self, requester: int, initial: int, final: int):
+        """ Moves a track in a users queue"""
+        self.queue.move_user_track(requester, initial, final)
+
+    def remove_user_track(self, requester: int, pos: int):
+        """ Removes the song at <pos> from the queue of requester """
+        self.queue.remove_user_track(requester, pos)
+
+    def remove_global_track(self, pos: int):
+        """ Removes the song at <pos> in the global queue """
+        self.queue.remove_global_track(pos)
+
+    def shuffle_user_queue(self, requester: int):
+        """ Randomly reorders the queue of requester """
+        self.queue.shuffle_user_queue(requester)
 
     async def play(self, track_index: int = 0, ignore_shuffle: bool = False):
         """ Plays the first track in the queue, if any or plays a track from the specified index in the queue. """
         if self.repeat and self.current:
             self.queue.append(self.current)
 
-        self.previous = self.current
         self.current = None
         self.position = 0
         self.paused = False
@@ -109,8 +120,6 @@ class MixPlayer(BasePlayer):
             await self.stop()
             await self._lavalink.dispatch_event(QueueEndEvent(self))
         else:
-#            if self.shuffle and not ignore_shuffle:
-#                track = self.queue.pop(randrange(len(self.queue)))
             track = self.queue.pop_first()
 
             self.current = track
@@ -122,17 +131,11 @@ class MixPlayer(BasePlayer):
         self.add_next(requester, track)
         await self.play(ignore_shuffle=True)
 
-    async def play_at(self, index: int):
+    async def skip_to(self, index: int):
         """ Play the queue from a specific point. Disregards tracks before the index. """
-        self.queue = self.queue[min(index, len(self.queue) - 1):len(self.queue)]
-        await self.play(ignore_shuffle=True)
-
-    async def play_previous(self):
-        """ Plays previous track if it exist, if it doesn't raises a NoPreviousTrack error. """
-        if not self.previous:
-            raise NoPreviousTrack
-        self.queue.insert(0, self.previous)
-        await self.play(ignore_shuffle=True)
+        for i in range(index):
+            _ = self.queue.pop_first()
+        await self.play()
 
     async def stop(self):
         """ Stops the player, if playing. """

cogs/utils/mixplayer/mixqueue.py

@@ -29,6 +29,9 @@ class MixQueue:
             tmp += f'{requester}: {user_queue}\n'
         return tmp
 
+    def __bool__(self):
+        return self.is_empty()
+
     def __iter__(self):
         global_queue = roundrobin(*[x for x in self.queues.values()])
         priority_queue = self.priority_queue 
@@ -51,7 +54,7 @@ class MixQueue:
         self.queues = OrderedDict()
         self.priority_queue = []
 
-    # if pos is true also returns global positions of songs
+    # if pos is true also returns global positions of tracks
     def get_user_queue(self, requester: int, pos: bool=False):
         queue = self.queues.get(requester, [])
         if pos and queue:
@@ -62,17 +65,17 @@ class MixQueue:
 
     def pop_first(self):
         if self.priority_queue:
-            next_song = self.priority_queue.pop(0)
-            return next_song
+            next_track = self.priority_queue.pop(0)
+            return next_track
         try:
-            next_song = self.queues[self.first_queue].pop(0)
+            next_track = self.queues[self.first_queue].pop(0)
             self._shuffle()
             self._clear_empty()
-            return next_song
+            return next_track
         except KeyError:
             pass
 
-    def add_song(self, requester: int, track: AudioTrack, pos: int=None):
+    def add_track(self, requester: int, track: AudioTrack, pos: int=None):
         user_queue = self.queues.get(requester)
         if user_queue is None:
             self.queues[requester] = [track]
@@ -81,17 +84,17 @@ class MixQueue:
         else:
             user_queue.insert(pos, track)
 
-    def add_next_song(self, track: AudioTrack):
+    def add_next_track(self, track: AudioTrack):
         self.priority_queue.append(track)
 
-    def remove_song_from(self, requester: int, pos: int):
+    def remove_user_track(self, requester: int, pos: int):
         user_queue = self.queues.get(requester)
         if user_queue is not None:
             if pos < len(user_queue):
                 user_queue.pop(pos)
                 self._clear_empty()
 
-    def remove_song_at(self, pos: int):
+    def remove_global_track(self, pos: int):
         q, pos = self._glob_to_loc(pos)
         if q is None or pos is None:
             return
@@ -99,11 +102,12 @@ class MixQueue:
         queue.pop(pos)
         self._clear_empty()
 
-    def switch_user_songs(self, requester: int, first: int, second: int):
+    def move_user_track(self, requester: int, initial: int, final: int):
         queue = self.queues.get(requester, [])
         if queue:
             try:
-                queue[first], queue[second] = queue[second], queue[first]
+                track = queue.pop(initial)
+                queue.insert(final, track)
             except IndexError:
                 pass
 
@@ -127,23 +131,23 @@ class MixQueue:
         queue = self.queues.get(requester, [])
         if queue:
             try:
-                song = queue[pos]
-                for i, s in enumerate(self):
-                    if s == song:
+                track = queue[pos]
+                for i, t in enumerate(self):
+                    if t == track:
                         return i
             except IndexError:
                 pass
 
     def _glob_to_loc(self, pos: int):
-        song = None
-        for i, s in enumerate(self):
+        track = None
+        for i, t in enumerate(self):
             if i == pos:
-                song = s
-        if song is None:
+                track = t
+        if track is None:
             return None, None
         for requester, q in self.queues.items():
-            for i, s in enumerate(q):
-                if s == song:
+            for i, t in enumerate(q):
+                if t == track:
                     return requester, i
 
     @property