Update app.py

app.py

@@ -1,95 +1,95 @@
 import gradio as gr
-from PIL import Image, ImageDraw
+from PIL import Image, ImageDraw, ImageFont
 import random
 import time
 
 def choose_move(board, player):
-    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)
+    moves = [(r,c) for r in range(8) for c in range(8) if get_flips(board, r, c, player)]
+    return random.choice(moves) if moves else None
 
 def initialize_board():
-    board = [[0 for _ in range(8)] for _ in range(8)]
+    board = [[0]*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)]
+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)
+def get_flips(board, r, c, p):
+    if board[r][c]!=0: return []
+    flips=[]
+    for dr,dc in DIRECTIONS:
+        rr,cc=r+dr,c+dc; buf=[]
+        while 0<=rr<8 and 0<=cc<8 and board[rr][cc]==-p:
+            buf.append((rr,cc)); rr+=dr; cc+=dc
+        if buf and 0<=rr<8 and 0<=cc<8 and board[rr][cc]==p:
+            flips+=buf
     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
+def apply_move(board,r,c,p):
+    f=get_flips(board,r,c,p)
+    if not f: return False
+    board[r][c]=p
+    for rr,cc in f: board[rr][cc]=p
     return True
 
-def board_to_image(board, img_size=320):
-    cell = img_size // 8
-    img = Image.new('RGB', (img_size, img_size), 'green')
-    draw = ImageDraw.Draw(img)
+def count_score(board):
+    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 board_to_image(board, last_user, last_ai, player):
+    size=360; cell=size//8
+    img=Image.new('RGB',(size,size+cell),'darkgreen'); d=ImageDraw.Draw(img)
+    # スコアボード
+    b,w=count_score(board)
+    d.rectangle([0,0,size,cell],fill='navy')
+    fnt=ImageFont.load_default()
+    d.text((10,2),f"黒: {b}",font=fnt,fill='yellow')
+    d.text((size-60,2),f"白: {w}",font=fnt,fill='yellow')
+    # 盤面
     for r in range(8):
         for c in range(8):
-            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')
+            x0,y0=c*cell,cell+r*cell; x1,y1=x0+cell,y0+cell
+            d.rectangle([x0,y0,x1,y1],outline='black')
+            # 候補手
+            if board[r][c]==0 and get_flips(board,r,c,player):
+                d.ellipse([x0+cell*0.4,y0+cell*0.4,x0+cell*0.6,y0+cell*0.6],fill='yellow')
+            if board[r][c]==1: d.ellipse([x0+4,y0+4,x1-4,y1-4],fill='white')
+            if board[r][c]==-1: d.ellipse([x0+4,y0+4,x1-4,y1-4],fill='black')
+    # 着手マーク
+    if last_user:
+        r,c=last_user; x0,y0=c*cell,cell+r*cell; x1,y1=x0+cell,y1=y0+cell
+        d.rectangle([x0,y0,x1,y1],outline='red',width=3)
+    if last_ai:
+        r,c=last_ai; x0,y0=c*cell,cell+r*cell; x1,y1=x0+cell,y0+cell
+        d.rectangle([x0,y0,x1,y1],outline='blue',width=3)
     return img
 
-def count_score(board):
-    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 click_handler(evt: gr.SelectData, state):
-    board, player = 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
+def click_handler(evt:gr.SelectData,state):
+    board,player,last_user,last_ai=state
+    x,y=evt.index; cell=360//8
+    c,r=int(x//cell),int((y-cell)//cell)
+    if r<0 or r>7 or c<0 or c>7:
+        yield board_to_image(board,last_user,last_ai,player),state
         return
-    if not apply_move(board, r, c, player):
-        yield board_to_image(board), f"({r+1},{c+1})には置けません。", state
+    if apply_move(board,r,c,player):
+        last_user=(r,c)
+    else:
+        yield board_to_image(board,last_user,last_ai,player),(board,player,last_user,last_ai)
         return
-    b,w = count_score(board)
-    commentary = f"あなたは({r+1},{c+1})に石を���きました。\n現在：黒{b} - 白{w}。AIの思考中…"
-    player = -player
-    yield board_to_image(board), commentary, (board, player)
+    player=-player
+    yield board_to_image(board,last_user,last_ai,player),(board,player,last_user,last_ai)
     time.sleep(2)
-    ai_mv = choose_move(board, player)
+    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)
+        apply_move(board,ai_mv[0],ai_mv[1],player)
+        last_ai=(ai_mv[0],ai_mv[1])
+        player=-player
+    yield board_to_image(board,last_user,last_ai,player),(board,player,last_user,last_ai)
 
 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])
+    state=gr.State((initialize_board(),-1,None,None))
+    img=gr.Image(value=board_to_image(initialize_board(),None,None,-1),interactive=True)
+    img.select(click_handler,inputs=[state],outputs=[img,state])
     demo.launch()