Update app.py

app.py

@@ -5,105 +5,103 @@ from PIL import Image, ImageDraw, ImageFont
 
 DIRECTIONS = [(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]
 
-# Game logic
 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
+    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
 
-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:
+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 += 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 choose_move(board,p):
-    moves=[(r,c) for r in range(8) for c in range(8) if get_flips(board,r,c,p)]
+def choose_move(board, p):
+    moves = [(r,c) for r in range(8) for c in range(8) if get_flips(board,r,c,p)]
     return random.choice(moves) if moves else None
 
 def count_score(b):
-    bl=sum(c==-1 for row in b for c in row)
-    wh=sum(c==1  for row in b for c in row)
-    return bl,wh
+    bl = sum(c==-1 for row in b for c in row)
+    wh = sum(c==1 for row in b for c in row)
+    return bl, wh
 
-def get_possible(board,p):
+def get_possible(board, p):
     return [(r,c) for r in range(8) for c in range(8) if get_flips(board,r,c,p)]
 
 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))
+    return not any(get_flips(board,r,c,p) for p in (-1,1) for r in range(8) for c in range(8))
 
-# Rendering
 def board_to_image(state):
-    board,player,last_user,last_ai=state
-    size,bs=400,360;off=20;cell=bs//8
-    img=Image.new('RGB',(size,size),'darkgreen')
-    draw=ImageDraw.Draw(img)
-    try: fnt=ImageFont.truetype('arial.ttf',28)
-    except: fnt=ImageFont.load_default()
-    # flashy scoreboard
-    bl,wh=count_score(board)
-    draw.rectangle([0,0,size,off],fill='black')
-    draw.text((10,2),f"Black: {bl}",font=fnt,fill='yellow')
-    draw.text((size-140,2),f"White: {wh}",font=fnt,fill='yellow')
-    # possible moves
-    for r,c in get_possible(board,player):
-        x=off+c*cell+cell//2; y=off+r*cell+cell//2
-        draw.ellipse([x-5,y-5,x+5,y+5],outline='blue',width=2)
-    # stones and last move
+    board, player, last_user, last_ai = state
+    size, bs = 400, 360; off = 20; cell = bs//8
+    img = Image.new('RGB', (size, size), 'darkgreen')
+    draw = ImageDraw.Draw(img)
+    try: fnt = ImageFont.truetype('arial.ttf',28)
+    except: fnt = ImageFont.load_default()
+    bl, wh = count_score(board)
+    draw.rectangle([0,0,size,off], fill='black')
+    draw.text((10,2), f"Black: {bl}", font=fnt, fill='yellow')
+    draw.text((size-140,2), f"White: {wh}", font=fnt, fill='yellow')
+    for r,c in get_possible(board, player):
+        x = off+c*cell+cell//2; y = off+r*cell+cell//2
+        draw.ellipse([x-5,y-5,x+5,y+5], outline='blue', width=2)
     for r in range(8):
         for c in range(8):
-            x0,y0=off+c*cell,off+r*cell; x1,y1=x0+cell,y0+cell
-            draw.rectangle([x0,y0,x1,y1],outline='black')
-            v=board[r][c]
+            x0,y0 = off+c*cell, off+r*cell; x1,y1 = x0+cell, y0+cell
+            draw.rectangle([x0,y0,x1,y1], outline='black')
+            v = board[r][c]
             if v:
-                color='white' if v==1 else 'black'
-                draw.ellipse([x0+4,y0+4,x1-4,y1-4],fill=color)
-    # mark last moves
-    for pos,col in [(last_user,'red'),(last_ai,'orange')]:
+                color = 'white' if v==1 else 'black'
+                draw.ellipse([x0+4,y0+4,x1-4,y1-4], fill=color)
+    for pos,col in [(last_user,'red'), (last_ai,'orange')]:
         if pos:
-            r,c=pos; x0,y0=off+c*cell,off+r*cell; x1,y1=x0+cell,y0+cell
-            draw.rectangle([x0+2,y0+2,x1-2,y1-2],outline=col,width=4)
-    # game over text
+            r,c = pos; x0,y0 = off+c*cell, off+r*cell; x1,y1 = x0+cell, y0+cell
+            draw.rectangle([x0+2,y0+2,x1-2,y1-2], outline=col, width=4)
     if is_game_over(board):
-        res='DRAW' if bl==wh else 'BLACK WINS' if bl>wh else 'WHITE WINS'
-        draw.text((size//2-80,size//2-15),res,font=fnt,fill='cyan')
+        res = 'DRAW' if bl==wh else 'BLACK WINS' if bl>wh else 'WHITE WINS'
+        draw.text((size//2-80,size//2-15), res, font=fnt, fill='cyan')
     return img
 
-# Handlers
-def click_handler(evt,state):
-    board,player,last_user,last_ai=state
-    x,y=evt.index; cell=360//8;off=20
-    c=int((x-off)//cell); r=int((y-off)//cell)
+def click_handler(evt, state):
+    if state is None:
+        state = (initialize_board(), -1, None, None)
+    board, player, last_user, last_ai = state
+    x, y = evt.index; cell = 360//8; off = 20
+    c = int((x-off)//cell); r = int((y-off)//cell)
     if 0<=r<8 and 0<=c<8 and not is_game_over(board):
-        if apply_move(board,r,c,player): last_user=(r,c); player=-player
-        # delay + loading
-        time.sleep(1)
-        if not is_game_over(board):
-            mv=choose_move(board,player)
-            if mv: apply_move(board,mv[0],mv[1],player); last_ai=mv; player=-player
-    return board_to_image((board,player,last_user,last_ai)),(board,player,last_user,last_ai)
+        if apply_move(board, r, c, player):
+            last_user = (r, c); player = -player
+            time.sleep(1)
+            if not is_game_over(board):
+                mv = choose_move(board, player)
+                if mv:
+                    apply_move(board, mv[0], mv[1], player)
+                    last_ai = mv; player = -player
+    new_state = (board, player, last_user, last_ai)
+    return board_to_image(new_state), new_state
 
 def reset_game():
-    return (initialize_board(),-1,None,None)
+    state = (initialize_board(), -1, None, None)
+    return board_to_image(state), state
 
-# UI
-demo=gr.Blocks()
+demo = gr.Blocks()
 with demo:
-    state=gr.State((initialize_board(),-1,None,None))
-    img=gr.Image(value=board_to_image((initialize_board(),-1,None,None)),interactive=True)
-    new=gr.Button('New Game')
-    img.select(click_handler,inputs=[state],outputs=[img,state],show_progress=True)
-    new.click(lambda: reset_game(),outputs=[state])
+    state = gr.State((initialize_board(), -1, None, None))
+    img = gr.Image(value=board_to_image((initialize_board(),-1,None,None)), interactive=True)
+    new = gr.Button('New Game')
+    img.select(click_handler, inputs=[state], outputs=[img, state], show_progress=True)
+    new.click(reset_game, outputs=[img, state])
 demo.launch()