Update readme.md

Test

Migrate from Victoria

Bot/Handler/MusicPlayer/PlayCommand/PlayHandler.cs

@@ -1,12 +1,10 @@
-using Discord;
-using Discord.Commands;
 using Discord.WebSocket;
 using Lunaris2.SlashCommand;
 using MediatR;
-using Victoria.Node;
-using Victoria.Node.EventArgs;
-using Victoria.Player;
-using Victoria.Responses.Search;
+using Lavalink4NET;
+using Lavalink4NET.Events.Players;
+using Lavalink4NET.Players.Queued;
+using Lavalink4NET.Rest.Entities.Tracks;
 
 namespace Lunaris2.Handler.MusicPlayer.PlayCommand;
 
@@ -15,105 +13,84 @@ public record PlayCommand(SocketSlashCommand Message) : IRequest;
 public class PlayHandler : IRequestHandler<PlayCommand>
 {
     private readonly MusicEmbed _musicEmbed;
-    private readonly LavaNode _lavaNode;
     private readonly DiscordSocketClient _client;
+    private readonly IAudioService _audioService;
     private SocketSlashCommand _context;
     
     public PlayHandler(
-        LavaNode lavaNode, 
         DiscordSocketClient client, 
-        MusicEmbed musicEmbed)
+        MusicEmbed musicEmbed, 
+        IAudioService audioService)
     {
-        _lavaNode = lavaNode;
         _client = client;
         _musicEmbed = musicEmbed;
+        _audioService = audioService;
+        _audioService.TrackStarted += OnTrackStarted;
     }
-    
-    [Command(RunMode = RunMode.Async)]
+
+    private async Task OnTrackStarted(object sender, TrackStartedEventArgs eventargs)
+    {
+        var player = sender as QueuedLavalinkPlayer;
+        var track = player?.CurrentTrack;
+
+        if (track != null) 
+            await _musicEmbed.NowPlayingEmbed(track, _context, _client);
+    }
+
     public async Task Handle(PlayCommand command, CancellationToken cancellationToken)
     {
-        _context = command.Message;
+        await _audioService.StartAsync(cancellationToken);
+        var context = command.Message;
+        _context = context;
+        
+        var searchQuery = context.GetOptionValueByName(Option.Input);
 
-        await _lavaNode.EnsureConnected();
-
-        var songName = _context.GetOptionValueByName(Option.Input);
-
-        if (string.IsNullOrWhiteSpace(songName)) {
-            await _context.RespondAsync("Please provide search terms.");
+        if (string.IsNullOrWhiteSpace(searchQuery)) {
+            await context.SendMessageAsync("Please provide search terms.", _client);
             return;
         }
-
-        var player = await GetPlayer();
         
-        if (player == null) 
+        var player = await _audioService.GetPlayerAsync(_client, context, connectToVoiceChannel: true);
+
+        if (player is null)
             return;
 
-        var searchResponse = await _lavaNode.SearchAsync(
-            Uri.IsWellFormedUriString(songName, UriKind.Absolute)
-                ? SearchType.Direct
-                : SearchType.YouTube, songName);
+        var trackLoadOptions = new TrackLoadOptions
+        {
+            SearchMode = TrackSearchMode.YouTube,
+        };
+
+        var track = await _audioService.Tracks
+            .LoadTrackAsync(
+                searchQuery,
+                trackLoadOptions,
+                cancellationToken: cancellationToken);
         
-        if (!await SearchResponse(searchResponse, player, songName)) 
-            return;
+        if (track is null) 
+            await context.SendMessageAsync("😖 No results.", _client);
 
-        await PlayTrack(player);
+        if (player.CurrentTrack is null)
+        {
+            await player
+                .PlayAsync(track, cancellationToken: cancellationToken)
+                .ConfigureAwait(false);
         
-        await _musicEmbed.NowPlayingEmbed(player, _context, _client);
-
-        _lavaNode.OnTrackEnd += OnTrackEnd;
-    }
-
-    private async Task OnTrackEnd(TrackEndEventArg<LavaPlayer<LavaTrack>, LavaTrack> arg)
-    {
-        var player = arg.Player;
-        if (!player.Vueue.TryDequeue(out var nextTrack))
-            return;
-
-        await player.PlayAsync(nextTrack);
+            await _musicEmbed.NowPlayingEmbed(track, context, _client);
+        }
+        else
+        {
+            if (track != null)
+            {
+                var queueTracks = new[] { new TrackQueueItem(track) };
+                await player.Queue.AddRangeAsync(queueTracks, cancellationToken);
+                await context.SendMessageAsync($"🔈 Added to queue: {track.Title}", _client);
+            }
+            else
+            {
+                await context.SendMessageAsync($"Couldn't read song information", _client);
+            }
+        }
         
-        await _musicEmbed.NowPlayingEmbed(player, _context, _client);
-    }
-    
-    private static async Task PlayTrack(LavaPlayer<LavaTrack> player)
-    {
-        if (player.PlayerState is PlayerState.Playing or PlayerState.Paused) {
-            return;
-        }
-
-        player.Vueue.TryDequeue(out var lavaTrack);
-        await player.PlayAsync(lavaTrack);
-    }
-    
-    private async Task<LavaPlayer<LavaTrack>?> GetPlayer()
-    {
-        var voiceState = _context.User as IVoiceState;
-
-        if (voiceState?.VoiceChannel != null)
-            return await _lavaNode.JoinAsync(voiceState.VoiceChannel, _context.Channel as ITextChannel);
-        
-        await _context.RespondAsync("You must be connected to a voice channel!");
-        return null;
-    }
-    
-    private async Task<bool> SearchResponse(
-        SearchResponse searchResponse, LavaPlayer<LavaTrack> player, 
-        string songName)
-    {
-        if (searchResponse.Status is SearchStatus.LoadFailed or SearchStatus.NoMatches) {
-            await _context.RespondAsync($"I wasn't able to find anything for `{songName}`.");
-            return false;
-        }
-
-        if (!string.IsNullOrWhiteSpace(searchResponse.Playlist.Name)) {
-            player.Vueue.Enqueue(searchResponse.Tracks);
-            
-            await _context.RespondAsync($"Enqueued {searchResponse.Tracks.Count} songs.");
-        }
-        else {
-            var track = searchResponse.Tracks.FirstOrDefault()!;
-            player.Vueue.Enqueue(track);
-        }
-
-        return true;
+        _audioService.TrackStarted += OnTrackStarted;
     }
 }