Update app.py

app.py

@@ -4,92 +4,103 @@ import random
 import time
 
 def choose_move(board, player):
-    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
+    valid = [(r, c) for r in range(8) for c in range(8) if get_flips(board, r, c, player)]
+    return random.choice(valid) if valid else None
 
 def initialize_board():
-    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
+    b = [[0]*8 for _ in range(8)]
+    b[3][3], b[4][4] = 1, 1
+    b[3][4], b[4][3] = -1, -1
+    return b
 
 DIRECTIONS = [(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]
 
 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
+    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,r,c,p):
-    f=get_flips(board,r,c,p)
+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
+    board[r][c] = p
+    for rr, cc in f: board[rr][cc] = p
     return True
 
 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
+    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')
-    # 盤面
+    size = 360; cell = size//8
+    img = Image.new('RGB', (size, size+cell), 'darkgreen')
+    draw = ImageDraw.Draw(img)
+    # Scoreboard
+    b, w = count_score(board)
+    draw.rectangle([0,0,size,cell], fill='navy')
+    font = ImageFont.load_default()
+    draw.text((10,2), f"● 黒: {b}", font=font, fill='yellow')
+    draw.text((size-80,2), f"白: {w} ○", font=font, fill='yellow')
+    # Board
     for r in range(8):
         for c in range(8):
-            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')
-    # 着手マーク
+            x0, y0 = c*cell, cell + r*cell
+            x1, y1 = x0+cell, y0+cell
+            draw.rectangle([x0,y0,x1,y1], outline='black')
+            # possible moves
+            if board[r][c]==0 and get_flips(board, r, c, player):
+                draw.ellipse([x0+cell*0.4, y0+cell*0.4, x0+cell*0.6, y0+cell*0.6], fill='yellow')
+            if board[r][c]==1:
+                draw.ellipse([x0+4, y0+4, x1-4, y1-4], fill='white')
+            if board[r][c]==-1:
+                draw.ellipse([x0+4, y0+4, x1-4, y1-4], fill='black')
+    # markers
     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)
+        ur, uc = last_user
+        x0, y0 = uc*cell, cell + ur*cell; x1, y1 = x0+cell, y0+cell
+        draw.rectangle([x0,y0,x1,y1], outline='red', width=4)
     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)
+        ar, ac = last_ai
+        x0, y0 = ac*cell, cell + ar*cell; x1, y1 = x0+cell, y0+cell
+        draw.rectangle([x0,y0,x1,y1], outline='blue', width=4)
     return img
 
-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
+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)
+    # invalid
+    if not (0<=r<8 and 0<=c<8):
+        yield board_to_image(board, last_user, last_ai, player), state
         return
-    if apply_move(board,r,c,player):
-        last_user=(r,c)
+    # user move
+    if apply_move(board, r, c, player):
+        last_user = (r, c); player = -player
+        yield board_to_image(board, last_user, last_ai, player), state
     else:
-        yield board_to_image(board,last_user,last_ai,player),(board,player,last_user,last_ai)
+        yield board_to_image(board, last_user, last_ai, player), state
         return
-    player=-player
-    yield board_to_image(board,last_user,last_ai,player),(board,player,last_user,last_ai)
+    # AI thinking indicator
+    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 move
+    ai_mv = choose_move(board, player)
     if ai_mv:
-        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)
+        apply_move(board, ai_mv[0], ai_mv[1], player)
+        last_ai = ai_mv; player = -player
+        yield board_to_image(board, last_user, last_ai, player), (board, player, last_user, last_ai)
+    else:
+        yield board_to_image(board, last_user, last_ai, player), (board, player, last_user, last_ai)
 
 with gr.Blocks() as demo:
-    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])
+    state = gr.State((initialize_board(), -1, None, None))
+    board_img = gr.Image(value=board_to_image(initialize_board(), None, None, -1), interactive=True)
+    board_img.select(click_handler, inputs=[state], outputs=[board_img, state])
     demo.launch()