Update app.py

app.py

@@ -1,324 +1,517 @@
-""" Turkish Dama (Dama) — Gradio Space
-
-Single-file Gradio app implementing Turkish Draughts (Dama) playable as:
-
-Local 2-player (same device)
-
-Single-player vs AI (minimax)
-
-
-How to run locally:
-
-1. pip install gradio
-
-
-2. python turkish_dama_gradio.py
-
-
-3. Open the local Gradio URL or deploy to Hugging Face Spaces (create a new Space, upload this file, set runtime to "gradio").
-
-
-
-Notes / limitations:
-
-This implementation focuses on correct Turkish Dama rules: orthogonal moves, mandatory captures, immediate removal during multi-jump, kings move like rooks and capture from distance.
-
-Multiplayer over the network (real-time matchmaking) is not implemented here. I can add a turn-based room system (requires a small backend or use of external persistence) if you want.
-
-
-Author: ChatGPT — example implementation for Hugging Face Spaces """
-
-import gradio as gr 
-import copy 
-import json 
+""" Turkish Dama (Dama) — Gradio SpaceSingle-file Gradio app implementing Turkish Draughts (Dama) playable as:Local 2-player (same device)Single-player vs AI (minimax)How to run locally:1. pip install gradio2. python turkish_dama_gradio.py3. Open the local Gradio URL or deploy to Hugging Face Spaces (create a new Space, upload this file, set runtime to "gradio").Notes / limitations:This implementation focuses on correct Turkish Dama rules: orthogonal moves, mandatory captures, immediate removal during multi-jump, kings move like rooks and capture from distance.Multiplayer over the network (real-time matchmaking) is not implemented here. I can add a turn-based room system (requires a small backend or use of external persistence) if you want.Author: ChatGPT — example implementation for Hugging Face Spaces """
+import gradio as gr
+import copy
+import json
 import math
 
 BOARD_SIZE = 8
 
-#Piece encoding:
-
-0 = empty
-
-1 = white man
-
-2 = white king
-
--1 = black man
-
--2 = black king
-
-def initial_board(): b = [[0]*BOARD_SIZE for _ in range(BOARD_SIZE)] # Place white at bottom two rows, black at top two rows for r in range(2): for c in range(BOARD_SIZE): b[r][c] = -1  # black for r in range(BOARD_SIZE-2, BOARD_SIZE): for c in range(BOARD_SIZE): b[r][c] = 1   # white return b
-
-def inside(r,c): return 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE
-
-def clone(board): return copy.deepcopy(board)
-
-class Game: def init(self): self.board = initial_board() self.turn = 1  # 1 = white, -1 = black self.selected = None self.must_capture_moves = None self.history = []
-
-def to_json(self):
-    return json.dumps({
-        'board': self.board,
-        'turn': self.turn,
-        'history': self.history
-    })
-
-@staticmethod
-def from_json(s):
-    d = json.loads(s)
-    g = Game()
-    g.board = d['board']
-    g.turn = d['turn']
-    g.history = d.get('history', [])
-    return g
-
-def push(self):
-    self.history.append(json.dumps({'board': clone(self.board), 'turn': self.turn}))
-
-def undo(self):
-    if not self.history:
-        return
-    last = json.loads(self.history.pop())
-    self.board = last['board']
-    self.turn = last['turn']
+# Piece encoding:
+# 0 = empty
+# 1 = white man
+# 2 = white king
+# -1 = black man
+# -2 = black king
+
+def initial_board():
+    b = [[0]*BOARD_SIZE for _ in range(BOARD_SIZE)]
+    # Place white at bottom two rows, black at top two rows
+    for r in range(2):
+        for c in range(BOARD_SIZE):
+            b[r][c] = -1 # black
+    for r in range(BOARD_SIZE-2, BOARD_SIZE):
+        for c in range(BOARD_SIZE):
+            b[r][c] = 1 # white
+    return b
+
+def inside(r,c):
+    return 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE
+
+def clone(board):
+    return copy.deepcopy(board)
+
+class Game:
+    def __init__(self):
+        self.board = initial_board()
+        self.turn = 1 # 1 = white, -1 = black
+        self.selected = None
+        self.must_capture_moves = None
+        self.history = []
+
+    def to_json(self):
+        return json.dumps({
+            'board': self.board,
+            'turn': self.turn,
+            'history': self.history
+        })
+
+    @staticmethod
+    def from_json(s):
+        d = json.loads(s)
+        g = Game()
+        g.board = d['board']
+        g.turn = d['turn']
+        g.history = d.get('history', [])
+        return g
+
+    def push(self):
+        self.history.append(json.dumps({'board': clone(self.board), 'turn': self.turn}))
+
+    def undo(self):
+        if not self.history:
+            return
+        last = json.loads(self.history.pop())
+        self.board = last['board']
+        self.turn = last['turn']
+
+    def is_king(self, val):
+        return abs(val) == 2
+
+    def generate_moves(self, color):
+        # Returns list of moves. Move: tuple (r_from,c_from, r_to,c_to, [list of captures positions])
+        # We must enforce mandatory capture: if any capture exists, only captures allowed.
+        captures = []
+        noncaps = []
+        for r in range(BOARD_SIZE):
+            for c in range(BOARD_SIZE):
+                val = self.board[r][c]
+                if val*color <= 0:
+                    continue
 
-def is_king(self, val):
-    return abs(val) == 2
+                if abs(val) == 1: # man
+                    # moves: orthogonal forward (toward enemy) or sideways
+                    # For white (1): forward is -1 row (up)
+                    # But men can move forward or sideways one square
+                    dirs = [(-1,0),(0,-1),(0,1)] if val==1 else [(1,0),(0,-1),(0,1)]
+                    
+                    # For capturing, men capture orthogonally by jumping over adjacent enemy into empty square
+                    for dr,dc in dirs:
+                        r1,c1 = r+dr, c+dc
+                        r2,c2 = r+2*dr, c+2*dc
+                        if inside(r2,c2) and self.board[r1][c1]*color < 0 and self.board[r2][c2]==0:
+                            # capture
+                            captures.append((r,c,r2,c2,[(r1,c1)]))
+
+                    # non-capture moves
+                    for dr,dc in dirs:
+                        r1,c1 = r+dr,c+dc
+                        if inside(r1,c1) and self.board[r1][c1]==0:
+                            noncaps.append((r,c,r1,c1,[]))
 
-def generate_moves(self, color):
-    # Returns list of moves. Move: tuple (r_from,c_from, r_to,c_to, [list of captures positions])
-    # We must enforce mandatory capture: if any capture exists, only captures allowed.
-    captures = []
-    noncaps = []
+                else: # king
+                    # slide any distance orthogonally for moves; for captures can capture from distance
+                    for dr,dc in [(-1,0),(1,0),(0,-1),(0,1)]:
+                        step = 1
+                        while True:
+                            r1,c1 = r+dr*step, c+dc*step
+                            if not inside(r1,c1):
+                                break
+                            if self.board[r1][c1]==0:
+                                # candidate non-capture move
+                                noncaps.append((r,c,r1,c1,[]))
+                                step+=1
+                                continue
+                            if self.board[r1][c1]*color < 0:
+                                # possible capture: there must be an empty square beyond
+                                step2 = 1
+                                while True:
+                                    r_land = r1+dr*step2
+                                    c_land = c1+dc*step2
+                                    if not inside(r_land,c_land):
+                                        break
+                                    if self.board[r_land][c_land]==0:
+                                        captures.append((r,c,r_land,c_land,[(r1,c1)])) # kings can capture landing any square beyond captured piece; we record all
+                                        step2+=1
+                                        continue
+                                    else:
+                                        break
+                                break
+                            else:
+                                break
+        
+        # If captures exist, we must expand multi-captures (since immediate removal can open more captures)
+        if captures:
+            full_caps = []
+            for cap in captures:
+                seqs = self._expand_capture_sequence(clone(self.board), cap)
+                full_caps.extend(seqs)
+            
+            # choose only moves that capture maximum number of pieces per rule
+            max_captured = max(len(m[4]) for m in full_caps) if full_caps else 0
+            full_caps = [m for m in full_caps if len(m[4])==max_captured]
+
+            return full_caps
+        else:
+            return noncaps
+
+    def _expand_capture_sequence(self, board_state, move):
+        # move is (r_from,c_from,r_to,c_to, [captures_so_far])
+        # perform move on board_state, remove captured pieces immediately, then see if further captures possible from landing square
+        r0,c0,r1,c1,caps = move
+        b = copy.deepcopy(board_state)
+        piece = b[r0][c0]
+        b[r0][c0]=0
+        b[r1][c1]=piece
+        
+        # remove captured pieces
+        for (cr,cc) in caps:
+            b[cr][cc]=0
+            
+        # check promotion: if man reaches back row -> becomes king immediately
+        if abs(piece)==1:
+            if (piece==1 and r1==0) or (piece==-1 and r1==BOARD_SIZE-1):
+                b[r1][c1] = 2*piece
+                
+        # When promoted, possible capturing abilities change; continue expansion with new board
+        # find further captures from r1,c1
+        further = []
+        color = 1 if b[r1][c1]>0 else -1
+        val = b[r1][c1]
+        
+        if abs(val)==1:
+            dirs = [(-1,0),(0,-1),(0,1)] if val==1 else [(1,0),(0,-1),(0,1)]
+            for dr,dc in dirs:
+                rA,cA = r1+dr,c1+dc
+                rB,cB = r1+2*dr,c1+2*dc
+                if inside(rB,cB) and b[rA][cA]*color<0 and b[rB][cB]==0:
+                    # can capture
+                    new_caps = caps+[(rA,cA)]
+                    further.append((r1,c1,rB,cB,new_caps))
+        else: # king
+            for dr,dc in [(-1,0),(1,0),(0,-1),(0,1)]:
+                step = 1
+                while True:
+                    rA,cA = r1+dr*step, c1+dc*step
+                    if not inside(rA,cA):
+                        break
+                    if b[rA][cA]==0:
+                        step+=1
+                        continue
+                    if b[rA][cA]*color<0:
+                        # try landing squares beyond
+                        step2=1
+                        while True:
+                            rLand = rA+dr*step2
+                            cLand = cA+dc*step2
+                            if not inside(rLand,cLand):
+                                break
+                            if b[rLand][cLand]==0:
+                                new_caps = caps+[(rA,cA)]
+                                further.append((r1,c1,rLand,cLand,new_caps))
+                                step2+=1
+                                continue
+                            else:
+                                break
+                        break
+                    else:
+                        break
+        
+        if not further:
+            return [(r0,c0,r1,c1,caps)]
+        
+        results = []
+        for f in further:
+            results.extend(self._expand_capture_sequence(b, f)) # prepend original source coordinates
+        final = []
+        for seq in results:
+            final.append((r0,c0,seq[2],seq[3], seq[4]))
+        return final
+
+    def apply_move(self, move):
+        # move: (r0,c0,r1,c1,captures)
+        r0,c0,r1,c1,caps = move
+        piece = self.board[r0][c0]
+        self.push()
+        self.board[r0][c0]=0
+        self.board[r1][c1]=piece
+        
+        for (cr,cc) in caps:
+            self.board[cr][cc]=0
+            
+        # promotion immediate
+        if abs(piece)==1:
+            if (piece==1 and r1==0) or (piece==-1 and r1==BOARD_SIZE-1):
+                self.board[r1][c1] = 2*piece
+                
+        self.turn *= -1
+
+    def game_over(self):
+        # game over if one side has no pieces or no legal moves
+        white_exists = any(self.board[r][c]>0 for r in range(BOARD_SIZE) for c in range(BOARD_SIZE))
+        black_exists = any(self.board[r][c]<0 for r in range(BOARD_SIZE) for c in range(BOARD_SIZE))
+        if not white_exists:
+            return True, -1
+        if not black_exists:
+            return True, 1
+        
+        white_moves = self.generate_moves(1)
+        black_moves = self.generate_moves(-1)
+        
+        if not white_moves:
+            return True, -1
+        if not black_moves:
+            return True, 1
+
+        return False, None
+
+# Rendering helper: produce an SVG of the current board
+def render_svg(board, selected=None):
+    size = 480
+    cell = size // BOARD_SIZE
+    svg = [f'<svg width="{size}" height="{size}" viewBox="0 0 {size} {size}" xmlns="http://www.w3.org/2000/svg">']
+    # background
+    svg.append(f'<rect width="100%" height="100%" fill="#f0d9b5"/>')
+    # grid lines
+    for r in range(BOARD_SIZE):
+        for c in range(BOARD_SIZE):
+            x = c*cell
+            y = r*cell
+            svg.append(f'<rect x="{x}" y="{y}" width="{cell}" height="{cell}" fill="none" stroke="#000" stroke-width="1"/>')
+    # pieces
     for r in range(BOARD_SIZE):
         for c in range(BOARD_SIZE):
-            val = self.board[r][c]
-            if val*color <= 0:
+            val = board[r][c]
+            if val==0:
                 continue
-            if abs(val) == 1:  # man
-                # moves: orthogonal forward (toward enemy) or sideways
-                # For white (1): forward is -1 row (up)
-                # But men can move forward or sideways one square
-                dirs = [(-1,0),(0,-1),(0,1)] if val==1 else [(1,0),(0,-1),(0,1)]
-                # For capturing, men capture orthogonally by jumping over adjacent enemy into empty square
-                for dr,dc in dirs:
-                    r1,c1 = r+dr, c+dc
-                    r2,c2 = r+2*dr, c+2*dc
-                    if inside(r2,c2) and self.board[r1][c1]*color < 0 and self.board[r2][c2]==0:
-                        # capture
-                        captures.append((r,c,r2,c2,[(r1,c1)]))
-                # non-capture moves
-                for dr,dc in dirs:
-                    r1,c1 = r+dr,c+dc
-                    if inside(r1,c1) and self.board[r1][c1]==0:
-                        noncaps.append((r,c,r1,c1,[]))
-            else:  # king
-                # slide any distance orthogonally for moves; for captures can capture from distance
-                for dr,dc in [(-1,0),(1,0),(0,-1),(0,1)]:
-                    step = 1
-                    while True:
-                        r1,c1 = r+dr*step, c+dc*step
-                        if not inside(r1,c1):
-                            break
-                        if self.board[r1][c1]==0:
-                            # candidate non-capture move
-                            noncaps.append((r,c,r1,c1,[]))
-                            step+=1
-                            continue
-                        if self.board[r1][c1]*color < 0:
-                            # possible capture: there must be an empty square beyond
-                            step2 = 1
-                            while True:
-                                r_land = r1+dr*step2
-                                c_land = c1+dc*step2
-                                if not inside(r_land,c_land):
-                                    break
-                                if self.board[r_land][c_land]==0:
-                                    captures.append((r,c,r_land,c_land,[(r1,c1)]))
-                                    # kings can capture landing any square beyond captured piece; we record all
-                                    step2+=1
-                                    continue
-                                else:
-                                    break
-                            break
-                        else:
-                            break
-    # If captures exist, we must expand multi-captures (since immediate removal can open more captures)
-    if captures:
-        full_caps = []
-        for cap in captures:
-            seqs = self._expand_capture_sequence(clone(self.board), cap)
-            full_caps.extend(seqs)
-        # choose only moves that capture maximum number of pieces per rule
-        max_captured = max(len(m[4]) for m in full_caps) if full_caps else 0
-        full_caps = [m for m in full_caps if len(m[4])==max_captured]
-        return full_caps
-    else:
-        return noncaps
-
-def _expand_capture_sequence(self, board_state, move):
-    # move is (r_from,c_from,r_to,c_to, [captures_so_far])
-    # perform move on board_state, remove captured pieces immediately, then see if further captures possible from landing square
-    r0,c0,r1,c1,caps = move
-    b = copy.deepcopy(board_state)
-    piece = b[r0][c0]
-    b[r0][c0]=0
-    b[r1][c1]=piece
-    # remove captured pieces
-    for (cr,cc) in caps:
-        b[cr][cc]=0
-    # check promotion: if man reaches back row -> becomes king immediately
-    if abs(piece)==1:
-        if (piece==1 and r1==0) or (piece==-1 and r1==BOARD_SIZE-1):
-            b[r1][c1] = 2*piece
-            # When promoted, possible capturing abilities change; continue expansion with new board
-    # find further captures from r1,c1
-    further = []
-    color = 1 if b[r1][c1]>0 else -1
-    val = b[r1][c1]
-    if abs(val)==1:
-        dirs = [(-1,0),(0,-1),(0,1)] if val==1 else [(1,0),(0,-1),(0,1)]
-        for dr,dc in dirs:
-            rA,cA = r1+dr,c1+dc
-            rB,cB = r1+2*dr,c1+2*dc
-            if inside(rB,cB) and b[rA][cA]*color<0 and b[rB][cB]==0:
-                # can capture
-                new_caps = caps+[(rA,cA)]
-                further.append((r1,c1,rB,cB,new_caps))
-    else:  # king
-        for dr,dc in [(-1,0),(1,0),(0,-1),(0,1)]:
-            step = 1
-            while True:
-                rA,cA = r1+dr*step, c1+dc*step
-                if not inside(rA,cA):
-                    break
-                if b[rA][cA]==0:
-                    step+=1
-                    continue
-                if b[rA][cA]*color<0:
-                    # try landing squares beyond
-                    step2=1
-                    while True:
-                        rLand = rA+dr*step2
-                        cLand = cA+dc*step2
-                        if not inside(rLand,cLand):
-                            break
-                        if b[rLand][cLand]==0:
-                            new_caps = caps+[(rA,cA)]
-                            further.append((r1,c1,rLand,cLand,new_caps))
-                            step2+=1
-                            continue
-                        else:
-                            break
+            cx = c*cell + cell/2
+            cy = r*cell + cell/2
+            radius = cell*0.36
+            
+            if val>0:
+                fill = '#fff'
+                stroke = '#000'
+            else:
+                fill = '#000'
+                stroke = '#fff'
+            
+            svg.append(f'<circle cx="{cx}" cy="{cy}" r="{radius}" fill="{fill}" stroke="{stroke}" stroke-width="3"/>')
+            
+            if abs(val)==2: # king crown — simple crown path
+                svg.append(f'<text x="{cx}" y="{cy+6}" font-size="{int(cell*0.4)}" text-anchor="middle" fill="{stroke}" font-family="Arial" font-weight="700">♛</text>')
+                
+    # highlight selected
+    if selected:
+        r,c = selected
+        x = c*cell
+        y = r*cell
+        svg.append(f'<rect x="{x+2}" y="{y+2}" width="{cell-4}" height="{cell-4}" fill="none" stroke="#ff0000" stroke-width="3"/>')
+
+    svg.append('</svg>')
+    return '\n'.join(svg)
+
+# Basic AI: minimax with simple evaluation
+def evaluate(board):
+    score = 0
+    for r in range(BOARD_SIZE):
+        for c in range(BOARD_SIZE):
+            v = board[r][c]
+            if v==0:
+                continue
+            if abs(v)==1:
+                score += 3 * (1 if v>0 else -1)
+            else:
+                score += 8 * (1 if v>0 else -1)
+    return score
+
+def ai_best_move(game: Game, depth=3):
+    # returns a move for black (-1) or white depending on game.turn
+    color = game.turn
+    
+    def minimax(g: Game, d, alpha, beta):
+        ov, winner = g.game_over()
+        if ov:
+            if winner==color:
+                return (None, 10000)
+            else:
+                return (None, -10000)
+        
+        if d==0:
+            return (None, evaluate(g.board))
+        
+        moves = g.generate_moves(g.turn)
+        if not moves:
+            return (None, -10000 if g.turn==color else 10000)
+            
+        best_move = None
+        if g.turn==color:
+            max_eval = -99999
+            for m in moves:
+                ng = Game()
+                ng.board = clone(g.board)
+                ng.turn = g.turn
+                
+                # apply move manually since apply_move references history
+                r0,c0,r1,c1,caps = m
+                piece = ng.board[r0][c0]
+                ng.board[r0][c0]=0
+                ng.board[r1][c1]=piece
+                for (cr,cc) in caps:
+                    ng.board[cr][cc]=0
+                if abs(piece)==1:
+                    if (piece==1 and r1==0) or (piece==-1 and r1==BOARD_SIZE-1):
+                        ng.board[r1][c1]=2*piece
+                ng.turn = -1
+                
+                _, val = minimax(ng, d-1, alpha, beta)
+                
+                if val>max_eval:
+                    max_eval = val
+                    best_move = m
+                alpha = max(alpha, val)
+                if beta<=alpha:
                     break
-                else:
+            return (best_move, max_eval)
+        else:
+            min_eval = 99999
+            for m in moves:
+                ng = Game()
+                ng.board = clone(g.board)
+                ng.turn = g.turn
+                
+                r0,c0,r1,c1,caps = m
+                piece = ng.board[r0][c0]
+                ng.board[r0][c0]=0
+                ng.board[r1][c1]=piece
+                for (cr,cc) in caps:
+                    ng.board[cr][cc]=0
+                if abs(piece)==1:
+                    if (piece==1 and r1==0) or (piece==-1 and r1==BOARD_SIZE-1):
+                        ng.board[r1][c1]=2*piece
+                ng.turn *= -1
+                
+                _, val = minimax(ng, d-1, alpha, beta)
+                
+                if val<min_eval:
+                    min_eval = val
+                    best_move = m
+                beta = min(beta, val)
+                if beta<=alpha:
                     break
-    if not further:
-        return [(r0,c0,r1,c1,caps)]
-    results = []
-    for f in further:
-        results.extend(self._expand_capture_sequence(b, f))
-    # prepend original source coordinates
-    final = []
-    for seq in results:
-        final.append((r0,c0,seq[2],seq[3], seq[4]))
-    return final
-
-def apply_move(self, move):
-    # move: (r0,c0,r1,c1,captures)
-    r0,c0,r1,c1,caps = move
-    piece = self.board[r0][c0]
-    self.push()
-    self.board[r0][c0]=0
-    self.board[r1][c1]=piece
-    for (cr,cc) in caps:
-        self.board[cr][cc]=0
-    # promotion immediate
-    if abs(piece)==1:
-        if (piece==1 and r1==0) or (piece==-1 and r1==BOARD_SIZE-1):
-            self.board[r1][c1] = 2*piece
-    self.turn *= -1
-
-def game_over(self):
-    # game over if one side has no pieces or no legal moves
-    white_exists = any(self.board[r][c]>0 for r in range(BOARD_SIZE) for c in range(BOARD_SIZE))
-    black_exists = any(self.board[r][c]<0 for r in range(BOARD_SIZE) for c in range(BOARD_SIZE))
-    if not white_exists:
-        return True, -1
-    if not black_exists:
-        return True, 1
-    white_moves = self.generate_moves(1)
-    black_moves = self.generate_moves(-1)
-    if not white_moves:
-        return True, -1
-    if not black_moves:
-        return True, 1
-    return False, None
-
-Rendering helper: produce an SVG of the current board
-
-def render_svg(board, selected=None): size = 480 cell = size // BOARD_SIZE svg = [f'<svg width="{size}" height="{size}" viewBox="0 0 {size} {size}" xmlns="http://www.w3.org/2000/svg">'] # background svg.append(f'<rect width="100%" height="100%" fill="#f0d9b5"/>') # grid lines for r in range(BOARD_SIZE): for c in range(BOARD_SIZE): x = ccell y = rcell svg.append(f'<rect x="{x}" y="{y}" width="{cell}" height="{cell}" fill="" stroke="#000" stroke-width="1"/>') # pieces for r in range(BOARD_SIZE): for c in range(BOARD_SIZE): val = board[r][c] if val==0: continue cx = ccell + cell/2 cy = rcell + cell/2 radius = cell0.36 if val>0: fill = '#fff' stroke = '#000' else: fill = '#000' stroke = '#fff' svg.append(f'<circle cx="{cx}" cy="{cy}" r="{radius}" fill="{fill}" stroke="{stroke}" stroke-width="3"/>') if abs(val)==2: # king crown — simple crown path svg.append(f'<text x="{cx}" y="{cy+6}" font-size="{int(cell*0.4)}" text-anchor="middle" fill="{stroke}" font-family="Arial" font-weight="700">♛</text>') # highlight selected if selected: r,c = selected x = ccell y = r*cell svg.append(f'<rect x="{x+2}" y="{y+2}" width="{cell-4}" height="{cell-4}" fill="none" stroke="#ff0000" stroke-width="3"/>') svg.append('</svg>') return '\n'.join(svg)
-
-Basic AI: minimax with simple evaluation
-
-def evaluate(board): score = 0 for r in range(BOARD_SIZE): for c in range(BOARD_SIZE): v = board[r][c] if v==0: continue if abs(v)==1: score += 3 * (1 if v>0 else -1) else: score += 8 * (1 if v>0 else -1) return score
-
-def ai_best_move(game: Game, depth=3): # returns a move for black (-1) or white depending on game.turn color = game.turn def minimax(g: Game, d, alpha, beta): ov, winner = g.game_over() if ov: if winner==color: return (None, 10000) else: return (None, -10000) if d==0: return (None, evaluate(g.board)) moves = g.generate_moves(g.turn) if not moves: return (None, -10000 if g.turn==color else 10000) best_move = None if g.turn==color: max_eval = -99999 for m in moves: ng = Game() ng.board = clone(g.board) ng.turn = g.turn ng.apply_move = Game.apply_move.get(ng) # apply move manually since apply_move references history r0,c0,r1,c1,caps = m piece = ng.board[r0][c0] ng.board[r0][c0]=0 ng.board[r1][c1]=piece for (cr,cc) in caps: ng.board[cr][cc]=0 if abs(piece)==1: if (piece==1 and r1==0) or (piece==-1 and r1==BOARD_SIZE-1): ng.board[r1][c1]=2*piece ng.turn = -1 _, val = minimax(ng, d-1, alpha, beta) if val>max_eval: max_eval = val best_move = m alpha = max(alpha, val) if beta<=alpha: break return (best_move, max_eval) else: min_eval = 99999 for m in moves: ng = Game() ng.board = clone(g.board) ng.turn = g.turn r0,c0,r1,c1,caps = m piece = ng.board[r0][c0] ng.board[r0][c0]=0 ng.board[r1][c1]=piece for (cr,cc) in caps: ng.board[cr][cc]=0 if abs(piece)==1: if (piece==1 and r1==0) or (piece==-1 and r1==BOARD_SIZE-1): ng.board[r1][c1]=2piece ng.turn *= -1 _, val = minimax(ng, d-1, alpha, beta) if val<min_eval: min_eval = val best_move = m beta = min(beta, val) if beta<=alpha: break return (best_move, min_eval)
-
-mv, _ = minimax(game, depth, -99999, 99999)
-return mv
-
-Gradio app state
-
-STATE = Game()
-
-def click_cell(r_c, mode, ai_side, ai_depth): """ r_c: string like 'r,c' when user clicks a cell from the SVG. mode: 'local' or 'ai' ai_side: 'black' or 'white' (AI plays which color when mode=='ai') """ global STATE if r_c is None or r_c=="": return render_svg(STATE.board, STATE.selected), STATE.turn, "", STATE.to_json(), "" r,c = map(int, r_c.split(',')) # If nothing selected, select piece if it belongs to player if STATE.selected is None: if STATE.board[r][c]*STATE.turn>0: STATE.selected = (r,c) return render_svg(STATE.board, STATE.selected), STATE.turn, "", STATE.to_json(), "" else: # attempt to make move from selected to r,c moves = STATE.generate_moves(STATE.turn) chosen = None for m in moves: if m[0]==STATE.selected[0] and m[1]==STATE.selected[1] and m[2]==r and m[3]==c: chosen = m break if chosen: STATE.apply_move(chosen) STATE.selected = None ov, winner = STATE.game_over() if ov: return render_svg(STATE.board, None), STATE.turn, f'Game over. Winner: {"White" if winner==1 else "Black"}', STATE.to_json(), "" # If AI mode and it's AI's turn, compute AI move if mode=='ai': side = -1 if ai_side=='black' else 1 if STATE.turn==side: mv = ai_best_move(STATE, depth=ai_depth) if mv: STATE.apply_move(mv) ov,winner = STATE.game_over() if ov: return render_svg(STATE.board, None), STATE.turn, f'Game over. Winner: {"White" if winner==1 else "Black"}', STATE.to_json(), "" return render_svg(STATE.board, None), STATE.turn, "", STATE.to_json(), "" else: # clicked invalid target => change selection if clicking own piece if STATE.board[r][c]*STATE.turn>0: STATE.selected = (r,c) else: STATE.selected = None return render_svg(STATE.board, STATE.selected), STATE.turn, "Invalid move", STATE.to_json(), ""
-
-def new_game(): global STATE STATE = Game() return render_svg(STATE.board, None), STATE.turn, "New game started.", STATE.to_json(), ""
-
-def undo_action(): global STATE STATE.undo() return render_svg(STATE.board, None), STATE.turn, "Undo.", STATE.to_json(), ""
-
-def load_state(s): global STATE try: STATE = Game.from_json(s) return render_svg(STATE.board, None), STATE.turn, "Loaded.", STATE.to_json(), "" except Exception as e: return render_svg(STATE.board, None), STATE.turn, f'Load failed: {e}', STATE.to_json(), ""
-
-def export_state(): return STATE.to_json()
-
-with gr.Blocks() as demo: gr.Markdown("# Turkish Dama (Draughts) — Gradio Space\nPlay local 2-player or single-player vs AI. Click a piece, then click destination.") with gr.Row(): board_svg = gr.HTML(render_svg(STATE.board)) with gr.Column(): mode = gr.Radio(['local','ai'], value='local', label='Mode') ai_side = gr.Radio(['black','white'], value='black', label='AI plays') ai_depth = gr.Slider(minimum=1, maximum=4, value=3, step=1, label='AI depth (strength)') new_btn = gr.Button('New Game') undo_btn = gr.Button('Undo') status = gr.Textbox(label='Status', value='') export_btn = gr.Button('Export Game (JSON)') export_out = gr.Textbox(label='Exported JSON') import_in = gr.Textbox(label='Import Game (paste JSON)') import_btn = gr.Button('Load') # Hidden state exchange state_json = gr.State(value=STATE.to_json())
-
-# We'll capture clicks by overlaying an invisible grid of buttons in HTML using simple JS that sends coordinates to Python.
-# For simplicity, provide a small JS snippet that calls a Gradio function via URL - but Gradio's native event passing is simpler by having gradio.Buttons per cell.
-# Simpler solution: produce an HTML SVG with clickable rects that call the Gradio endpoint by sending their "r,c" as input. We'll use gradio's extra JS handler.
+            return (best_move, min_eval)
 
-# Create a helper that updates board HTML
-def update_board_html(svg, turn, msg, jsstate, _unused=""):
-    # svg is actual string; replace board
-    return gr.update(value=svg), gr.update(value=msg), jsstate
+    mv, _ = minimax(game, depth, -99999, 99999)
+    return mv
 
-# Connect UI actions
-# Click handler: we cheat by using a text input that the frontend fills via small JS in the HTML. But to keep this single-file and simple, we'll use buttons overlay.
-
-# Create 8x8 invisible buttons grid: we'll render an HTML block with embedded JS that forwards clicks to Python via the Gradio api.
-# Build clickable SVG where each cell has an onclick that sets a hidden text input value then triggers a python call via the "submit" button. We'll instead wire via gradio's `js` - but simple approach: use prebuilt `click_cell` via gr.Buttons per cell.
+# Gradio app state
+STATE = Game()
 
-# Create 8x8 buttons below for clicks (works but not pretty)
-btns = []
-for r in range(BOARD_SIZE):
-    row = []
+def click_cell(r_c, mode, ai_side, ai_depth):
+    """
+    r_c: string like 'r,c' when user clicks a cell from the SVG.
+    mode: 'local' or 'ai'
+    ai_side: 'black' or 'white' (AI plays which color when mode=='ai')
+    """
+    global STATE
+    if r_c is None or r_c=="":
+        return render_svg(STATE.board, STATE.selected), STATE.turn, "", STATE.to_json(), ""
+    
+    r,c = map(int, r_c.split(','))
+    
+    # If nothing selected, select piece if it belongs to player
+    if STATE.selected is None:
+        if STATE.board[r][c]*STATE.turn>0:
+            STATE.selected = (r,c)
+        return render_svg(STATE.board, STATE.selected), STATE.turn, "", STATE.to_json(), ""
+    else:
+        # attempt to make move from selected to r,c
+        moves = STATE.generate_moves(STATE.turn)
+        chosen = None
+        for m in moves:
+            if m[0]==STATE.selected[0] and m[1]==STATE.selected[1] and m[2]==r and m[3]==c:
+                chosen = m
+                break
+        
+        if chosen:
+            STATE.apply_move(chosen)
+            STATE.selected = None
+            ov, winner = STATE.game_over()
+            if ov:
+                return render_svg(STATE.board, None), STATE.turn, f'Game over. Winner: {"White" if winner==1 else "Black"}', STATE.to_json(), ""
+            
+            # If AI mode and it's AI's turn, compute AI move
+            if mode=='ai':
+                side = -1 if ai_side=='black' else 1
+                if STATE.turn==side:
+                    mv = ai_best_move(STATE, depth=ai_depth)
+                    if mv:
+                        STATE.apply_move(mv)
+                        ov,winner = STATE.game_over()
+                        if ov:
+                            return render_svg(STATE.board, None), STATE.turn, f'Game over. Winner: {"White" if winner==1 else "Black"}', STATE.to_json(), ""
+            
+            return render_svg(STATE.board, None), STATE.turn, "", STATE.to_json(), ""
+        else:
+            # clicked invalid target => change selection if clicking own piece
+            if STATE.board[r][c]*STATE.turn>0:
+                STATE.selected = (r,c)
+            else:
+                STATE.selected = None
+            return render_svg(STATE.board, STATE.selected), STATE.turn, "Invalid move", STATE.to_json(), ""
+
+def new_game():
+    global STATE
+    STATE = Game()
+    return render_svg(STATE.board, None), STATE.turn, "New game started.", STATE.to_json(), ""
+
+def undo_action():
+    global STATE
+    STATE.undo()
+    return render_svg(STATE.board, None), STATE.turn, "Undo.", STATE.to_json(), ""
+
+def load_state(s):
+    global STATE
+    try:
+        STATE = Game.from_json(s)
+        return render_svg(STATE.board, None), STATE.turn, "Loaded.", STATE.to_json(), ""
+    except Exception as e:
+        return render_svg(STATE.board, None), STATE.turn, f'Load failed: {e}', STATE.to_json(), ""
+
+def export_state():
+    return STATE.to_json()
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Turkish Dama (Draughts) — Gradio Space\nPlay local 2-player or single-player vs AI. Click a piece, then click destination.")
     with gr.Row():
+        board_svg = gr.HTML(render_svg(STATE.board))
+        with gr.Column():
+            mode = gr.Radio(['local','ai'], value='local', label='Mode')
+            ai_side = gr.Radio(['black','white'], value='black', label='AI plays')
+            ai_depth = gr.Slider(minimum=1, maximum=4, value=3, step=1, label='AI depth (strength)')
+            new_btn = gr.Button('New Game')
+            undo_btn = gr.Button('Undo')
+            status = gr.Textbox(label='Status', value='')
+            export_btn = gr.Button('Export Game (JSON)')
+            export_out = gr.Textbox(label='Exported JSON')
+            import_in = gr.Textbox(label='Import Game (paste JSON)')
+            import_btn = gr.Button('Load')
+
+    # Hidden state exchange
+    state_json = gr.State(value=STATE.to_json())
+
+    # Create 8x8 invisible buttons grid for clicks (works but not pretty)
+    btns = []
+    for r in range(BOARD_SIZE):
+        row = []
+        with gr.Row():
+            for c in range(BOARD_SIZE):
+                b = gr.Button(f'{r},{c}', elem_id=f'cell_{r}_{c}', visible=True)
+                row.append(b)
+        btns.append(row)
+
+    # Wire buttons
+    for r in range(BOARD_SIZE):
         for c in range(BOARD_SIZE):
-            b = gr.Button(f'{r},{c}', elem_id=f'cell_{r}_{c}', visible=True)
-            row.append(b)
-    btns.append(row)
-
-# Wire buttons
-for r in range(BOARD_SIZE):
-    for c in range(BOARD_SIZE):
-        btns[r][c].click(fn=lambda rc=f"{r},{c}", mode_comp=mode, ai_side_comp=ai_side, depth_comp=ai_depth: click_cell(rc, mode_comp, ai_side_comp, int(depth_comp)), inputs=[], outputs=[board_svg, gr.Textbox.update, status, state_json, export_out])
+            btns[r][c].click(fn=lambda rc=f"{r},{c}", mode_comp=mode, ai_side_comp=ai_side, depth_comp=ai_depth: click_cell(rc, mode_comp, ai_side_comp, int(depth_comp)),
+                             inputs=[gr.Textbox(visible=False), mode, ai_side, ai_depth],
+                             outputs=[board_svg, status, state_json, export_out])
 
-new_btn.click(new_game, inputs=[], outputs=[board_svg, gr.Textbox.update, status, state_json, export_out])
-undo_btn.click(undo_action, inputs=[], outputs=[board_svg, gr.Textbox.update, status, state_json, export_out])
-export_btn.click(lambda: STATE.to_json(), inputs=[], outputs=[export_out])
-import_btn.click(lambda s=import_in: load_state(s), inputs=[import_in], outputs=[board_svg, gr.Textbox.update, status, state_json, export_out])
+    new_btn.click(new_game, inputs=[], outputs=[board_svg, status, state_json, export_out])
+    undo_btn.click(undo_action, inputs=[], outputs=[board_svg, status, state_json, export_out])
+    export_btn.click(export_state, inputs=[], outputs=[export_out])
+    import_btn.click(load_state, inputs=[import_in], outputs=[board_svg, status, state_json, export_out])
 
-gr.Markdown("---\nControls: Click a piece then click a destination. Use 'Export Game' to get JSON that you can save, and 'Load' to restore a saved game.")
+    gr.Markdown("---")
+    gr.Markdown("Controls: Click a piece then click a destination. Use 'Export Game' to get JSON that you can save, and 'Load' to restore a saved game.")
 
 demo.launch()
-