private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
if (!player.Queue.TryDequeue(out var queueable))
{
await player.TextChannel.SendMessageAsync("Queue finished.");
_ = InitiateDisconnectAsync(args.Player, TimeSpan.FromSeconds(10));
return;
}
if (!(queueable is LavaTrack track))
{
await player.TextChannel.SendMessageAsync("That's not a song.");
return;
}
await args.Player.PlayAsync(track);
await args.Player.TextChannel.SendMessageAsync($"{args.Reason}: {args.Track.Title}\nPlaying: {track.Title}");
}
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
if (!player.Queue.TryDequeue(out var queueable))
{
await(player.TextChannel as ISocketMessageChannel).SendSuccessAsync("Music", "Queue completed! Please add more tracks to rock n' roll!");
return;
}
if (!(queueable is LavaTrack track))
{
await(player.TextChannel as ISocketMessageChannel).SendErrorAsync("Music", "Next item in queue is not a track.");
return;
}
await args.Player.PlayAsync(track);
await(player.TextChannel as ISocketMessageChannel).SendSuccessAsync($"{args.Reason}: {args.Track.Title}", $"Now playing: {track.Title}");
}
private async Task TrackEndedAsync(TrackEndedEventArgs trackEndArgs)
{
if (!trackEndArgs.Reason.ShouldPlayNext())
{
return;
}
if (!trackEndArgs.Player.Queue.TryDequeue(out var track))
{
await trackEndArgs.Player.TextChannel.SendMessageAsync("Playback Finised");
return;
}
var embed = new EmbedBuilder()
.WithColor(Color.Green)
.WithTitle("Music Service, Now Playing")
.WithDescription(
$"Title: {track.Title}\n" +
$"Author: {track.Author}\n" +
$"Duration: {track.Duration.ToString("h'h 'm'm 's's'")}\n\n" +
$"Url: [Youtube]({track.Url})")
.WithThumbnailUrl($"https://img.youtube.com/vi/{track.Id}/maxresdefault.jpg");
await trackEndArgs.Player.PlayAsync(track);
await trackEndArgs.Player.TextChannel.SendMessageAsync(embed : embed.Build());
}
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
if (!player.Queue.TryDequeue(out var queueable))
{
await(player.TextChannel as ISocketMessageChannel).SendSuccessAsync("Queue completed!", "Please add more tracks to rock n' roll!");
await _client.SetGameAsync("use //help to see my commands", null, ActivityType.Playing);
return;
}
if (!(queueable is LavaTrack track))
{
await(player.TextChannel as ISocketMessageChannel).SendErrorAsync("Error!", "Next item in queue is not a track!");
return;
}
await args.Player.PlayAsync(track);
await(args.Player.TextChannel as ISocketMessageChannel).SendSuccessAsync("Finished playing current song!",
$"{args.Reason}: `{args.Track.Title}`\n\nNow playing: `{track.Title}`");
await _client.SetGameAsync($"{args.Track.Title}", null, ActivityType.Listening);
}
public async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
if (!player.Queue.TryDequeue(out var queueable))
{
return;
}
if (!(queueable is LavaTrack track))
{
return;
}
await args.Player.PlayAsync(track);
var embed = new EmbedBuilder {
Description = track.Title, Title = "Now playing"
};
embed.WithColor(Color.Blue);
await args.Player.TextChannel.SendMessageAsync(embed : embed.Build());
}
private async Task TrackFinished(TrackEndedEventArgs args)
{
await _logger.WriteLog("TrackFinished triggered");
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
if (!player.Queue.TryDequeue(out var queueable))
{
await player.TextChannel.SendMessageAsync("Kolejka jest już pusta");
return;
}
if (!(queueable is LavaTrack track))
{
await player.TextChannel.SendMessageAsync("Z kolejką jest coś nie tak");
return;
}
await args.Player.PlayAsync(track);
await player.TextChannel.SendMessageAsync($"Teraz odtwarzane: {track.Title.SongTitleTrim()} ({track.Duration.SongDurationToString()})");
}
private async Task TrackFinished(TrackEndedEventArgs endedEventArgs)
{
if (!endedEventArgs.Reason.ShouldPlayNext())
{
return;
}
LavaPlayer player = endedEventArgs.Player;
if (!player.Queue.TryDequeue(out var queueable))
{
await player.TextChannel.SendMessageAsync("", false, warnembed.EndQueue());
await _lavaNode.LeaveAsync(player.VoiceChannel);
await player.TextChannel.SendMessageAsync("", false, warnembed.LeavingRoom(player.VoiceChannel.Name, player.VoiceChannel.CreateInviteAsync().Result.Url));
var item = AdminUsers.First(kvp => kvp.Value == player.VoiceChannel.GuildId);
AdminUsers.Remove(item.Key);
return;
}
if (!(queueable is LavaTrack track))
{
await player.TextChannel.SendMessageAsync("Next item in queue is not a track.");
return;
}
await player.PlayAsync(track);
await player.TextChannel.SendMessageAsync("", false, warnembed.NowPlaying(player.Track.Title));
}
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
if (!player.Queue.TryDequeue(out var queueable))
{
await player.TextChannel.SendMessageAsync("No more tracks to play.");
return;
}
if (!(queueable is LavaTrack track))
{
await player.TextChannel.SendMessageAsync("Next item in queue is not a track.");
return;
}
VoteQueue.Clear();
await args.Player.PlayAsync(track);
await args.Player.TextChannel.SendMessageAsync(
$"{args.Reason}: {args.Track.Title}\nNow playing: {track.Title}");
}
public async Task TrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
if (!args.Player.Queue.TryDequeue(out var queueable))
{
//await args.Player.TextChannel.SendMessageAsync("Playback Finished.");
return;
}
if (!(queueable is LavaTrack track))
{
await args.Player.TextChannel.SendMessageAsync("Next item in queue is not a track.");
return;
}
await args.Player.PlayAsync(track);
await args.Player.TextChannel.SendMessageAsync(
embed : await EmbedHandler.CreateSongPlayEmbed(track));
}
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (args.Reason != TrackEndReason.Finished)
{
return;
}
var player = args.Player;
if (!player.Queue.TryDequeue(out var lavaTrack))
{
await player.TextChannel.SendMessageAsync("Queue completed! Please add more tracks to rock n' roll!");
_ = InitiateDisconnectAsync(args.Player, TimeSpan.FromSeconds(120));
return;
}
if (lavaTrack is null)
{
await player.TextChannel.SendMessageAsync("Next item in queue is not a track.");
return;
}
await args.Player.PlayAsync(lavaTrack);
}
public static async Task OnTrackEnded(TrackEndedEventArgs args)
{
var player = args.Player;
if (player.TextChannel.Guild.Id.GetQueueCount() > 0 && args.Reason == TrackEndReason.Finished)
{
var final = await player.TextChannel.SendMessageAsync("🧐 Playing the next song");
var track = player.TextChannel.Guild.Id.PopTrack();
var playing = new EmbedBuilder
{
Title = "Now Playing",
Description = track.Title,
Color = new Color(213, 0, 249)
}.Build();
await player.PlayAsync(track);
await final.ModifyAsync(x =>
{
x.Embed = playing;
x.Content = null;
});
return;
}
if (args.Reason != TrackEndReason.Replaced)
{
await InitiateDisconnectAsync(args.Player, TimeSpan.FromMinutes(2));
}
}
private async Task OnTrackEnded(TrackEndedEventArgs e)
{
if (!e.Reason.ShouldPlayNext() || e.Player == null)
{
return;
}
if (!e.Player.Queue.TryDequeue(out var track))
{
await e.Player.TextChannel.SendMessageAsync(embed : this.GetSimpleMusicEmbed("No more tracks in queue.").Build());
return;
}
if (track == null)
{
await e.Player.TextChannel.SendMessageAsync(
embed : this.GetSimpleMusicEmbed("Next item in queue was not a track. Stopped playback..").Build());
return;
}
// Queue next song
await e.Player.PlayAsync(track);
var eb = await this.GetExtendedMusicEmbed(track);
var msg = await e.Player.TextChannel.SendMessageAsync(embed : eb.Build());
// Remove old and set new msg
await this.RemoveOldAndSetNewMessage(msg, e.Player);
}
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
if (_pulledTrack != null)
{
await player.PlayAsync(_pulledTrack);
_pulledTrack = null;
return;
}
if (!player.Queue.TryDequeue(out var queueable))
{
return;
}
if (!(queueable is LavaTrack track))
{
await player.TextChannel.SendMessageAsync("Something wrong with the next track");
return;
}
await player.PlayAsync(track);
}
// ---------------------------- Victoria Event Handlers ----------------------------
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
if (!player.Queue.TryDequeue(out var queueable))
{
await player.TextChannel.SendMessageAsync("Queue completed! Please add more tracks to rock n' roll!");
_ = InitiateDisconnectAsync(args.Player, TimeSpan.FromSeconds(10));
return;
}
if (!(queueable is { } track))
{
await player.TextChannel.SendMessageAsync("Next item in the queue is not a track.");
return;
}
await args.Player.PlayAsync(track);
await args.Player.TextChannel.SendMessageAsync($"{args.Reason}: {args.Track.Title}\nNow playing: {track.Title}");
}
private async Task TrackFinish(TrackEndedEventArgs arg)
{
var player = arg.Player;
var endReason = arg.Reason;
var ptrack = arg.Track;
var guild = GetOrAddConfig(player.VoiceChannel.GuildId);
if (guild.Repeat) // If the guild enabled repeating, do this
{
if (guild.IsPlayed) // If the previous playing track was replaced, do this
{
if (endReason != TrackEndReason.Replaced) // If the track wasn't replaced, do this
{
guild.IsPlayed = false;
var track = guild.Queue.Dequeue();
await player.TextChannel.SendMessageAsync("", false, await EmbedMethods.GetEmbedQueue(track, guild.Queue, ptrack));
await player.PlayAsync(track);
}
else // If it wasn't replaced, don't do anything because it doesn't need to be added at the end of the queue.
{
return;
}
}
else
{
if (endReason == TrackEndReason.Replaced) // If the track was replaced, declare that it was replaced
{
guild.IsPlayed = true;
guild.Queue.Enqueue(new TrackInput(ptrack, guild.CurrentUserPlaying));
}
else
{
guild.Queue.Enqueue(new TrackInput(ptrack, guild.CurrentUserPlaying));
var track = guild.Queue.Dequeue();
await player.TextChannel.SendMessageAsync("", false, await EmbedMethods.GetEmbedQueue(track, guild.Queue, ptrack));
await player.PlayAsync(track);
}
}
}
else // If the guild didn't enable repeating do this
{
if (endReason != TrackEndReason.Replaced)
{
if (guild.Queue.Count > 0)
{
var track = guild.Queue.Dequeue();
guild.DecrementUser(guild.CurrentUserPlaying);
await player.TextChannel.SendMessageAsync("", false, await EmbedMethods.GetEmbedQueue(track, guild.Queue, ptrack));
guild.CurrentUserPlaying = track.UserInputter;
await player.PlayAsync(track);
}
}
}
}
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
MusicTrackQueues.Single(x => x.GuildId == args.Player.VoiceChannel.GuildId).QueuedItems
.RemoveAll(x => x.Track.Id == args.Track.Id);
if (!player.Queue.TryDequeue(out var queueable))
{
await player.TextChannel.SendMessageAsync("", false, EmbedHandler.GenerateEmbedResponse("No more tracks to play."));
return;
}
if (!(queueable is LavaTrack track))
{
await player.TextChannel.SendMessageAsync("", false, EmbedHandler.GenerateEmbedResponse("Next item in queue is not a track."));
return;
}
await args.Player.PlayAsync(track);
var artwork = await track.FetchArtworkAsync();
var requestingUser = MusicTrackQueues.Single(x => x.GuildId == args.Player.VoiceChannel.GuildId).QueuedItems.First().RequestingUser;
var embed = new EmbedBuilder
{
Title = track.Title,
Description = track.Author,
ThumbnailUrl = artwork,
Url = track.Url,
Author = new EmbedAuthorBuilder
{
Name = "Next Up!"
},
Footer = new EmbedFooterBuilder
{
Text =
$"This track was requested by {requestingUser.Username}#{requestingUser.Discriminator}",
IconUrl = requestingUser.GetAvatarUrl()
},
Color = Color.Green
}
.AddField("Duration", $@"{track.Duration:mm\:ss}");
//await args.Player.TextChannel.SendMessageAsync("", false, EmbedHandler.GenerateEmbedResponse($"{args.Reason}: {args.Track.Title}\nNow playing: {track.Title}"));
await args.Player.TextChannel.SendMessageAsync("", false, embed.Build());
}
private async Task OnTrackEndedAsync(TrackEndedEventArgs args)
{
if (args.Reason != Victoria.Enums.TrackEndReason.Finished)
{
return;
}
// No users are in the channel, stop playing and leave.
if ((args.Player.VoiceChannel as SocketVoiceChannel).Users.Count == 0)
{
await LeaveChannel(args.Player.VoiceChannel.Guild, args.Player.VoiceChannel);
return;
}
// Check if we should loop the track that ended.
DJGuildInfo guild = null;
if (guildInfo.TryGetValue(args.Player.VoiceChannel.Guild, out guild))
{
if (guild.loopSong == true)
{
await args.Player.PlayAsync(args.Track);
await args.Player.TextChannel.SendMessageAsync($"**Looping** 🎶 `{args.Track.Title}`");
return;
}
}
// Couldn't find the guild, leave channel.
if (guild == null)
{
await LeaveChannel(args.Player.VoiceChannel.Guild, args.Player.VoiceChannel);
return;
}
guild.OnNextTrack();
// There was no next track, leave channel.
if (guild.currentlyPlaying == null)
{
await LeaveChannel(args.Player.VoiceChannel.Guild, args.Player.VoiceChannel);
return;
}
LavaTrack track = guild.currentlyPlaying.track as LavaTrack;
await args.Player.PlayAsync(track);
await args.Player.TextChannel.SendMessageAsync($"**Playing** 🎶`{track.Title}`");
}
public async Task TrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext() ||
!args.Player.Queue.TryDequeue(out var track))
{
return;
}
await args.Player.PlayAsync(track);
await args.Player.TextChannel.SendMessageAsync($"Now playing `{track.Title}`");
}
private async Task OnTrackEndedAsync(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var builder = new EmbedBuilder();
ulong guildId = args.Player.TextChannel.GuildId;
if (_loopDict.ContainsKey(guildId))
{
if (_loopDict[guildId] == 0)
{
_loopDict.TryRemove(guildId, out _);
var builder2 = new EmbedBuilder()
.WithDescription(string.Format(GuildUtils.Locate("LoopEnded", args.Player.TextChannel), args.Track.ToTrackLink(false)))
.WithColor(FergunClient.Config.EmbedColor);
await args.Player.TextChannel.SendMessageAsync(null, false, builder2.Build());
await _logService.LogAsync(new LogMessage(LogSeverity.Info, "Victoria", $"Loop for track {args.Track.Title} ({args.Track.Url}) ended in {args.Player.TextChannel.Guild.Name}/{args.Player.TextChannel.Name}"));
}
else
{
await args.Player.PlayAsync(args.Track);
_loopDict[guildId]--;
return;
}
}
if (!args.Player.Queue.TryDequeue(out var nextTrack))
{
builder.WithDescription(GuildUtils.Locate("NoTracks", args.Player.TextChannel))
.WithColor(FergunClient.Config.EmbedColor);
await args.Player.TextChannel.SendMessageAsync(embed : builder.Build());
await _logService.LogAsync(new LogMessage(LogSeverity.Info, "Victoria", $"Queue now empty in {args.Player.TextChannel.Guild.Name}/{args.Player.TextChannel.Name}"));
return;
}
await args.Player.PlayAsync(nextTrack);
builder.WithTitle(GuildUtils.Locate("NowPlaying", args.Player.TextChannel))
.WithDescription(nextTrack.ToTrackLink())
.WithColor(FergunClient.Config.EmbedColor);
await args.Player.TextChannel.SendMessageAsync(embed : builder.Build());
await _logService.LogAsync(new LogMessage(LogSeverity.Info, "Victoria", $"Now playing: {nextTrack.Title} ({nextTrack.Url}) in {args.Player.TextChannel.Guild.Name}/{args.Player.TextChannel.Name}"));
}
private async Task TrackEnded(TrackEndedEventArgs arg)
{
if (!arg.Reason.ShouldPlayNext())
{
return;
}
if (!arg.Player.Queue.TryDequeue(out var item) || !(item is LavaTrack nextTrack))
{
await arg.Player.TextChannel.SendMessageAsync("There are no more queued tracks");
return;
}
await arg.Player.PlayAsync(nextTrack);
}
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (args.Reason is TrackEndReason.LoadFailed || args.Reason is TrackEndReason.Cleanup ||
args.Reason is TrackEndReason.Replaced || args.Reason is TrackEndReason.Stopped)
{
return;
}
CustomLavaPlayer player = (CustomLavaPlayer)args.Player;
player.SkippedUsers.Clear();
player.Queue.TryDequeue(out _);
if (!player.CustomQueue.TryDequeue(out CustomLavaTrack nextTrack) && !player.QueueLoop)
{
await player.TextChannel.SendMessageAsync("Queue finished.");
await Disconnect(player.VoiceChannel);
}
private async Task TrackEnded(TrackEndedEventArgs arg)
{
if (!arg.Reason.ShouldPlayNext())
{
return;
}
if (arg.Player.Queue.TryDequeue(out var item) || !(item is LavaTrack nextTrack))
{
await _client.SetGameAsync("");
return;
}
await arg.Player.PlayAsync(nextTrack);
await _client.SetGameAsync(nextTrack.Title);
}
private async Task TrackEnded(TrackEndedEventArgs endEvent)
{
if (!endEvent.Reason.ShouldPlayNext())
{
return;
}
if (!endEvent.Player.Queue.TryDequeue(out var item))
{
await endEvent.Player.TextChannel.SendMessageAsync("Queue empty.");
return;
}
await endEvent.Player.PlayAsync(item);
await endEvent.Player.TextChannel.SendMessageAsync(
$"**Now playing:** *{item.Title}*\n{item.Url}");
}
public static async Task OnTrackEnd(TrackEndedEventArgs e)
{
LavaPlayer player = e.Player;
DefaultQueue <IQueueable> queue = player.Queue;
if (player != null && queue?.Count > 0 && e.Reason.ShouldPlayNext())
{
bool success = queue.TryDequeue(out IQueueable val);
if (success)
{
var track = (LavaTrack)val;
await player.PlayAsync(track);
if (player.TextChannel != null)
{
var sb = new StringBuilder();
sb.AppendLine($"Songs left in queue: `{queue.Count:N0}`");
sb.AppendLine($"Title: `{track.Title}`");
sb.AppendLine($"Duration: `{track.Duration.Humanize(2)}`");
sb.AppendLine($"Track Name: `{track.Title}`");
var embed = new KaguyaEmbedBuilder
{
Title = $"New Track",
Fields = new List <EmbedFieldBuilder>
{
new EmbedFieldBuilder
{
Name = "Track Information",
Value = sb.ToString()
}
}
};
await player.TextChannel.SendEmbedAsync(embed);
}
await ConsoleLogger.LogAsync("Successfully continued the music " +
$"queue in guild {e.Player.VoiceChannel.Guild}", LogLvl.DEBUG);
}
}
}
private async Task TrackEndedAsync(TrackEndedEventArgs arg)
{
await _logger.LogMessage(new LogMessage(LogSeverity.Info,
"AudioManager",
$"Track \"{arg.Track.Title}\" ended in \"{arg.Player.VoiceChannel.Name}\" on {arg.Player.VoiceChannel.Guild.Name}\"."));
var guildId = arg.Player.TextChannel.Guild.Id;
var repeat = _repeat[guildId];
if (arg.Reason == TrackEndReason.Cleanup ||
arg.Reason == TrackEndReason.Stopped ||
(arg.Player.Queue.Count == 0 && arg.Player.Track == null && !repeat))
{
await _nowPlayingMessages[guildId].DeleteAsync();
_nowPlayingMessages.Remove(guildId);
}
if (!arg.Reason.ShouldPlayNext())
{
return;
}
var player = arg.Player;
if (repeat)
{
await arg.Player.PlayAsync(arg.Track);
}
else
{
if (!player.Queue.TryDequeue(out var queueable))
{
return;
}
if (queueable is LavaTrack track)
{
await arg.Player.PlayAsync(track);
}
}
}
/// Handling track end event for auto play. (original)
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
if (!player.Queue.TryDequeue(out var queueable))
{
await player.TextChannel.SendMessageAsync(":stop_button: No more tracks to play.");
return;
}
if (!(queueable is LavaTrack track))
{
await player.TextChannel.SendMessageAsync(":x: Next item in queue is not a track.");
return;
}
//https://i.ytimg.com/vi/tPEE9ZwTmy0/hqdefault.jpg
//https://i.ytimg.com/vi/tPEE9ZwTmy0/hqdefault.jpg
await args.Player.PlayAsync(track);
await args.Player.TextChannel.SendMessageAsync(
$"{args.Reason}: **{args.Track.Title}**.",
embed : new EmbedBuilder()
.WithAuthor("Now Playing")
.WithTitle(track.Title)
.WithColor(Config.Onpu.EmbedColor)
.WithUrl(track.Url)
.AddField("Duration", track.Duration, true)
.AddField("Author", track.Author, true)
.WithThumbnailUrl($"https://i.ytimg.com/vi/{track.Id}/hqdefault.jpg")
.WithFooter("Onpu Musicbox", Config.Onpu.EmbedAvatarUrl)
.Build());
}
private async Task OnTrackEnded(TrackEndedEventArgs e)
{
IPlayable track = null;
switch (e.Reason)
{
case "Finished":
await Prepare(e.Player.VoiceChannel.Guild);
track = await _music.PlayNext();
break;
case "Replaced":
break;
case "LoadFailed":
await Prepare(e.Player.VoiceChannel.Guild);
await e.Player.TextChannel.SendMessageAsync(_localization.GetMessage("Music exception"));
track = await _music.PlayNext();
break;
case "Cleanup":
break;
case "Stopped":
break;
}
if (track == null)
{
return;
}
await track.TextChannel.SendMessageAsync(_localization.GetMessage("Music now playing", track.Track.Title,
track.Requester.Nickname()));
}
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
TrackEndReason reason = args.Reason;
LavaPlayer player = args.Player;
LavaTrack track = args.Track;
if (!reason.ShouldPlayNext())
{
return;
}
if (_loop)
{
await player.PlayAsync(track);
await player.TextChannel.SendMessageAsync($":arrow_forward: Now playing: `{track.Title}`");
return;
}
if (!player.Queue.TryDequeue(out IQueueable queueObject) || !(queueObject is LavaTrack nextTrack))
{
await player.TextChannel.SendMessageAsync(":x: There are no more tracks in the queue.");
return;
}
if (_qloop)
{
await player.PlayAsync(nextTrack);
player.Queue.Enqueue(track);
await player.TextChannel.SendMessageAsync($":arrow_forward: Now playing: `{nextTrack.Title}`");
return;
}
await player.PlayAsync(nextTrack);
await player.TextChannel.SendMessageAsync($":arrow_forward: Now playing: `{nextTrack.Title}`");
}
//EventHandlers
private async Task OnTrackEnded(TrackEndedEventArgs args) //embed and purge last message
{
var player = args.Player;
if (!player.Queue.TryDequeue(out var queueable))
{
await player.TextChannel.SendMessageAsync("Queue completed, gib more tracks");
return;
}
if (!(queueable is LavaTrack track))
{
await player.TextChannel.SendMessageAsync("Next item in queue is not a track.");
return;
}
await args.Player.PlayAsync(track);
await args.Player.TextChannel.SendMessageAsync(
$"{args.Reason}: {args.Track.Title}\nNow playing: {track.Title}");
}
private async Task OnTrackEndedAsync(TrackEndedEventArgs args)
{
var toEmebed = new EmbedBuilder();
if (!args.Reason.ShouldPlayNext())
{
return;
}
if (!args.Player.Queue.TryDequeue(out var track))
{
await _lavaNode.LeaveAsync(args.Player.VoiceChannel);
return;
}
var nexttrack = (LavaTrack)track;
await args.Player.PlayAsync(nexttrack);
toEmebed.WithTitle("Now playing");
toEmebed.WithDescription(nexttrack.Title);
toEmebed.WithColor(Color.Green);
await args.Player.TextChannel.SendMessageAsync("", false, toEmebed.Build());
}
