Update app.py

app.py

@@ -1,11 +1,9 @@
 import gradio as gr
 from PIL import Image, ImageDraw
 import random
+time
 
 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):
@@ -33,81 +31,65 @@ def get_flips(board, row, col, player):
         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
+            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
+    if not flips: return False
     board[row][col] = player
-    for r, c in flips:
-        board[r][c] = 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
+    cell = 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')
+            x0, y0 = c*cell, r*cell; x1, y1 = x0+cell, y0+cell
+            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
+    b = sum(cell==-1 for row in board for cell in row)
+    w = sum(cell==1 for row in board for cell in row)
+    return b, w
 
-def play_move(x, y, state):
+def click_handler(evt: gr.SelectData, 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
+    x, y = evt.index
+    cell = 320/8
+    r, c = int(y//cell), int(x//cell)
+    if not (0<=r<8 and 0<=c<8):
+        yield board_to_image(board), "ボード上をクリックしてください。", state
+        return
+    if not apply_move(board, r, c, player):
+        yield board_to_image(board), f"({r+1},{c+1})には置けません。", state
+        return
+    b,w = count_score(board)
+    commentary = f"あなたは({r+1},{c+1})に石を置きました。\n現在：黒{b} - 白{w}。AIの思考中…"
     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
+    yield board_to_image(board), commentary, (board, player)
+    time.sleep(2)
+    ai_mv = choose_move(board, player)
+    if ai_mv:
+        apply_move(board, ai_mv[0], ai_mv[1], player)
+        b,w = count_score(board)
+        commentary = f"AIは({ai_mv[0]+1},{ai_mv[1]+1})に石を置きました。\n現在：黒{b} - 白{w}。{'あなた' if player==-1 else 'AI'}の番です。"
+    else:
+        commentary = "AIはパスしました。あなたの番です。"
+    player = -player
+    yield board_to_image(board), commentary, (board, player)
 
-        image_box.select(click_handler, inputs=[state], outputs=[image_box, status, state])
+with gr.Blocks() as demo:
+    gr.HTML("<h2>オセロ（リバーシ）</h2>")
+    state = gr.State((initialize_board(), -1))
+    board_img = gr.Image(value=board_to_image(initialize_board()), interactive=True)
+    commentary = gr.Markdown("黒2 - 白2。黒の番です。")
+    board_img.select(click_handler, inputs=[state], outputs=[board_img, commentary, state])
     demo.launch()
-
-if __name__ == "__main__":
-    main()