| from __future__ import annotations
|
|
|
| import random
|
| from dataclasses import dataclass
|
|
|
| import discord
|
| from discord.ext import commands
|
| from bot.i18n import get_cmd_desc
|
| from bot.emojis import ui
|
|
|
| FILES = "abcdefgh"
|
|
|
|
|
| @dataclass
|
| class BoardGameSession:
|
| game: str
|
| players: tuple[int, int]
|
| turn: int
|
| board: list[list[str]]
|
| tournament_name: str | None = None
|
|
|
|
|
|
|
|
|
| class BoardMoveModal(discord.ui.Modal, title="Play Move"):
|
| move = discord.ui.TextInput(label="Move", placeholder="e2e4 / d3 / 4", max_length=10)
|
|
|
| def __init__(self, cog: "BoardGames") -> None:
|
| super().__init__(timeout=None)
|
| self.cog = cog
|
|
|
| async def on_submit(self, interaction: discord.Interaction) -> None:
|
| if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
|
| await interaction.response.send_message("Server text channels only.", ephemeral=True)
|
| return
|
| err = await self.cog._play_turn(
|
| guild=interaction.guild,
|
| channel=interaction.channel,
|
| author_id=interaction.user.id,
|
| move=str(self.move.value).strip(),
|
| )
|
| if err:
|
| await interaction.response.send_message(err, ephemeral=True)
|
| else:
|
| await interaction.response.send_message("✅ Move accepted.", ephemeral=True)
|
|
|
|
|
| class BoardActionView(discord.ui.View):
|
| def __init__(self, cog: "BoardGames") -> None:
|
| super().__init__(timeout=None)
|
| self.cog = cog
|
|
|
| @discord.ui.button(label="Play Move", style=discord.ButtonStyle.primary, emoji=ui("controller"), custom_id="board_play")
|
| async def play_move(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| await interaction.response.send_modal(BoardMoveModal(self.cog))
|
|
|
| @discord.ui.button(label="Forfeit", style=discord.ButtonStyle.danger, emoji=ui("no"), custom_id="board_forfeit")
|
| async def forfeit(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
|
| await interaction.response.send_message("Server text channels only.", ephemeral=True)
|
| return
|
| err = await self.cog._forfeit(
|
| guild=interaction.guild,
|
| channel=interaction.channel,
|
| author_id=interaction.user.id,
|
| )
|
| if err:
|
| await interaction.response.send_message(err, ephemeral=True)
|
| return
|
| await interaction.response.send_message("🏳️ Forfeit processed.", ephemeral=True)
|
|
|
| @discord.ui.button(label="End Game", style=discord.ButtonStyle.danger, emoji=ui("lock"), custom_id="board_end")
|
| async def end_game(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
|
| await interaction.response.send_message("Server text channels only.", ephemeral=True)
|
| return
|
| session = self.cog.sessions.get(interaction.channel.id)
|
| if not session:
|
| await interaction.response.send_message("No active board game in this channel.", ephemeral=True)
|
| return
|
| if interaction.user.id not in session.players and not interaction.user.guild_permissions.manage_channels:
|
| await interaction.response.send_message("Only players/admins can end this game.", ephemeral=True)
|
| return
|
| self.cog.sessions.pop(interaction.channel.id, None)
|
| await interaction.response.send_message("🔒 Game session ended.", ephemeral=True)
|
| if interaction.channel.name.startswith("game-"):
|
| try:
|
| await interaction.channel.delete(reason=f"Game room closed by {interaction.user}")
|
| except Exception:
|
| pass
|
|
|
|
|
| class Connect4ActionView(BoardActionView):
|
| def __init__(self, cog: "BoardGames") -> None:
|
| super().__init__(cog)
|
| self.clear_items()
|
| for col in range(1, 8):
|
| button = discord.ui.Button(label=str(col), style=discord.ButtonStyle.secondary, row=0 if col <= 4 else 1)
|
|
|
| async def _drop(interaction: discord.Interaction, c: int = col) -> None:
|
| if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
|
| await interaction.response.send_message("Server text channels only.", ephemeral=True)
|
| return
|
| err = await self.cog._play_turn(
|
| guild=interaction.guild,
|
| channel=interaction.channel,
|
| author_id=interaction.user.id,
|
| move=str(c),
|
| )
|
| if err:
|
| await interaction.response.send_message(err, ephemeral=True)
|
| else:
|
| await interaction.response.send_message(f"✅ Dropped in column {c}", ephemeral=True)
|
|
|
| button.callback = _drop
|
| self.add_item(button)
|
|
|
| forfeit_btn = discord.ui.Button(label="Forfeit", style=discord.ButtonStyle.danger, emoji=ui("no"), row=2, custom_id="board_forfeit_c4")
|
| end_btn = discord.ui.Button(label="End Game", style=discord.ButtonStyle.danger, emoji=ui("lock"), row=2, custom_id="board_end_c4")
|
|
|
| async def _forfeit(interaction: discord.Interaction) -> None:
|
| if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
|
| await interaction.response.send_message("Server text channels only.", ephemeral=True)
|
| return
|
| err = await self.cog._forfeit(guild=interaction.guild, channel=interaction.channel, author_id=interaction.user.id)
|
| if err:
|
| await interaction.response.send_message(err, ephemeral=True)
|
| return
|
| await interaction.response.send_message("🏳️ Forfeit processed.", ephemeral=True)
|
|
|
| forfeit_btn.callback = _forfeit
|
| self.add_item(forfeit_btn)
|
|
|
| async def _end(interaction: discord.Interaction) -> None:
|
| if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
|
| await interaction.response.send_message("Server text channels only.", ephemeral=True)
|
| return
|
| session = self.cog.sessions.get(interaction.channel.id)
|
| if not session:
|
| await interaction.response.send_message("No active board game in this channel.", ephemeral=True)
|
| return
|
| if interaction.user.id not in session.players and not interaction.user.guild_permissions.manage_channels:
|
| await interaction.response.send_message("Only players/admins can end this game.", ephemeral=True)
|
| return
|
| self.cog.sessions.pop(interaction.channel.id, None)
|
| await interaction.response.send_message("🔒 Game session ended.", ephemeral=True)
|
| if interaction.channel.name.startswith("game-"):
|
| try:
|
| await interaction.channel.delete(reason=f"Game room closed by {interaction.user}")
|
| except Exception:
|
| pass
|
|
|
| end_btn.callback = _end
|
| self.add_item(end_btn)
|
|
|
|
|
| import random as _random
|
|
|
|
|
| class QuickRPSView(discord.ui.View):
|
| def __init__(self) -> None:
|
| super().__init__(timeout=60)
|
|
|
| @discord.ui.button(label="Rock 🪨", style=discord.ButtonStyle.primary)
|
| async def rock(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| await self._resolve(interaction, "rock")
|
|
|
| @discord.ui.button(label="Paper 📄", style=discord.ButtonStyle.primary)
|
| async def paper(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| await self._resolve(interaction, "paper")
|
|
|
| @discord.ui.button(label="Scissors ✂️", style=discord.ButtonStyle.primary)
|
| async def scissors(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| await self._resolve(interaction, "scissors")
|
|
|
| async def _resolve(self, interaction: discord.Interaction, choice: str) -> None:
|
| bot_choice = _random.choice(["rock", "paper", "scissors"])
|
| emoji_map = {"rock": "🪨", "paper": "📄", "scissors": "✂️"}
|
| result_map = {("rock", "scissors"): "win", ("paper", "rock"): "win", ("scissors", "paper"): "win"}
|
| if choice == bot_choice:
|
| result = "🤝 Tie!"
|
| elif (choice, bot_choice) in result_map:
|
| result = "🎉 You win!"
|
| else:
|
| result = "💀 You lose!"
|
| await interaction.response.send_message(f"You: {emoji_map[choice]} | Bot: {emoji_map[bot_choice]}\n{result}", ephemeral=True)
|
| self.stop()
|
|
|
|
|
| class GamePanelView(discord.ui.View):
|
| def __init__(self, cog: "BoardGames") -> None:
|
| super().__init__(timeout=None)
|
| self.cog = cog
|
|
|
| async def _start(self, interaction: discord.Interaction, game: str) -> None:
|
| if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
|
| await interaction.response.send_message("Server text channels only.", ephemeral=True)
|
| return
|
| ok = await self.cog.start_game_session_interaction(interaction, game)
|
| if ok:
|
| await interaction.response.send_message(f"✅ Started **{game}** vs bot.", ephemeral=True)
|
|
|
| @discord.ui.button(label="Chess", style=discord.ButtonStyle.primary, emoji=ui("chess"), row=0, custom_id="board_chess")
|
| async def chess(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| await self._start(interaction, "chess")
|
|
|
| @discord.ui.button(label="Checkers", style=discord.ButtonStyle.secondary, emoji=ui("joystick"), row=0, custom_id="board_checkers")
|
| async def checkers(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| await self._start(interaction, "checkers")
|
|
|
| @discord.ui.button(label="Connect4", style=discord.ButtonStyle.success, emoji=ui("joystick"), row=0, custom_id="board_connect4")
|
| async def connect4(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| await self._start(interaction, "connect4")
|
|
|
| @discord.ui.button(label="Othello", style=discord.ButtonStyle.blurple, emoji=ui("joystick"), row=0, custom_id="board_othello")
|
| async def othello(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| await self._start(interaction, "othello")
|
|
|
| @discord.ui.button(label="TicTacToe", style=discord.ButtonStyle.primary, emoji=ui("x"), row=1, custom_id="board_tictactoe")
|
| async def tictactoe(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
|
| await interaction.response.send_message("Server text channels only.", ephemeral=True)
|
| return
|
| await interaction.response.send_message(f"❎ **TicTacToe**: {interaction.user.mention} vs 🤖 Bot\nUse `/xo` to play!", ephemeral=True)
|
|
|
| @discord.ui.button(label="Rock Paper Scissors", style=discord.ButtonStyle.secondary, emoji="✂️", row=1, custom_id="board_rps")
|
| async def rps(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
|
| if not interaction.guild:
|
| await interaction.response.send_message("Server only.", ephemeral=True)
|
| return
|
| await interaction.response.send_message(
|
| "Choose your move:",
|
| view=QuickRPSView(),
|
| ephemeral=True,
|
| )
|
|
|
|
|
| class BoardGames(commands.Cog):
|
| def __init__(self, bot: commands.Bot) -> None:
|
| self.bot = bot
|
| self.sessions: dict[int, BoardGameSession] = {}
|
|
|
| async def cog_load(self) -> None:
|
| self.bot.add_view(GamePanelView(self))
|
| self.bot.add_view(BoardActionView(self))
|
|
|
| def _coord(self, token: str) -> tuple[int, int] | None:
|
| token = token.strip().lower()
|
| if len(token) != 2 or token[0] not in FILES or token[1] not in "12345678":
|
| return None
|
| x = FILES.index(token[0])
|
| y = 8 - int(token[1])
|
| return y, x
|
|
|
| def _coord_to_text(self, y: int, x: int) -> str:
|
| return f"{FILES[x]}{8-y}"
|
|
|
| def _current_player(self, s: BoardGameSession) -> int:
|
| return s.players[s.turn]
|
|
|
| def _render(self, s: BoardGameSession) -> str:
|
| if s.game == "connect4":
|
| lines = ["1️⃣2️⃣3️⃣4️⃣5️⃣6️⃣7️⃣"]
|
| for row in s.board:
|
| lines.append("".join(row))
|
| return "\n".join(lines)
|
| if s.game == "othello":
|
| lines = ["⬛🇦🇧🇨🇩🇪🇫🇬🇭"]
|
| for y, row in enumerate(s.board):
|
| lines.append(f"{8-y}️⃣" + "".join(row))
|
| return "\n".join(lines)
|
| lines = [" 🇦 🇧 🇨 🇩 🇪 🇫 🇬 🇭"]
|
| for y, row in enumerate(s.board):
|
| lines.append(f"{8-y} " + " ".join(row))
|
| return "\n".join(lines)
|
|
|
| def _make_chess(self) -> list[list[str]]:
|
| return [
|
| list("♜♞♝♛♚♝♞♜"),
|
| list("♟♟♟♟♟♟♟♟"),
|
| list("▫▫▫▫▫▫▫▫"),
|
| list("▫▫▫▫▫▫▫▫"),
|
| list("▫▫▫▫▫▫▫▫"),
|
| list("▫▫▫▫▫▫▫▫"),
|
| list("♙♙♙♙♙♙♙♙"),
|
| list("♖♘♗♕♔♗♘♖"),
|
| ]
|
|
|
| def _make_checkers(self) -> list[list[str]]:
|
| board = [["▫" for _ in range(8)] for _ in range(8)]
|
| for y in range(3):
|
| for x in range(8):
|
| if (x + y) % 2 == 1:
|
| board[y][x] = "🔴"
|
| for y in range(5, 8):
|
| for x in range(8):
|
| if (x + y) % 2 == 1:
|
| board[y][x] = "⚪"
|
| return board
|
|
|
| def _make_connect4(self) -> list[list[str]]:
|
| return [["⚫" for _ in range(7)] for _ in range(6)]
|
|
|
| def _make_othello(self) -> list[list[str]]:
|
| b = [["🟩" for _ in range(8)] for _ in range(8)]
|
| b[3][3] = "⚪"
|
| b[3][4] = "⚫"
|
| b[4][3] = "⚫"
|
| b[4][4] = "⚪"
|
| return b
|
|
|
| async def _announce(self, ctx: commands.Context, s: BoardGameSession, text: str) -> None:
|
| p1 = f"<@{s.players[0]}>"
|
| p2 = "🤖 Bot" if s.players[1] == 0 else f"<@{s.players[1]}>"
|
| turn = self._current_player(s)
|
| tname = "🤖 Bot" if turn == 0 else f"<@{turn}>"
|
| await ctx.send(
|
| f"**{s.game.title()}** | {p1} vs {p2}\n{text}\nTurn: {tname}\n{self._render(s)}"
|
| )
|
|
|
| async def start_game_session(
|
| self,
|
| ctx: commands.Context,
|
| game: str,
|
| opponent: discord.Member | None = None,
|
| tournament_name: str | None = None,
|
| ) -> bool:
|
| game = game.lower().strip()
|
| if game not in {"chess", "checkers", "connect4", "othello"}:
|
| await ctx.reply("Supported: chess, checkers, connect4, othello")
|
| return False
|
| if ctx.channel.id in self.sessions:
|
| await ctx.reply("There is already an active board game in this channel.")
|
| return False
|
|
|
| opponent_id = opponent.id if opponent else 0
|
| if opponent_id == ctx.author.id:
|
| await ctx.reply("Choose another player or leave opponent empty for bot.")
|
| return False
|
|
|
| if game == "chess":
|
| board = self._make_chess()
|
| elif game == "checkers":
|
| board = self._make_checkers()
|
| elif game == "connect4":
|
| board = self._make_connect4()
|
| else:
|
| board = self._make_othello()
|
|
|
| s = BoardGameSession(game=game, players=(ctx.author.id, opponent_id), turn=0, board=board, tournament_name=tournament_name)
|
| self.sessions[ctx.channel.id] = s
|
| await self._announce(ctx.channel, s, "Game started. Use buttons or `/board_move`.")
|
| return True
|
|
|
| async def start_game_session_interaction(self, interaction: discord.Interaction, game: str) -> bool:
|
| if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
|
| return False
|
| game = game.lower().strip()
|
| if game not in {"chess", "checkers", "connect4", "othello"}:
|
| await interaction.followup.send("Supported: chess, checkers, connect4, othello", ephemeral=True)
|
| return False
|
| if interaction.channel.id in self.sessions:
|
| await interaction.followup.send("There is already an active board game in this channel.", ephemeral=True)
|
| return False
|
|
|
| if game == "chess":
|
| board = self._make_chess()
|
| elif game == "checkers":
|
| board = self._make_checkers()
|
| elif game == "connect4":
|
| board = self._make_connect4()
|
| else:
|
| board = self._make_othello()
|
|
|
| s = BoardGameSession(game=game, players=(interaction.user.id, 0), turn=0, board=board)
|
| self.sessions[interaction.channel.id] = s
|
| await self._announce(interaction.channel, s, "Game started from panel.")
|
| return True
|
|
|
| async def start_tournament_duel(
|
| self,
|
| ctx: commands.Context,
|
| game: str,
|
| player1: discord.Member,
|
| player2: discord.Member | None,
|
| tournament_name: str,
|
| ) -> bool:
|
| if ctx.channel.id in self.sessions:
|
| await ctx.reply("There is already an active board game in this channel.")
|
| return False
|
| game = game.lower().strip()
|
| if game == "chess":
|
| board = self._make_chess()
|
| elif game == "checkers":
|
| board = self._make_checkers()
|
| elif game == "connect4":
|
| board = self._make_connect4()
|
| elif game == "othello":
|
| board = self._make_othello()
|
| else:
|
| await ctx.reply("Supported: chess, checkers, connect4, othello")
|
| return False
|
|
|
| s = BoardGameSession(
|
| game=game,
|
| players=(player1.id, player2.id if player2 else 0),
|
| turn=0,
|
| board=board,
|
| tournament_name=tournament_name,
|
| )
|
| self.sessions[ctx.channel.id] = s
|
| await self._announce(ctx.channel, s, f"Tournament duel: **{tournament_name}**")
|
| return True
|
|
|
|
|
| def _in_bounds(self, y: int, x: int) -> bool:
|
| return 0 <= y < 8 and 0 <= x < 8
|
|
|
| def _is_white(self, p: str) -> bool:
|
| return p in "♙♖♘♗♕♔"
|
|
|
| def _is_black(self, p: str) -> bool:
|
| return p in "♟♜♞♝♛♚"
|
|
|
| def _enemy(self, p: str, white_turn: bool) -> bool:
|
| return self._is_black(p) if white_turn else self._is_white(p)
|
|
|
| def _friend(self, p: str, white_turn: bool) -> bool:
|
| return self._is_white(p) if white_turn else self._is_black(p)
|
|
|
| def _chess_legal(self, b: list[list[str]], src: tuple[int, int], dst: tuple[int, int], white_turn: bool) -> bool:
|
| sy, sx = src
|
| dy, dx = dst
|
| if not (self._in_bounds(sy, sx) and self._in_bounds(dy, dx)):
|
| return False
|
| piece = b[sy][sx]
|
| if piece == "▫" or not self._friend(piece, white_turn):
|
| return False
|
| target = b[dy][dx]
|
| if target != "▫" and self._friend(target, white_turn):
|
| return False
|
|
|
| vy = dy - sy
|
| vx = dx - sx
|
| ady, adx = abs(vy), abs(vx)
|
|
|
| def clear_line(stepy: int, stepx: int) -> bool:
|
| y, x = sy + stepy, sx + stepx
|
| while (y, x) != (dy, dx):
|
| if b[y][x] != "▫":
|
| return False
|
| y += stepy
|
| x += stepx
|
| return True
|
|
|
| if piece in "♙♟":
|
| direction = -1 if piece == "♙" else 1
|
| start_row = 6 if piece == "♙" else 1
|
| if vx == 0 and target == "▫":
|
| if vy == direction:
|
| return True
|
| if sy == start_row and vy == 2 * direction and b[sy + direction][sx] == "▫":
|
| return True
|
| if adx == 1 and vy == direction and target != "▫" and self._enemy(target, white_turn):
|
| return True
|
| return False
|
| if piece in "♖♜":
|
| if sx == dx and clear_line(1 if vy > 0 else -1, 0):
|
| return True
|
| if sy == dy and clear_line(0, 1 if vx > 0 else -1):
|
| return True
|
| return False
|
| if piece in "♗♝":
|
| if adx == ady and clear_line(1 if vy > 0 else -1, 1 if vx > 0 else -1):
|
| return True
|
| return False
|
| if piece in "♕♛":
|
| if sx == dx and clear_line(1 if vy > 0 else -1, 0):
|
| return True
|
| if sy == dy and clear_line(0, 1 if vx > 0 else -1):
|
| return True
|
| if adx == ady and clear_line(1 if vy > 0 else -1, 1 if vx > 0 else -1):
|
| return True
|
| return False
|
| if piece in "♘♞":
|
| return (ady, adx) in {(1, 2), (2, 1)}
|
| if piece in "♔♚":
|
| return max(ady, adx) == 1
|
| return False
|
|
|
| def _checkers_legal(self, b: list[list[str]], src: tuple[int, int], dst: tuple[int, int], white_turn: bool) -> bool:
|
| sy, sx = src
|
| dy, dx = dst
|
| if not (self._in_bounds(sy, sx) and self._in_bounds(dy, dx)):
|
| return False
|
| me = "⚪" if white_turn else "🔴"
|
| enemy = "🔴" if white_turn else "⚪"
|
| if b[sy][sx] != me or b[dy][dx] != "▫":
|
| return False
|
| vy, vx = dy - sy, dx - sx
|
| direction = -1 if white_turn else 1
|
| if abs(vx) == 1 and vy == direction:
|
| return True
|
| if abs(vx) == 2 and vy == 2 * direction:
|
| my, mx = sy + direction, sx + (1 if vx > 0 else -1)
|
| return b[my][mx] == enemy
|
| return False
|
|
|
| def _apply_checkers_capture(self, b: list[list[str]], src: tuple[int, int], dst: tuple[int, int], white_turn: bool) -> None:
|
| sy, sx = src
|
| dy, dx = dst
|
| if abs(dy - sy) == 2:
|
| my, mx = (sy + dy) // 2, (sx + dx) // 2
|
| b[my][mx] = "▫"
|
|
|
| def _connect4_drop(self, b: list[list[str]], col: int, white_turn: bool) -> tuple[int, int] | None:
|
| token = "🔵" if white_turn else "🟠"
|
| for y in range(len(b) - 1, -1, -1):
|
| if b[y][col] == "⚫":
|
| b[y][col] = token
|
| return y, col
|
| return None
|
|
|
| def _has_four(self, b: list[list[str]], y: int, x: int) -> bool:
|
| token = b[y][x]
|
| if token == "⚫":
|
| return False
|
| dirs = [(1, 0), (0, 1), (1, 1), (1, -1)]
|
| h, w = len(b), len(b[0])
|
| for dy, dx in dirs:
|
| c = 1
|
| for sign in (1, -1):
|
| ny, nx = y, x
|
| while True:
|
| ny += dy * sign
|
| nx += dx * sign
|
| if not (0 <= ny < h and 0 <= nx < w) or b[ny][nx] != token:
|
| break
|
| c += 1
|
| if c >= 4:
|
| return True
|
| return False
|
|
|
| def _othello_flips(self, b: list[list[str]], y: int, x: int, black_turn: bool) -> list[tuple[int, int]]:
|
| me = "⚫" if black_turn else "⚪"
|
| enemy = "⚪" if black_turn else "⚫"
|
| if not self._in_bounds(y, x) or b[y][x] != "🟩":
|
| return []
|
| flips: list[tuple[int, int]] = []
|
| for dy in (-1, 0, 1):
|
| for dx in (-1, 0, 1):
|
| if dy == 0 and dx == 0:
|
| continue
|
| path: list[tuple[int, int]] = []
|
| ny, nx = y + dy, x + dx
|
| while self._in_bounds(ny, nx) and b[ny][nx] == enemy:
|
| path.append((ny, nx))
|
| ny += dy
|
| nx += dx
|
| if path and self._in_bounds(ny, nx) and b[ny][nx] == me:
|
| flips.extend(path)
|
| return flips
|
|
|
| async def _finish(self, ctx: commands.Context, winner_id: int | None, reason: str) -> None:
|
| s = self.sessions.pop(ctx.channel.id, None)
|
| if not s:
|
| return
|
| if winner_id is None:
|
| await ctx.send(f"🤝 Draw | {reason}")
|
| return
|
|
|
| if winner_id == 0:
|
| await ctx.send(f"🤖 Bot won | {reason}")
|
| return
|
|
|
| await ctx.send(f"🏆 Winner: <@{winner_id}> | {reason}")
|
| if s.tournament_name:
|
| await self.bot.db.execute(
|
| "UPDATE tournaments SET winner_id = ?, status = 'finished' WHERE guild_id = ? AND name = ?",
|
| winner_id,
|
| ctx.guild.id,
|
| s.tournament_name,
|
| )
|
|
|
| async def _bot_move(self, ctx: commands.Context) -> None:
|
| s = self.sessions.get(ctx.channel.id)
|
| if not s or s.players[1] != 0 or self._current_player(s) != 0:
|
| return
|
| if s.game == "connect4":
|
| valid = [c for c in range(7) if s.board[0][c] == "⚫"]
|
| col = random.choice(valid)
|
| spot = self._connect4_drop(s.board, col, white_turn=False)
|
| if spot and self._has_four(s.board, spot[0], spot[1]):
|
| await self._announce(ctx.channel, s, f"Bot played column {col + 1}.")
|
| await self._finish(ctx, 0, "Four in a row!")
|
| return
|
| s.turn = 0
|
| await self._announce(ctx.channel, s, f"Bot played column {col + 1}.")
|
| return
|
|
|
| if s.game == "othello":
|
| legal: list[tuple[int, int, list[tuple[int, int]]]] = []
|
| for y in range(8):
|
| for x in range(8):
|
| flips = self._othello_flips(s.board, y, x, black_turn=False)
|
| if flips:
|
| legal.append((y, x, flips))
|
| if not legal:
|
| s.turn = 0
|
| await self._announce(ctx.channel, s, "Bot has no valid move and passes.")
|
| return
|
| y, x, flips = random.choice(legal)
|
| s.board[y][x] = "⚪"
|
| for fy, fx in flips:
|
| s.board[fy][fx] = "⚪"
|
| s.turn = 0
|
| await self._announce(ctx.channel, s, f"Bot played {self._coord_to_text(y, x)}")
|
| return
|
|
|
|
|
| moves: list[tuple[tuple[int, int], tuple[int, int]]] = []
|
| for sy in range(8):
|
| for sx in range(8):
|
| for dy in range(8):
|
| for dx in range(8):
|
| if s.game == "chess":
|
| if self._chess_legal(s.board, (sy, sx), (dy, dx), white_turn=False):
|
| moves.append(((sy, sx), (dy, dx)))
|
| elif self._checkers_legal(s.board, (sy, sx), (dy, dx), white_turn=False):
|
| moves.append(((sy, sx), (dy, dx)))
|
| if not moves:
|
| await self._finish(ctx, s.players[0], "Bot has no legal moves.")
|
| return
|
| src, dst = random.choice(moves)
|
| sy, sx = src
|
| dy, dx = dst
|
| target = s.board[dy][dx]
|
| if s.game == "checkers":
|
| self._apply_checkers_capture(s.board, src, dst, white_turn=False)
|
| s.board[dy][dx] = s.board[sy][sx]
|
| s.board[sy][sx] = "▫"
|
| s.turn = 0
|
| await self._announce(ctx.channel, s, f"Bot played {self._coord_to_text(sy, sx)}{self._coord_to_text(dy, dx)}")
|
| if s.game == "chess" and target == "♔":
|
| await self._finish(ctx, 0, "White king captured.")
|
|
|
| @commands.hybrid_command(name="boardgames", hidden=True, description=get_cmd_desc("commands.boardgames.boardgames_desc"), with_app_command=False)
|
| async def boardgames(self, ctx: commands.Context) -> None:
|
| embed = discord.Embed(title="Board Games", color=discord.Color.blurple())
|
| embed.description = (
|
| "• chess\n"
|
| "• checkers\n"
|
| "• connect4\n"
|
| "• othello\n\n"
|
| "Use `/board_start <game> [opponent]` then `/board_move`"
|
| )
|
| await ctx.reply(embed=embed)
|
|
|
| @commands.hybrid_command(name="board_start", hidden=True, description=get_cmd_desc("commands.boardgames.board_start_desc"), with_app_command=False)
|
| async def board_start(self, ctx: commands.Context, game: str, opponent: discord.Member | None = None) -> None:
|
| await self.start_game_session(ctx, game, opponent)
|
|
|
| @commands.hybrid_command(name="chess", hidden=True, description=get_cmd_desc("commands.boardgames.chess_desc"), with_app_command=False)
|
| async def chess(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
|
| await self.start_game_session(ctx, "chess", opponent)
|
|
|
| @commands.hybrid_command(name="checkers", hidden=True, description=get_cmd_desc("commands.boardgames.checkers_desc"), with_app_command=False)
|
| async def checkers(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
|
| await self.start_game_session(ctx, "checkers", opponent)
|
|
|
| @commands.hybrid_command(name="connect4", hidden=True, description=get_cmd_desc("commands.boardgames.connect4_desc"), with_app_command=False)
|
| async def connect4(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
|
| await self.start_game_session(ctx, "connect4", opponent)
|
|
|
| @commands.hybrid_command(name="othello", hidden=True, description=get_cmd_desc("commands.boardgames.othello_desc"), with_app_command=False)
|
| async def othello(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
|
| await self.start_game_session(ctx, "othello", opponent)
|
|
|
| async def _play_turn(self, *, guild: discord.Guild, channel: discord.TextChannel, author_id: int, move: str) -> str | None:
|
| s = self.sessions.get(channel.id)
|
| if not s:
|
| return "No active board game in this channel."
|
| if self._current_player(s) != author_id:
|
| return "Not your turn."
|
|
|
| is_first_player = author_id == s.players[0]
|
|
|
| if s.game == "connect4":
|
| try:
|
| col = int(move) - 1
|
| except ValueError:
|
| return "Connect4 move is column number 1-7"
|
| if not 0 <= col < 7:
|
| return "Column must be 1-7"
|
| spot = self._connect4_drop(s.board, col, white_turn=is_first_player)
|
| if not spot:
|
| return "Column is full."
|
| if self._has_four(s.board, spot[0], spot[1]):
|
| await self._announce(channel, s, f"Move: {col + 1}")
|
| winner = author_id if author_id != 0 else None
|
| await self._finish_ctxless(guild, channel, winner, "Four in a row!")
|
| return None
|
| if all(s.board[0][i] != "⚫" for i in range(7)):
|
| await self._announce(channel, s, f"Move: {col + 1}")
|
| await self._finish_ctxless(guild, channel, None, "Board full")
|
| return None
|
| s.turn = 1 - s.turn
|
| await self._announce(channel, s, f"Move: {col + 1}")
|
| if s.players[1] == 0:
|
| await self._bot_move_channel(guild, channel)
|
| return None
|
|
|
| if s.game == "othello":
|
| c = self._coord(move)
|
| if not c:
|
| return "Use coordinate like d3"
|
| y, x = c
|
| black_turn = is_first_player
|
| flips = self._othello_flips(s.board, y, x, black_turn=black_turn)
|
| if not flips:
|
| return "Illegal move."
|
| s.board[y][x] = "⚫" if black_turn else "⚪"
|
| for fy, fx in flips:
|
| s.board[fy][fx] = "⚫" if black_turn else "⚪"
|
| s.turn = 1 - s.turn
|
| await self._announce(channel, s, f"Move: {move.lower()}")
|
| if s.players[1] == 0:
|
| await self._bot_move_channel(guild, channel)
|
| return None
|
|
|
| if len(move) != 4:
|
| return "Use move format like e2e4"
|
| src = self._coord(move[:2])
|
| dst = self._coord(move[2:])
|
| if not src or not dst:
|
| return "Invalid coordinates. Example: e2e4"
|
|
|
| legal = self._chess_legal(s.board, src, dst, white_turn=is_first_player) if s.game == "chess" else self._checkers_legal(s.board, src, dst, white_turn=is_first_player)
|
| if not legal:
|
| return "Illegal move."
|
|
|
| sy, sx = src
|
| dy, dx = dst
|
| target = s.board[dy][dx]
|
| if s.game == "checkers":
|
| self._apply_checkers_capture(s.board, src, dst, white_turn=is_first_player)
|
| piece = s.board[sy][sx]
|
| s.board[dy][dx] = piece
|
| s.board[sy][sx] = "▫"
|
| if piece == "♙" and dy == 0:
|
| s.board[dy][dx] = "♕"
|
| if piece == "♟" and dy == 7:
|
| s.board[dy][dx] = "♛"
|
|
|
| if s.game == "chess" and target in {"♚", "♔"}:
|
| await self._announce(channel, s, f"Move: {move.lower()}")
|
| await self._finish_ctxless(guild, channel, author_id, "King captured.")
|
| return None
|
|
|
| s.turn = 1 - s.turn
|
| await self._announce(channel, s, f"Move: {move.lower()}")
|
| if s.players[1] == 0:
|
| await self._bot_move_channel(guild, channel)
|
| return None
|
|
|
| async def _finish_ctxless(self, guild: discord.Guild, channel: discord.TextChannel, winner_id: int | None, reason: str) -> None:
|
| s = self.sessions.pop(channel.id, None)
|
| if not s:
|
| return
|
| if winner_id is None:
|
| await channel.send(f"🤝 Draw | {reason}")
|
| return
|
| if winner_id == 0:
|
| await channel.send(f"🤖 Bot won | {reason}")
|
| return
|
| await channel.send(f"🏆 Winner: <@{winner_id}> | {reason}")
|
| if s.tournament_name:
|
| await self.bot.db.execute(
|
| "UPDATE tournaments SET winner_id = ?, status = 'finished' WHERE guild_id = ? AND name = ?",
|
| winner_id,
|
| guild.id,
|
| s.tournament_name,
|
| )
|
|
|
| async def _bot_move_channel(self, guild: discord.Guild, channel: discord.TextChannel) -> None:
|
| class Dummy:
|
| pass
|
| d=Dummy(); d.guild=guild; d.channel=channel
|
| await self._bot_move(d)
|
|
|
| async def _forfeit(self, *, guild: discord.Guild, channel: discord.TextChannel, author_id: int) -> str | None:
|
| s = self.sessions.get(channel.id)
|
| if not s:
|
| return "No active board game in this channel."
|
| if author_id not in s.players:
|
| return "Only players can forfeit."
|
| winner = s.players[1] if author_id == s.players[0] else s.players[0]
|
| await self._finish_ctxless(guild, channel, None if winner == 0 else winner, "Forfeit")
|
| return None
|
|
|
| @commands.hybrid_command(name="board_move", hidden=True, description=get_cmd_desc("commands.boardgames.board_move_desc"), with_app_command=False)
|
| async def board_move(self, ctx: commands.Context, move: str) -> None:
|
| if not ctx.guild or not isinstance(ctx.channel, discord.TextChannel):
|
| await ctx.reply("Server text channels only.")
|
| return
|
| err = await self._play_turn(guild=ctx.guild, channel=ctx.channel, author_id=ctx.author.id, move=move)
|
| if err:
|
| await ctx.reply(err)
|
|
|
| @commands.hybrid_command(name="games_panel", hidden=True, description=get_cmd_desc("commands.boardgames.games_panel_desc"), with_app_command=False)
|
| async def games_panel(self, ctx: commands.Context) -> None:
|
| await ctx.reply("<:animatedarrowgreen:1477261279428087979> This panel is deprecated. Use `/gamehub` for the improved game experience.")
|
|
|
| @commands.hybrid_command(name="board_forfeit", hidden=True, description=get_cmd_desc("commands.boardgames.board_forfeit_desc"), with_app_command=False)
|
| async def board_forfeit(self, ctx: commands.Context) -> None:
|
| if not ctx.guild or not isinstance(ctx.channel, discord.TextChannel):
|
| await ctx.reply("Server text channels only.")
|
| return
|
| err = await self._forfeit(guild=ctx.guild, channel=ctx.channel, author_id=ctx.author.id)
|
| if err:
|
| await ctx.reply(err)
|
|
|
|
|
| async def setup(bot: commands.Bot) -> None:
|
| await bot.add_cog(BoardGames(bot))
|
|
|
