File size: 4,115 Bytes
c4367ba 6ad4064 edf941b c4367ba 34d6098 c4367ba 34d6098 c4367ba 6ad4064 c4367ba 6ad4064 c4367ba 34d6098 c4367ba 6ad4064 34d6098 c4367ba 6ad4064 c4367ba 6ad4064 c4367ba 34d6098 c4367ba 34d6098 b75074b 34d6098 c4367ba 34d6098 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 |
import gradio as gr
from PIL import Image, ImageDraw
import random
def choose_move(board, player):
"""
Simple AI: chooses a random valid move from all legal flips.
"""
valid_moves = []
for r in range(8):
for c in range(8):
if get_flips(board, r, c, player):
valid_moves.append((r, c))
if not valid_moves:
return None
return random.choice(valid_moves)
def initialize_board():
board = [[0 for _ in range(8)] for _ in range(8)]
board[3][3], board[4][4] = 1, 1
board[3][4], board[4][3] = -1, -1
return board
DIRECTIONS = [(-1, -1), (-1, 0), (-1, 1),
(0, -1), (0, 1),
(1, -1), (1, 0), (1, 1)]
def get_flips(board, row, col, player):
if board[row][col] != 0:
return []
flips = []
for dr, dc in DIRECTIONS:
r, c = row + dr, col + dc
buffer = []
while 0 <= r < 8 and 0 <= c < 8 and board[r][c] == -player:
buffer.append((r, c))
r += dr
c += dc
if buffer and 0 <= r < 8 and 0 <= c < 8 and board[r][c] == player:
flips.extend(buffer)
return flips
def apply_move(board, row, col, player):
flips = get_flips(board, row, col, player)
if not flips:
return False
board[row][col] = player
for r, c in flips:
board[r][c] = player
return True
def board_to_image(board, img_size=320):
cell_size = img_size // 8
img = Image.new('RGB', (img_size, img_size), 'green')
draw = ImageDraw.Draw(img)
for r in range(8):
for c in range(8):
x0, y0 = c * cell_size, r * cell_size
x1, y1 = x0 + cell_size, y0 + cell_size
draw.rectangle([x0, y0, x1, y1], outline='black')
if board[r][c] == 1:
draw.ellipse([x0+4, y0+4, x1-4, y1-4], fill='white')
elif board[r][c] == -1:
draw.ellipse([x0+4, y0+4, x1-4, y1-4], fill='black')
return img
def count_score(board):
black = sum(cell == -1 for row in board for cell in row)
white = sum(cell == 1 for row in board for cell in row)
return black, white
def play_move(x, y, state):
board, player = state
img_size = 320
cell_size = img_size / 8
col, row = int(x // cell_size), int(y // cell_size)
if not (0 <= row < 8 and 0 <= col < 8):
return board_to_image(board), f"Click inside the board.", state
if not apply_move(board, row, col, player):
return board_to_image(board), f"Invalid move at ({row+1},{col+1})", state
player = -player
black_score, white_score = count_score(board)
status = f"Black: {black_score} | White: {white_score} | {'Black' if player == -1 else 'White'} to move"
return board_to_image(board), status, (board, player)
def main():
with gr.Blocks() as demo:
gr.HTML("<h2>Othello (Reversi) Game</h2>")
state = gr.State((initialize_board(), -1))
image_box = gr.Image(value=board_to_image(initialize_board()), interactive=True, label="Click to place a stone")
status = gr.Text(value="Black: 2 | White: 2 | Black to move", interactive=False)
def click_handler(evt: gr.SelectData, state):
# ユーザーの手
board_img, status_text, state = play_move(evt.index[0], evt.index[1], state)
board, player = state
# AI（White）が動く
if player == 1:
ai_move = choose_move(board, player)
if ai_move:
apply_move(board, ai_move[0], ai_move[1], player)
player = -player
black_score, white_score = count_score(board)
status_text = f"Black: {black_score} | White: {white_score} | {'Black' if player == -1 else 'White'} to move"
board_img = board_to_image(board)
state = (board, player)
return board_img, status_text, state
image_box.select(click_handler, inputs=[state], outputs=[image_box, status, state])
demo.launch()
if __name__ == "__main__":
main() |