Update app.py

app.py

@@ -2,137 +2,115 @@ import gradio as gr
 from PIL import Image, ImageDraw, ImageFont
 import random, time
 
-DIRECTIONS = [(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]
-
-history_log = []
-
-# Load custom fonts or fall back
-try:
-    FONT_L = ImageFont.truetype("DejaVuSans-Bold.ttf", 36)
-    FONT_S = ImageFont.truetype("DejaVuSans-Bold.ttf", 20)
-except:
-    FONT_L = ImageFont.load_default()
-    FONT_S = ImageFont.load_default()
+# Constants
+dIRECTIONS = [(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]
 
+# Initialize board
 def initialize_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
+    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
 
+# Get flips
 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
+    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.extend(buf)
     return flips
 
+# Apply move
 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
+    flips = get_flips(board, r, c, p)
+    if not flips: return False
+    board[r][c] = p
+    for rr, cc in flips:
+        board[rr][cc] = p
     return True
 
-def choose_move(board, player):
-    valid=[(r,c) for r in range(8) for c in range(8) if get_flips(board,r,c,player)]
+# AI choose move
+def choose_move(board, p):
+    valid = [(r,c) for r in range(8) for c in range(8) if get_flips(board,r,c,p)]
     return random.choice(valid) if valid else None
 
+# Count score
 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
+    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
 
+# Check game over
 def is_game_over(board):
     return not any(get_flips(board,r,c,p) for p in (-1,1) for r in range(8) for c in range(8))
 
+# Render board image
 def board_to_image(board, state):
-    board_state, player, last_user, last_ai, history = state
-    size, cell = 400, 400//8
-    img=Image.new('RGB',(size,size+cell*5),'darkgreen')
-    draw=ImageDraw.Draw(img)
-
-    b,w=count_score(board_state)
-    draw.rectangle([0,0,size,cell],fill='navy')
-    draw.text((10,2),f"BLACK: {b}",font=FONT_L,fill='white')
-    draw.text((size-200,2),f"WHITE: {w}",font=FONT_L,fill='white')
-
+    board_state, player, last_user, last_ai = state
+    size, cell = 360, 360//8
+    img = Image.new('RGB', (size, size+cell), 'darkgreen')
+    draw = ImageDraw.Draw(img)
+    font = ImageFont.load_default()
+
+    # Scoreboard
+    b, w = count_score(board_state)
+    draw.text((10,2), f"B:{b}", font=font, fill='white')
+    draw.text((size-40,2), f"W:{w}", font=font, fill='white')
+
+    # Game end
     if is_game_over(board_state):
-        winner = "DRAW" if b==w else ("BLACK WINS" if b>w else "WHITE WINS")
-        draw.rectangle([0,cell,size,cell*2],fill='darkred')
-        draw.text((size//2-120,cell+2),winner,font=FONT_L,fill='yellow')
-        draw.text((size//2-120,cell+30),"Click 'New Game' to restart",font=FONT_S,fill='white')
+        winner = "Draw" if b==w else ("Black wins" if b>w else "White wins")
+        draw.text((size//2-40, size//2), winner, font=font, fill='yellow')
 
+    # Board grid and stones
     for r in range(8):
         for c in range(8):
-            x0,y0=c*cell,cell*2+r*cell; x1,y1=x0+cell,y0+cell
-            draw.rectangle([x0,y0,x1,y1],outline='black')
-            if board_state[r][c]==0 and get_flips(board_state,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_state[r][c]==1: draw.ellipse([x0+4,y0+4,x1-4,y1-4],fill='white')
-            if board_state[r][c]==-1: draw.ellipse([x0+4,y0+4,x1-4,y1-4],fill='black')
-
-    for mark,clr in ((last_user,'red'),(last_ai,'blue')):
-        if mark:
-            mr,mc=mark; x0,y0=mc*cell,cell*2+mr*cell; x1,y1=x0+cell,y0+cell
-            draw.rectangle([x0,y0,x1,y1],outline=clr,width=4)
-
-    y=cell*2+8*cell+10
-    if history:
-        draw.text((10,y),"History:",font=FONT_S,fill='white'); y+=cell//2
-        for res in history[-5:]:
-            draw.text((10,y),res,font=FONT_S,fill='white'); y+=cell//2
-
+            x0, y0 = c*cell, cell + r*cell
+            x1, y1 = x0+cell, y0+cell
+            draw.rectangle([x0,y0,x1,y1], outline='black')
+            if board_state[r][c] == 1:
+                draw.ellipse([x0+4,y0+4,x1-4,y1-4], fill='white')
+            elif board_state[r][c] == -1:
+                draw.ellipse([x0+4,y0+4,x1-4,y1-4], fill='black')
     return img
 
+# Click handler
+
 def click_handler(evt, state):
+    # state: (board, player, last_user, last_ai)
     if state is None:
-        state = (initialize_board(), -1, None, None, [])
-    board, player, lu, la, history = state
-    if callable(evt.index):
-        x, y = evt.index()
-    else:
-        x, y = evt.index
-    cell = 400 // 8
-    c, r = int(x // cell), int((y - cell * 2) // cell)
+        state = (initialize_board(), -1, None, None)
+    board, player, last_user, last_ai = state
+
+    x, y = evt.index
+    cell = 360 // 8
+    c, r = int(x//cell), int((y-cell)//cell)
 
+    # Player move
     if 0 <= r < 8 and 0 <= c < 8 and not is_game_over(board):
         if apply_move(board, r, c, player):
-            lu, player = (r, c), -player
-
-    yield board_to_image(board, (board, player, lu, la, history)), (board, player, lu, la, history)
-
-    if is_game_over(board):
-        winner = "DRAW" if count_score(board)[0] == count_score(board)[1] else ("BLACK" if count_score(board)[0] > count_score(board)[1] else "WHITE")
-        history.append(f"Game {len(history)+1}: {winner}")
-        history_log.append(f"Game {len(history_log)+1}: {winner}")
-        yield board_to_image(board, (board, player, lu, la, history)), (board, player, lu, la, history)
-        return
+            last_user = (r, c)
+            player = -player
 
-    thinking_img = board_to_image(board, (board, player, lu, la, history))
-    draw = ImageDraw.Draw(thinking_img)
-    draw.text((150, 400 - 25), "AI Thinking...", font=FONT_S, fill='cyan')
-    yield thinking_img, (board, player, lu, la, history)
-    time.sleep(1.5)
+    # AI move
+    if not is_game_over(board):
+        ai_mv = choose_move(board, player)
+        if ai_mv:
+            apply_move(board, ai_mv[0], ai_mv[1], player)
+            last_ai = ai_mv
+            player = -player
 
-    ai_mv = choose_move(board, player)
-    if ai_mv:
-        apply_move(board, ai_mv[0], ai_mv[1], player)
-        la, player = ai_mv, -player
-    yield board_to_image(board, (board, player, lu, la, history)), (board, player, lu, la, history)
+    return board_to_image(board, (board, player, last_user, last_ai)), (board, player, last_user, last_ai)
 
-def reset_handler():
-    new_board = initialize_board()
-    return new_board, -1, None, None, history_log.copy()
+# Main
 
 with gr.Blocks() as demo:
-    state=gr.State((initialize_board(),-1,None,None,[]))
-    img=gr.Image(value=board_to_image(initialize_board(),(initialize_board(),-1,None,None,[])),interactive=True)
-    new_btn=gr.Button("New Game")
-    img.select(click_handler,inputs=[state],outputs=[img,state])
-    new_btn.click(fn=lambda: (initialize_board(), -1, None, None, history_log.copy()), outputs=[state, img])
+    state = gr.State((initialize_board(), -1, None, None))
+    img = gr.Image(value=board_to_image(initialize_board(), (initialize_board(), -1, None, None)), interactive=True)
+    img.select(click_handler, inputs=[state], outputs=[img, state])
     demo.launch()