871 lines
38 KiB
Python
871 lines
38 KiB
Python
import wavelink
|
||
import discord
|
||
import random
|
||
import asyncio
|
||
import logging
|
||
import json
|
||
from pathlib import Path
|
||
from collections import deque
|
||
from discord.ext import commands
|
||
|
||
log = logging.getLogger(__name__)
|
||
|
||
# ── colours & assets ────────────────────────────────────────────────────────
|
||
C_MAIN = 0x8BE9FD # cyan – now playing
|
||
C_QUEUE = 0xBD93F9 # purple – queue
|
||
C_OK = 0x50FA7B # green – success
|
||
C_WARN = 0xFFB86C # orange – warnings / loop
|
||
C_ERR = 0xFF5555 # red – errors
|
||
C_HIST = 0x6272A4 # muted – history
|
||
C_RADIO = 0xFF79C6 # pink – radio
|
||
|
||
LOOP_OFF = 0
|
||
LOOP_TRACK = 1
|
||
LOOP_QUEUE = 2
|
||
|
||
LOOP_LABEL = {
|
||
LOOP_OFF: "Off",
|
||
LOOP_TRACK: "🔂 Track",
|
||
LOOP_QUEUE: "🔁 Queue",
|
||
}
|
||
|
||
MODE_MUSIC = "music"
|
||
MODE_RADIO = "radio"
|
||
|
||
# ── per-guild state ──────────────────────────────────────────────────────────
|
||
class GuildState:
|
||
def __init__(self):
|
||
self.queue: deque = deque()
|
||
self.history: list = [] # last 10 tracks
|
||
self.loop: int = LOOP_OFF
|
||
self.autoplay: bool = False
|
||
self.current: wavelink.Playable | None = None
|
||
self.mode: str | None = None
|
||
|
||
def push_history(self, track: wavelink.Playable):
|
||
self.history.insert(0, track)
|
||
if len(self.history) > 10:
|
||
self.history.pop()
|
||
|
||
# ── helpers ──────────────────────────────────────────────────────────────────
|
||
def fmt_duration(ms: int) -> str:
|
||
s = ms // 1000
|
||
m, s = divmod(s, 60)
|
||
h, m = divmod(m, 60)
|
||
return f"{h}:{m:02}:{s:02}" if h else f"{m}:{s:02}"
|
||
|
||
def progress_bar(position_ms: int, duration_ms: int, width: int = 14) -> str:
|
||
if duration_ms == 0:
|
||
return "▬" * width
|
||
pct = min(position_ms / duration_ms, 1.0)
|
||
filled = int(pct * width)
|
||
return "▬" * filled + "🔘" + "▬" * (width - filled)
|
||
|
||
def is_dj():
|
||
"""Soft DJ check — allows anyone to use info/play, restricts control commands."""
|
||
async def predicate(ctx: commands.Context):
|
||
if any(r.name.lower() == "dj" for r in ctx.author.roles):
|
||
return True
|
||
await ctx.reply(
|
||
embed=discord.Embed(
|
||
description="🎧 You need the **DJ** role to use this command.",
|
||
color=C_ERR,
|
||
)
|
||
)
|
||
return False
|
||
return commands.check(predicate)
|
||
|
||
# ── UI views ─────────────────────────────────────────────────────────────────
|
||
class _CategoryView(discord.ui.View):
|
||
"""Step 1: buttons for each radio category."""
|
||
def __init__(self, bot: commands.Bot, stations: dict, timeout: float = 120.0):
|
||
super().__init__(timeout=timeout)
|
||
self.bot = bot
|
||
self.stations = stations
|
||
self.message: discord.Message | None = None
|
||
|
||
for i, category in enumerate(stations.keys()):
|
||
# Truncate long category names for button labels (max 80 chars)
|
||
label = category[:80]
|
||
btn = discord.ui.Button(
|
||
label=label,
|
||
style=discord.ButtonStyle.primary,
|
||
row=i // 5, # 5 buttons per row
|
||
)
|
||
btn.callback = self._make_category_callback(category)
|
||
self.add_item(btn)
|
||
|
||
def _make_category_callback(self, category: str):
|
||
async def callback(interaction: discord.Interaction):
|
||
station_list = self.stations[category]
|
||
view = _StationSelect(self.bot, category, station_list, interaction, timeout=self.timeout)
|
||
embed = discord.Embed(
|
||
title=f"📻 {category}",
|
||
description="Pick a station from the dropdown below:",
|
||
color=C_RADIO,
|
||
)
|
||
await interaction.response.edit_message(embed=embed, view=view)
|
||
view.message = interaction.message
|
||
return callback
|
||
|
||
async def on_timeout(self):
|
||
if self.message:
|
||
try:
|
||
for child in self.children:
|
||
child.disabled = True
|
||
await self.message.edit(view=self)
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
class _StationSelect(discord.ui.View):
|
||
"""Step 2: dropdown to pick a specific station."""
|
||
def __init__(self, bot: commands.Bot, category: str, stations: list[dict], interaction: discord.Interaction, timeout: float = 120.0):
|
||
super().__init__(timeout=timeout)
|
||
self.bot = bot
|
||
self.category = category
|
||
self.stations = stations
|
||
self._interaction = interaction
|
||
self.message: discord.Message | None = None
|
||
self._picked: dict | None = None
|
||
|
||
options = []
|
||
for s in stations:
|
||
label = s["name"][:100] # Discord limit
|
||
desc = s["desc"][:100] if s["desc"] else "\u200b" # zero-width space if empty
|
||
options.append(discord.SelectOption(label=label, description=desc, value=s["name"]))
|
||
|
||
select = discord.ui.Select(
|
||
placeholder="Choose a station…",
|
||
options=options,
|
||
)
|
||
select.callback = self._on_select
|
||
self.add_item(select)
|
||
|
||
async def _on_select(self, interaction: discord.Interaction):
|
||
station_name = interaction.data["values"][0] # type: ignore
|
||
for s in self.stations:
|
||
if s["name"] == station_name:
|
||
self._picked = s
|
||
break
|
||
# Disable the dropdown immediately
|
||
for child in self.children:
|
||
child.disabled = True
|
||
await interaction.response.edit_message(view=self)
|
||
|
||
# Do the actual radio playback
|
||
cog = self.bot.get_cog("Music")
|
||
if cog and self._picked:
|
||
await cog._play_radio_stream(interaction, self.category, self._picked)
|
||
self.stop()
|
||
|
||
async def on_timeout(self):
|
||
if self.message:
|
||
try:
|
||
for child in self.children:
|
||
child.disabled = True
|
||
await self.message.edit(view=self)
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
# ── cog ──────────────────────────────────────────────────────────────────────
|
||
class Music(commands.Cog):
|
||
def __init__(self, bot: commands.Bot):
|
||
self.bot = bot
|
||
self._states: dict[int, GuildState] = {}
|
||
self._voice_channels: dict[int, int] = {} # guild_id → channel_id for disconnect cleanup
|
||
self._radio_channels: dict[int, int] = {} # guild_id → channel_id for radio-drop notifications
|
||
self._locks: dict[int, asyncio.Lock] = {}
|
||
|
||
# Load radio stations
|
||
stations_path = Path(__file__).parent / "radio_stations.json"
|
||
with open(stations_path, "r", encoding="utf-8") as f:
|
||
self._radio_stations: dict[str, list[dict]] = json.load(f)
|
||
log.info(f"Loaded radio stations: {sum(len(v) for v in self._radio_stations.values())} stations in {len(self._radio_stations)} categories")
|
||
|
||
def state(self, guild_id: int) -> GuildState:
|
||
if guild_id not in self._states:
|
||
self._states[guild_id] = GuildState()
|
||
return self._states[guild_id]
|
||
|
||
def _get_player(self, ctx: commands.Context) -> wavelink.Player | None:
|
||
"""Get the wavelink Player for a context, or None."""
|
||
vc = ctx.voice_client
|
||
if isinstance(vc, wavelink.Player):
|
||
return vc
|
||
return None
|
||
|
||
def _lock(self, guild_id: int) -> asyncio.Lock:
|
||
"""Get or create a per-guild asyncio.Lock."""
|
||
if guild_id not in self._locks:
|
||
self._locks[guild_id] = asyncio.Lock()
|
||
return self._locks[guild_id]
|
||
|
||
# ── channel status ────────────────────────────────────────────────────────
|
||
async def _set_channel_status(self, player: wavelink.Player, track: wavelink.Playable | None = None, *, title: str | None = None):
|
||
"""Set (or clear) the voice channel status. Pass *title* for radio; otherwise uses track.title."""
|
||
channel = player.channel
|
||
if channel is None:
|
||
return
|
||
try:
|
||
if title is not None:
|
||
status = f"📻 {title}"[:500]
|
||
elif track is not None:
|
||
status = f"🎵 {track.title}"[:500]
|
||
else:
|
||
status = None
|
||
route = discord.http.Route(
|
||
'PUT',
|
||
'/channels/{channel_id}/voice-status',
|
||
channel_id=channel.id,
|
||
)
|
||
await self.bot.http.request(route, json={'status': status})
|
||
except Exception:
|
||
log.warning(f"Failed to set voice channel status in {player.guild.id}", exc_info=True)
|
||
|
||
async def _clear_channel_status(self, guild_id: int):
|
||
"""Clear voice channel status after the bot was disconnected."""
|
||
channel_id = self._voice_channels.pop(guild_id, None)
|
||
if channel_id is None:
|
||
return
|
||
try:
|
||
route = discord.http.Route(
|
||
'PUT',
|
||
'/channels/{channel_id}/voice-status',
|
||
channel_id=channel_id,
|
||
)
|
||
await self.bot.http.request(route, json={'status': None})
|
||
except Exception:
|
||
log.warning(f"Failed to clear voice channel status in guild {guild_id}", exc_info=True)
|
||
|
||
# ── connect lavalink ─────────────────────────────────────────────────────
|
||
@commands.Cog.listener()
|
||
async def on_ready(self):
|
||
node = wavelink.Node(uri="http://127.0.0.1:2333", password="yuukabot")
|
||
await wavelink.Pool.connect(nodes=[node], client=self.bot)
|
||
log.info("Wavelink connected to Lavalink")
|
||
|
||
# ── voice state update → clear status on disconnect ──────────────────────
|
||
@commands.Cog.listener()
|
||
async def on_voice_state_update(self, member: discord.Member, before: discord.VoiceState, after: discord.VoiceState):
|
||
if member.id != self.bot.user.id:
|
||
return
|
||
# Bot was in a channel and left (kicked, moved, or disconnected)
|
||
if before.channel is not None and after.channel is None:
|
||
guild_id = member.guild.id
|
||
# Also clean up guild state
|
||
st = self._states.pop(guild_id, None)
|
||
if st:
|
||
st.queue.clear()
|
||
self._locks.pop(guild_id, None)
|
||
self._radio_channels.pop(guild_id, None)
|
||
await self._clear_channel_status(guild_id)
|
||
|
||
# ── track end → advance queue ─────────────────────────────────────────────
|
||
@commands.Cog.listener()
|
||
async def on_wavelink_track_end(self, payload: wavelink.TrackEndEventPayload):
|
||
player: wavelink.Player = payload.player
|
||
if player is None:
|
||
return
|
||
|
||
st = self.state(player.guild.id)
|
||
|
||
if st.loop == LOOP_TRACK and st.current:
|
||
await player.play(st.current)
|
||
await self._set_channel_status(player, st.current)
|
||
return
|
||
|
||
if st.loop == LOOP_QUEUE and st.current:
|
||
st.queue.append(st.current)
|
||
|
||
if st.current:
|
||
st.push_history(st.current)
|
||
|
||
if st.queue:
|
||
next_track = st.queue.popleft()
|
||
st.current = next_track
|
||
await player.play(next_track)
|
||
await self._set_channel_status(player, next_track)
|
||
elif st.autoplay:
|
||
# wavelink built-in autoplay
|
||
await player.set_autoplay(wavelink.AutoPlayMode.enabled)
|
||
else:
|
||
# If a radio stream dropped unexpectedly, notify the channel
|
||
if st.mode == MODE_RADIO:
|
||
await self._notify_radio_drop(player.guild.id)
|
||
st.current = None
|
||
st.mode = None
|
||
await self._set_channel_status(player)
|
||
|
||
# ── track exception / stuck → radio stream failures ──────────────────────
|
||
@commands.Cog.listener()
|
||
async def on_wavelink_track_exception(self, payload: wavelink.TrackExceptionEventPayload):
|
||
player: wavelink.Player = payload.player
|
||
if player is None:
|
||
return
|
||
st = self.state(player.guild.id)
|
||
if st.mode == MODE_RADIO:
|
||
log.warning(f"Radio stream exception in guild {player.guild.id}: {payload.exception}")
|
||
await self._notify_radio_drop(player.guild.id)
|
||
st.mode = None
|
||
await self._set_channel_status(player)
|
||
|
||
@commands.Cog.listener()
|
||
async def on_wavelink_track_stuck(self, payload: wavelink.TrackStuckEventPayload):
|
||
player: wavelink.Player = payload.player
|
||
if player is None:
|
||
return
|
||
st = self.state(player.guild.id)
|
||
if st.mode == MODE_RADIO:
|
||
log.warning(f"Radio stream stuck in guild {player.guild.id}, threshold {payload.threshold_ms}ms")
|
||
await self._notify_radio_drop(player.guild.id)
|
||
st.mode = None
|
||
await self._set_channel_status(player)
|
||
|
||
async def _notify_radio_drop(self, guild_id: int):
|
||
"""Send a notification to the channel where radio was started."""
|
||
channel_id = self._radio_channels.pop(guild_id, None)
|
||
if channel_id is None:
|
||
return
|
||
guild = self.bot.get_guild(guild_id)
|
||
if guild is None:
|
||
return
|
||
channel = guild.get_channel_or_thread(channel_id)
|
||
if channel is None:
|
||
return
|
||
try:
|
||
await channel.send(embed=discord.Embed(
|
||
description="📻 Radio stream ended unexpectedly. Use `!radio` to restart.",
|
||
color=C_WARN,
|
||
))
|
||
except Exception:
|
||
log.warning(f"Failed to send radio-drop notification in guild {guild_id}", exc_info=True)
|
||
|
||
# ── track start → update status ───────────────────────────────────────────
|
||
@commands.Cog.listener()
|
||
async def on_wavelink_track_start(self, payload: wavelink.TrackStartEventPayload):
|
||
player: wavelink.Player = payload.player
|
||
if player is None:
|
||
return
|
||
st = self.state(player.guild.id)
|
||
st.current = payload.track
|
||
# Only auto-update status for music mode (radio sets its own title)
|
||
if st.mode != MODE_RADIO:
|
||
await self._set_channel_status(player, st.current)
|
||
|
||
# ── !play ─────────────────────────────────────────────────────────────────
|
||
@commands.command(aliases=["p"])
|
||
async def play(self, ctx: commands.Context, *, query: str):
|
||
"""Play a song or playlist. Accepts search terms or YouTube URLs."""
|
||
if not ctx.author.voice:
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="❌ Join a voice channel first.", color=C_ERR))
|
||
|
||
st = self.state(ctx.guild.id)
|
||
|
||
# Mode check: refuse if radio is active
|
||
if st.mode == MODE_RADIO:
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="📻 Radio is currently active. Use `!stop` first to switch back to music.",
|
||
color=C_WARN))
|
||
|
||
async with self._lock(ctx.guild.id):
|
||
vc = self._get_player(ctx)
|
||
if not vc:
|
||
vc = await ctx.author.voice.channel.connect(cls=wavelink.Player)
|
||
vc.autoplay = wavelink.AutoPlayMode.disabled
|
||
vc.inactive_timeout = None
|
||
self._voice_channels[ctx.guild.id] = ctx.author.voice.channel.id
|
||
|
||
async with ctx.typing():
|
||
results = await wavelink.Playable.search(query)
|
||
|
||
if not results:
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="❌ Nothing found.", color=C_ERR))
|
||
|
||
# playlist
|
||
if isinstance(results, wavelink.Playlist):
|
||
tracks = list(results.tracks)
|
||
for t in tracks:
|
||
t.extras = {"requester_id": ctx.author.id}
|
||
st.queue.append(t)
|
||
|
||
# Start the first track if nothing is playing
|
||
if not vc.playing and not vc.paused and st.queue:
|
||
st.current = st.queue.popleft()
|
||
await vc.play(st.current)
|
||
await self._set_channel_status(vc, st.current)
|
||
|
||
st.mode = MODE_MUSIC
|
||
|
||
embed = discord.Embed(
|
||
title="📋 Playlist Queued",
|
||
description=f"**{results.name}**",
|
||
color=C_QUEUE,
|
||
)
|
||
embed.add_field(name="Tracks", value=str(len(tracks)))
|
||
embed.add_field(name="Added by", value=ctx.author.mention)
|
||
await ctx.reply(embed=embed)
|
||
|
||
else:
|
||
track = results[0]
|
||
track.extras = {"requester_id": ctx.author.id}
|
||
|
||
if vc.playing or vc.paused:
|
||
st.queue.append(track)
|
||
embed = discord.Embed(
|
||
title="➕ Added to Queue",
|
||
description=f"**{track.title}**",
|
||
color=C_QUEUE,
|
||
)
|
||
embed.add_field(name="Duration", value=fmt_duration(track.length))
|
||
embed.add_field(name="Position", value=f"#{len(st.queue)}")
|
||
embed.add_field(name="Requested by", value=ctx.author.mention)
|
||
if track.artwork:
|
||
embed.set_thumbnail(url=track.artwork)
|
||
return await ctx.reply(embed=embed)
|
||
|
||
st.current = track
|
||
await vc.play(track)
|
||
await self._set_channel_status(vc, track)
|
||
|
||
st.mode = MODE_MUSIC
|
||
|
||
embed = discord.Embed(
|
||
title="▶️ Now Playing",
|
||
description=f"**{track.title}**",
|
||
color=C_MAIN,
|
||
)
|
||
embed.add_field(name="Duration", value=fmt_duration(track.length))
|
||
embed.add_field(name="Requested by", value=ctx.author.mention)
|
||
embed.add_field(name="Loop", value=LOOP_LABEL[st.loop], inline=True)
|
||
embed.add_field(name="Autoplay", value="On" if st.autoplay else "Off", inline=True)
|
||
if track.artwork:
|
||
embed.set_thumbnail(url=track.artwork)
|
||
await ctx.reply(embed=embed)
|
||
|
||
# ── !pause / !resume ──────────────────────────────────────────────────────
|
||
@commands.command()
|
||
@is_dj()
|
||
async def pause(self, ctx: commands.Context):
|
||
vc = self._get_player(ctx)
|
||
if vc and vc.playing:
|
||
await vc.pause(True)
|
||
await ctx.reply(embed=discord.Embed(description="⏸️ Paused.", color=C_OK))
|
||
else:
|
||
await ctx.reply(embed=discord.Embed(description="❌ Nothing is playing.", color=C_ERR))
|
||
|
||
@commands.command()
|
||
@is_dj()
|
||
async def resume(self, ctx: commands.Context):
|
||
vc = self._get_player(ctx)
|
||
if vc and vc.paused:
|
||
await vc.pause(False)
|
||
await ctx.reply(embed=discord.Embed(description="▶️ Resumed.", color=C_OK))
|
||
else:
|
||
await ctx.reply(embed=discord.Embed(description="❌ Nothing is paused.", color=C_ERR))
|
||
|
||
# ── !skip ─────────────────────────────────────────────────────────────────
|
||
@commands.command()
|
||
@is_dj()
|
||
async def skip(self, ctx: commands.Context):
|
||
vc = self._get_player(ctx)
|
||
if vc and (vc.playing or vc.paused):
|
||
await vc.skip()
|
||
await ctx.reply(embed=discord.Embed(description="⏭️ Skipped.", color=C_OK))
|
||
else:
|
||
await ctx.reply(embed=discord.Embed(description="❌ Nothing to skip.", color=C_ERR))
|
||
|
||
# ── !stop / !leave ────────────────────────────────────────────────────────
|
||
@commands.command(aliases=["leave", "disconnect"])
|
||
@is_dj()
|
||
async def stop(self, ctx: commands.Context):
|
||
"""Stop playback (music or radio), clear the queue, and disconnect from voice."""
|
||
st = self.state(ctx.guild.id)
|
||
current_mode = st.mode
|
||
|
||
st.queue.clear()
|
||
st.current = None
|
||
st.loop = LOOP_OFF
|
||
st.autoplay = False
|
||
st.mode = None
|
||
|
||
vc = self._get_player(ctx)
|
||
if vc:
|
||
await self._set_channel_status(vc)
|
||
await vc.disconnect()
|
||
|
||
self._voice_channels.pop(ctx.guild.id, None)
|
||
self._radio_channels.pop(ctx.guild.id, None)
|
||
self._locks.pop(ctx.guild.id, None)
|
||
|
||
if current_mode == MODE_RADIO:
|
||
msg = "⏹️ Stopped radio and disconnected."
|
||
else:
|
||
msg = "⏹️ Stopped and disconnected."
|
||
await ctx.reply(embed=discord.Embed(description=msg, color=C_OK))
|
||
|
||
# ── !seek ─────────────────────────────────────────────────────────────────
|
||
@commands.command()
|
||
@is_dj()
|
||
async def seek(self, ctx: commands.Context, timestamp: str):
|
||
"""Seek to a timestamp. Format: 1:30 or 90 (seconds)."""
|
||
vc = self._get_player(ctx)
|
||
if not vc or not vc.playing:
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="❌ Nothing is playing.", color=C_ERR))
|
||
try:
|
||
if ":" in timestamp:
|
||
parts = timestamp.split(":")
|
||
if len(parts) == 2:
|
||
ms = (int(parts[0]) * 60 + int(parts[1])) * 1000
|
||
else:
|
||
ms = (int(parts[0]) * 3600 + int(parts[1]) * 60 + int(parts[2])) * 1000
|
||
else:
|
||
ms = int(timestamp) * 1000
|
||
except ValueError:
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="❌ Invalid format. Use `1:30` or `90`.", color=C_ERR))
|
||
|
||
await vc.seek(ms)
|
||
await ctx.reply(embed=discord.Embed(
|
||
description=f"⏩ Seeked to `{timestamp}`.", color=C_OK))
|
||
|
||
# ── !looptrack / !loopqueue ───────────────────────────────────────────────
|
||
@commands.command()
|
||
@is_dj()
|
||
async def looptrack(self, ctx: commands.Context):
|
||
st = self.state(ctx.guild.id)
|
||
st.loop = LOOP_OFF if st.loop == LOOP_TRACK else LOOP_TRACK
|
||
await ctx.reply(embed=discord.Embed(
|
||
description=f"🔂 Loop track: **{'On' if st.loop == LOOP_TRACK else 'Off'}**",
|
||
color=C_WARN))
|
||
|
||
@commands.command()
|
||
@is_dj()
|
||
async def loopqueue(self, ctx: commands.Context):
|
||
st = self.state(ctx.guild.id)
|
||
st.loop = LOOP_OFF if st.loop == LOOP_QUEUE else LOOP_QUEUE
|
||
await ctx.reply(embed=discord.Embed(
|
||
description=f"🔁 Loop queue: **{'On' if st.loop == LOOP_QUEUE else 'Off'}**",
|
||
color=C_WARN))
|
||
|
||
# ── !autoplay ─────────────────────────────────────────────────────────────
|
||
@commands.command()
|
||
@is_dj()
|
||
async def autoplay(self, ctx: commands.Context):
|
||
st = self.state(ctx.guild.id)
|
||
vc = self._get_player(ctx)
|
||
st.autoplay = not st.autoplay
|
||
if vc:
|
||
mode = wavelink.AutoPlayMode.enabled if st.autoplay else wavelink.AutoPlayMode.disabled
|
||
await vc.set_autoplay(mode)
|
||
await ctx.reply(embed=discord.Embed(
|
||
description=f"✨ Autoplay: **{'On' if st.autoplay else 'Off'}**",
|
||
color=C_OK))
|
||
|
||
# ── !nowplaying ───────────────────────────────────────────────────────────
|
||
@commands.command(aliases=["np"])
|
||
async def nowplaying(self, ctx: commands.Context):
|
||
vc = self._get_player(ctx)
|
||
st = self.state(ctx.guild.id)
|
||
|
||
if not vc or not vc.playing or not st.current:
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="❌ Nothing is playing.", color=C_ERR))
|
||
|
||
track = st.current
|
||
pos_ms = vc.position
|
||
dur_ms = track.length
|
||
bar = progress_bar(pos_ms, dur_ms)
|
||
|
||
if track.extras and isinstance(track.extras, dict):
|
||
requester_id = track.extras.get("requester_id")
|
||
requester = f"<@{requester_id}>" if requester_id else "Unknown"
|
||
else:
|
||
requester = "Unknown"
|
||
|
||
embed = discord.Embed(
|
||
title="🎵 Now Playing",
|
||
description=f"### {track.title}",
|
||
color=C_MAIN,
|
||
)
|
||
embed.add_field(
|
||
name="Progress",
|
||
value=f"`{fmt_duration(pos_ms)}` {bar} `{fmt_duration(dur_ms)}`",
|
||
inline=False,
|
||
)
|
||
embed.add_field(name="Requested by", value=requester, inline=True)
|
||
embed.add_field(name="Loop", value=LOOP_LABEL[st.loop], inline=True)
|
||
embed.add_field(name="Autoplay", value="On" if st.autoplay else "Off", inline=True)
|
||
embed.add_field(name="Queue", value=f"{len(st.queue)} track(s) up next", inline=True)
|
||
if track.artwork:
|
||
embed.set_thumbnail(url=track.artwork)
|
||
embed.set_footer(text="yuuka music")
|
||
await ctx.reply(embed=embed)
|
||
|
||
# ── !queue ────────────────────────────────────────────────────────────────
|
||
@commands.command(aliases=["q"])
|
||
async def queue(self, ctx: commands.Context):
|
||
st = self.state(ctx.guild.id)
|
||
|
||
if not st.current and not st.queue:
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="📋 Queue is empty.", color=C_QUEUE))
|
||
|
||
embed = discord.Embed(title="📋 Queue", color=C_QUEUE)
|
||
|
||
if st.current:
|
||
embed.add_field(
|
||
name="▶️ Now Playing",
|
||
value=f"**{st.current.title}** `{fmt_duration(st.current.length)}`",
|
||
inline=False,
|
||
)
|
||
|
||
if st.queue:
|
||
lines = []
|
||
for i, t in enumerate(list(st.queue)[:15], 1):
|
||
lines.append(f"`{i:02}.` **{t.title}** `{fmt_duration(t.length)}`")
|
||
if len(st.queue) > 15:
|
||
lines.append(f"*... and {len(st.queue) - 15} more*")
|
||
embed.add_field(name="Up Next", value="\n".join(lines), inline=False)
|
||
|
||
total_ms = sum(t.length for t in st.queue)
|
||
embed.set_footer(text=f"{len(st.queue)} tracks · {fmt_duration(total_ms)} remaining · Loop: {LOOP_LABEL[st.loop]}")
|
||
await ctx.reply(embed=embed)
|
||
|
||
# ── !remove ───────────────────────────────────────────────────────────────
|
||
@commands.command()
|
||
@is_dj()
|
||
async def remove(self, ctx: commands.Context, position: int):
|
||
st = self.state(ctx.guild.id)
|
||
if position < 1 or position > len(st.queue):
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description=f"❌ Position must be between 1 and {len(st.queue)}. Use `!queue` to see positions.", color=C_ERR))
|
||
q = list(st.queue)
|
||
removed = q.pop(position - 1)
|
||
st.queue = deque(q)
|
||
await ctx.reply(embed=discord.Embed(
|
||
description=f"🗑️ Removed **{removed.title}** from queue.", color=C_OK))
|
||
|
||
# ── !move ─────────────────────────────────────────────────────────────────
|
||
@commands.command()
|
||
@is_dj()
|
||
async def move(self, ctx: commands.Context, from_pos: int, to_pos: int):
|
||
st = self.state(ctx.guild.id)
|
||
size = len(st.queue)
|
||
if not (1 <= from_pos <= size) or not (1 <= to_pos <= size):
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description=f"❌ Invalid positions. Queue has {size} items. Use `!queue` to see positions.", color=C_ERR))
|
||
q = list(st.queue)
|
||
track = q.pop(from_pos - 1)
|
||
q.insert(to_pos - 1, track)
|
||
st.queue = deque(q)
|
||
await ctx.reply(embed=discord.Embed(
|
||
description=f"↕️ Moved **{track.title}** to position **{to_pos}**.", color=C_OK))
|
||
|
||
# ── !shuffle ──────────────────────────────────────────────────────────────
|
||
@commands.command()
|
||
@is_dj()
|
||
async def shuffle(self, ctx: commands.Context):
|
||
st = self.state(ctx.guild.id)
|
||
if not st.queue:
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="❌ Queue is empty.", color=C_ERR))
|
||
q = list(st.queue)
|
||
random.shuffle(q)
|
||
st.queue = deque(q)
|
||
await ctx.reply(embed=discord.Embed(
|
||
description="🔀 Queue shuffled.", color=C_OK))
|
||
|
||
# ── !clear ────────────────────────────────────────────────────────────────
|
||
@commands.command()
|
||
@is_dj()
|
||
async def clear(self, ctx: commands.Context):
|
||
st = self.state(ctx.guild.id)
|
||
st.queue.clear()
|
||
await ctx.reply(embed=discord.Embed(
|
||
description="🗑️ Queue cleared.", color=C_OK))
|
||
|
||
# ── !history ──────────────────────────────────────────────────────────────
|
||
@commands.command(aliases=["h"])
|
||
async def history(self, ctx: commands.Context):
|
||
st = self.state(ctx.guild.id)
|
||
if not st.history:
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="📜 No history yet.", color=C_HIST))
|
||
lines = [f"`{i:02}.` **{t.title}** `{fmt_duration(t.length)}`"
|
||
for i, t in enumerate(st.history, 1)]
|
||
embed = discord.Embed(
|
||
title="📜 Recently Played",
|
||
description="\n".join(lines),
|
||
color=C_HIST,
|
||
)
|
||
await ctx.reply(embed=embed)
|
||
|
||
# ── !radio ────────────────────────────────────────────────────────────────
|
||
@commands.command()
|
||
async def radio(self, ctx: commands.Context):
|
||
"""Browse and play radio stations with a two-step interactive picker."""
|
||
if not ctx.author.voice:
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="❌ Join a voice channel first.", color=C_ERR))
|
||
|
||
st = self.state(ctx.guild.id)
|
||
|
||
# Mode check: refuse if music is active
|
||
if st.mode == MODE_MUSIC and (st.current or st.queue):
|
||
return await ctx.reply(embed=discord.Embed(
|
||
description="🎵 Music is currently playing. Use `!stop` first to switch to radio.",
|
||
color=C_WARN))
|
||
|
||
# Step 1: show category buttons
|
||
view = _CategoryView(self.bot, self._radio_stations)
|
||
embed = discord.Embed(
|
||
title="📻 Radio — Choose a Category",
|
||
description="Select a genre to browse stations:",
|
||
color=C_RADIO,
|
||
)
|
||
await ctx.reply(embed=embed, view=view)
|
||
|
||
# ── radio playback helper (called from _StationSelect callback) ──────────
|
||
async def _play_radio_stream(self, interaction: discord.Interaction, category: str, station: dict):
|
||
"""Connect, play a radio stream, and set mode. Called from the station picker callback."""
|
||
guild = interaction.guild
|
||
if guild is None:
|
||
return
|
||
|
||
member = guild.get_member(interaction.user.id)
|
||
if member is None or member.voice is None:
|
||
await interaction.followup.send(
|
||
embed=discord.Embed(description="❌ You must be in a voice channel.", color=C_ERR),
|
||
ephemeral=True,
|
||
)
|
||
return
|
||
|
||
st = self.state(guild.id)
|
||
|
||
async with self._lock(guild.id):
|
||
# Re-check mode — music may have started between !radio and now
|
||
if st.mode == MODE_MUSIC:
|
||
await interaction.followup.send(
|
||
embed=discord.Embed(
|
||
description="🎵 Music is currently playing. Use `!stop` first to switch to radio.",
|
||
color=C_WARN,
|
||
),
|
||
ephemeral=True,
|
||
)
|
||
return
|
||
|
||
# Connect or reuse existing player
|
||
vc = guild.voice_client
|
||
if not isinstance(vc, wavelink.Player):
|
||
try:
|
||
vc = await member.voice.channel.connect(cls=wavelink.Player)
|
||
except Exception as e:
|
||
await interaction.followup.send(
|
||
embed=discord.Embed(description=f"❌ Failed to connect: {e}", color=C_ERR),
|
||
ephemeral=True,
|
||
)
|
||
return
|
||
vc.autoplay = wavelink.AutoPlayMode.disabled
|
||
vc.inactive_timeout = None
|
||
self._voice_channels[guild.id] = member.voice.channel.id
|
||
|
||
# Clear mode before skipping so the old track_end handler
|
||
# doesn't interfere with the new station's state
|
||
if vc.playing or vc.paused:
|
||
st.mode = None
|
||
st.current = None
|
||
await vc.skip()
|
||
|
||
# Resolve and play the stream URL via Lavalink
|
||
try:
|
||
results = await wavelink.Playable.search(station["url"])
|
||
if not results:
|
||
await interaction.followup.send(
|
||
embed=discord.Embed(
|
||
description=f"❌ Could not resolve stream: `{station['url']}`\n"
|
||
"Lavalink may need the **LavaSrc** plugin for direct HTTP/Icecast URLs.",
|
||
color=C_ERR,
|
||
),
|
||
ephemeral=True,
|
||
)
|
||
return
|
||
track = results[0]
|
||
except Exception as e:
|
||
await interaction.followup.send(
|
||
embed=discord.Embed(description=f"❌ Failed to load stream: {e}", color=C_ERR),
|
||
ephemeral=True,
|
||
)
|
||
return
|
||
|
||
# Set radio state *before* play so on_wavelink_track_start
|
||
# sees MODE_RADIO and doesn't overwrite our status text
|
||
st.queue.clear()
|
||
st.current = track
|
||
st.loop = LOOP_OFF
|
||
st.autoplay = False
|
||
st.mode = MODE_RADIO
|
||
self._radio_channels[guild.id] = interaction.channel_id
|
||
|
||
try:
|
||
await vc.play(track)
|
||
except Exception as e:
|
||
st.mode = None
|
||
self._radio_channels.pop(guild.id, None)
|
||
await interaction.followup.send(
|
||
embed=discord.Embed(description=f"❌ Failed to play stream: {e}", color=C_ERR),
|
||
ephemeral=True,
|
||
)
|
||
return
|
||
|
||
# Set channel status with the JSON station name
|
||
await self._set_channel_status(vc, title=station["name"])
|
||
|
||
# Send now-playing embed
|
||
embed = discord.Embed(
|
||
title="📻 Now Playing",
|
||
description=f"### {station['name']}",
|
||
color=C_RADIO,
|
||
)
|
||
if station["desc"]:
|
||
embed.add_field(name="Description", value=station["desc"], inline=False)
|
||
embed.add_field(name="Category", value=category, inline=True)
|
||
embed.add_field(name="Source", value=station["url"], inline=True)
|
||
embed.set_footer(text="yuuka radio · use !stop to disconnect")
|
||
await interaction.followup.send(embed=embed)
|
||
|
||
# ── !music ────────────────────────────────────────────────────────────────
|
||
@commands.command()
|
||
async def music(self, ctx: commands.Context):
|
||
"""List all music commands."""
|
||
embed = discord.Embed(title="🎵 Music Commands", color=C_MAIN)
|
||
embed.add_field(name="Playback", value=(
|
||
"`!play <query/url>` · `!p`\n"
|
||
"`!pause` · `!resume` · `!skip` · `!stop`\n"
|
||
"`!seek <1:30>` · `!looptrack` · `!loopqueue`\n"
|
||
"`!autoplay`"
|
||
), inline=False)
|
||
embed.add_field(name="Radio", value=(
|
||
"`!radio` — Browse & play radio stations\n"
|
||
"Use `!stop` to stop either music or radio"
|
||
), inline=False)
|
||
embed.add_field(name="Queue", value=(
|
||
"`!queue` · `!q`\n"
|
||
"`!remove <pos>` · `!move <from> <to>`\n"
|
||
"`!shuffle` · `!clear`"
|
||
), inline=False)
|
||
embed.add_field(name="Info", value=(
|
||
"`!nowplaying` · `!np`\n"
|
||
"`!history` · `!h`"
|
||
), inline=False)
|
||
embed.set_footer(text="🎧 DJ role required for control commands")
|
||
await ctx.reply(embed=embed)
|
||
|
||
|
||
async def setup(bot: commands.Bot):
|
||
await bot.add_cog(Music(bot))
|