Upload 10 files

app.py

@@ -0,0 +1,48 @@
+import gradio as gr
+import chess
+import chess.svg
+from PIL import Image
+import io
+import cairosvg
+
+from main import get_moves   # your engine wrapper
+
+
+def predict_from_image(img):
+    # Save uploaded image
+    img = img.convert("RGB")
+    img.save("board.png", format="PNG")
+
+    # Your function should return (fen, moves)
+    fen, moves = get_moves("board.png")
+
+    # Convert FEN -> SVG -> PNG for Gradio display
+    board = chess.Board(fen)
+    svg_data = chess.svg.board(board=board, size=350)
+
+    # convert svg to png (since Gradio Image widget expects raster)
+    png_bytes = cairosvg.svg2png(bytestring=svg_data)
+    board_img = Image.open(io.BytesIO(png_bytes))
+
+    return fen, str(moves), board_img
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# ♟️ Chess AI from Image")
+
+    with gr.Row():
+        image = gr.Image(type="pil", label="Upload Chessboard Image")
+        board_display = gr.Image(type="pil", label="Detected Board")
+
+    fen_out = gr.Textbox(label="Detected FEN")
+    moves_out = gr.Textbox(label="Predicted Best Moves")
+
+    btn = gr.Button("Analyze Board")
+
+    btn.click(
+        fn=predict_from_image,
+        inputs=image,
+        outputs=[fen_out, moves_out, board_display]
+    )
+
+demo.launch()

chess_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63c90c04c52375c9ed51bf5e36c1c1214e8c7bf3116c633fa3660e2059d261d7
+size 261952

engine.py

@@ -0,0 +1,752 @@
+"""
+this file contains all details of game state and other parametrs
+"""
+class GameState():
+    def __init__(self,board=[[]]):
+        self.board=[['bR','bN','bB','bQ','bK','bB','bN','bR'],
+                    ['bp','bp','bp','bp','bp','bp','bp','bp'],
+                    ['--','--','--','--','--','--','--','--'],
+                    ['--','--','--','--','--','--','--','--'],
+                    ['--','--','--','--','--','--','--','--'],
+                    ['--','--','--','--','--','--','--','--'],
+                    ['wp','wp','wp','wp','wp','wp','wp','wp'],
+                    ['wR','wN','wB','wQ','wK','wB','wN','wR']
+                    ]
+        
+        if self.is_valid_board(board):
+            self.board=board
+            
+        self.whiteToMove=True
+        self.moveLog=[]
+        self.knight_directions=[(-2, -1), (-1, -2), (-2, 1), (-1, 2), (2, -1), (1, -2), (2, 1), (1, 2)]
+        self.bishop_directions= [(-1,-1),(-1,1),(1,-1),(1,1)]
+        self.king_directions=[(-1,0),(0,-1),(1,0),(0,1),(-1,-1),(-1,1),(1,-1),(1,1)]
+        self.check_mate = False
+        self.steale_mate = False
+        self.inheck = False  # if king is in check this will be True
+        self.pins=[]  # if any peice stopping the check and if u move them u gona get check 
+        self.checks=[]   # possible checks 
+        # we need to keep track of squares where u can eliminate if u took double move in the first place 
+        #that move name is empassant move
+        # we can have dictionary to store functions
+        
+        self.protects=[[]]
+        self.threatens =[[]]
+        self.peices_can_move_to = [[]]
+        
+        
+        self.move_functions={'p':self.get_pawn_moves,
+                             'R':self.get_rook_moves,
+                             'N':self.get_knight_moves,
+                             'B':self.get_bishop_moves,
+                             'K':self.get_king_moves,
+                             'Q':self.get_queen_moves
+                             }
+        #solution 1 to checks is keep track of kings location
+        self.black_king_location=(0,4)
+        self.white_king_location=(7,4)
+        # we need to keep track of squares where u can eliminate if u took double move in the first place 
+        #that move name is empassant move
+        # we can have dictionary to store functions
+        self.empassant_moves=()  #square for which empassant move is possible
+        self.current_castling_rights = Castling_Rights(True,True,True,True)
+        self.castle_rights_log=[Castling_Rights(self.current_castling_rights.wks,self.current_castling_rights.wqs,self.current_castling_rights.bks,self.current_castling_rights.bqs)]
+        self.empassant_possible_log=[self.empassant_moves]
+        # when current castling rights modified it creates new object and pt it in log 
+        
+        
+        
+        
+    '''
+    To castle, your king and the chosen rook must not have moved, 
+    there must be no pieces between them, 
+    the king cannot be in or pass through check, 
+    and the king must not end up in check.
+    castle must be first move to both king and rook
+    this is the only move where two peice move 
+    
+    '''
+    def make_move(self,move): #this is not for castling and pawn promotion just to add it for squares 
+        self.board[move.start_row][move.start_col]= '--'
+        self.board[move.end_row][move.end_col]= move.peice_moved
+        if move.peice_moved=='bK':
+            self.black_king_location= (move.end_row,move.end_col)
+        if move.peice_moved=="wK":
+            self.white_king_location= (move.end_row,move.end_col)
+            
+        if move.is_pawn_promotion:
+            self.board[move.end_row][move.end_col] = move.peice_moved[0]+ move.promotion_choice
+        
+        #castle move 
+        if move.castle:
+            if move.end_col - move.start_col ==2: #king side col
+                self.board [move.end_row][move.end_col-1]= self.board[move.end_row][move.end_col+1]
+                self.board[move.end_row][move.end_col+1]='--'
+            else:
+                self.board [move.end_row][move.end_col+1]= self.board[move.end_row][move.end_col-2] #2 squares aqay from it starts
+                self.board[move.end_row][move.end_col-2]='--'
+                
+        
+        #empassant move 
+        if move.is_empassant_move: # remove square that is not captured but on the road
+            self.board[move.start_row][move.end_col] = '--'  # capturing the pawn 
+        
+        #update empassant possible 
+        #only in the case 
+        if move.peice_moved[1] == 'p' and abs(move.start_row-move.end_row)==2:
+            self.empassant_moves=( (move.start_row + move.end_row)//2 ,move.end_col )
+            
+        else:
+            self.empassant_moves = ()
+            
+        #update castling rights  whenever is is king or rook moves 
+        self.update_castle_rights(move)
+        self.castle_rights_log.append(Castling_Rights(self.current_castling_rights.wks,self.current_castling_rights.wqs,self.current_castling_rights.bks,self.current_castling_rights.bqs))
+        self.empassant_possible_log.append(self.empassant_moves)
+        self.moveLog.append(move)
+        self.whiteToMove = not self.whiteToMove #switch turns 
+    '''
+    undo the previous move made 
+    '''
+    def undo_move(self):
+        if len(self.moveLog):
+            l_move = self.moveLog.pop()
+            self.whiteToMove = not self.whiteToMove
+            self.board[l_move.end_row][l_move.end_col]=l_move.peice_captured
+            self.board[l_move.start_row][l_move.start_col]=l_move.peice_moved 
+            move=l_move
+            if move.peice_moved=='bK':
+                self.black_king_location= (move.start_row,move.start_col)
+            if move.peice_moved=="wK":
+                self.white_king_location= (move.start_row,move.start_col)
+            if move.is_empassant_move:
+                self.board[l_move.end_row][l_move.end_col] = '--' #leave end row and column as it is 
+                self.board[l_move.start_row][l_move.end_col]= move.peice_captured
+            
+            self.empassant_possible_log.pop()
+            self.empassant_moves = self.empassant_possible_log[-1]
+                
+            if move.castle:
+            
+                if move.end_col - move.start_col ==2: #king side col
+                    self.board [move.end_row][move.end_col+1]= self.board[move.end_row][move.end_col-1]
+                    self.board[move.end_row][move.end_col-1]='--'
+                else:
+                    self.board [move.end_row][move.end_col-2]= self.board[move.end_row][move.end_col+1] #2 squares aqay from it starts
+                    self.board[move.end_row][move.end_col+1]='--'
+                
+            
+            ## undo the castling rights 
+            self.castle_rights_log.pop()  #get rid of new castle rights 
+            self.current_castling_rights = self.castle_rights_log[-1]
+
+            #undo checkmate move 
+            self.check_mate = False
+            self.steale_mate = False
+            
+                
+                
+        else:
+            print("this is our starting move ")
+    #if u move then it might be check to u so need to check these possiblities 
+    #so we need to generate possible moves in next turn abd based on that we need to move
+    
+    def is_valid_board(self,board):
+    # must be list of 8 rows
+        if len(board) != 8:
+            return False
+        for row in board:
+            # each row must have 8 columns
+            if len(row) != 8:
+                return False
+            # check no element is empty
+            if any(cell in [None, "", "-"] for cell in row):
+                return False
+        return True
+ 
+    '''
+    all moves including checks
+    '''
+    def update_castle_rights(self,move):
+        if move.peice_moved=='wK':
+            self.current_castling_rights.wks=False
+            self.current_castling_rights.wqs=False
+        elif move.peice_moved=='bK':
+            self.current_castling_rights.bks=False
+            self.current_castling_rights.bqs=False
+        elif move.peice_moved=='wR' and move.start_row==0: 
+            if move.start_col==7:
+                self.current_castling_rights.wks=False
+            elif move.start_col==0:
+                self.current_castling_rights.wqs=False
+        elif move.peice_moved=='bR' and move.start_row==7: 
+            if move.start_col==7:
+                self.current_castling_rights.bks=False
+            elif move.start_col==0:
+                self.current_castling_rights.bqs=False
+        
+        # if rook is captured
+        if move.peice_captured == 'wR':
+            if move.end_row == 7:
+                if move.end_col == 0:
+                    self.current_castling_rights.wqs=False
+                elif move.end_col == 7:
+                    self.current_castling_rights.wks = False
+        elif move.peice_captured == 'bR':
+            if move.end_row == 0:
+                if move.end_col == 0:
+                    self.current_castling_rights.bqs=False
+                elif move.end_col == 7:
+                    self.current_castling_rights.bks = False
+                
+            
+            
+            
+        
+    def is_valid_square(self,r,c):
+        if r>=0 and r<=7 and c>=0 and c<=7:
+            return True
+        else:
+            return False
+    
+    def king_safety(self, color):
+        board = self.board
+        score = 0
+
+        # Find king position
+        king_pos = None
+        for r in range(8):
+            for c in range(8):
+                if board[r][c] == color + 'K':
+                    king_pos = (r, c)
+                    break
+            if king_pos:
+                break
+
+        if not king_pos:
+            return 0  # King missing? shouldn't happen.
+
+        r, c = king_pos
+
+        # Pawn shield (pawns in front of king)
+        if color == 'w':
+            pawn_row = r - 1
+            if pawn_row >= 0:
+                for dc in [-1, 0, 1]:
+                    cc = c + dc
+                    if 0 <= cc < 8:
+                        if board[pawn_row][cc] == 'wp':
+                            score += 30   # strong pawn shield
+                        elif board[pawn_row][cc] == '--':
+                            score -= 15   # weak if missing
+        else:  # black
+            pawn_row = r + 1
+            if pawn_row < 8:
+                for dc in [-1, 0, 1]:
+                    cc = c + dc
+                    if 0 <= cc < 8:
+                        if board[pawn_row][cc] == 'bp':
+                            score += 30
+                        elif board[pawn_row][cc] == '--':
+                            score -= 15
+
+        # Open file penalty (if no pawn in king’s file)
+        file_has_pawn = False
+        for rr in range(8):
+            if board[rr][c] == color + 'p':
+                file_has_pawn = True
+                break
+        if not file_has_pawn:
+            score -= 40  # open file in front of king is dangerous
+
+        # Enemy attacks around the king (adjacent squares)
+        king_zone = [(r + dr, c + dc) for dr in [-1, 0, 1] for dc in [-1, 0, 1] if not (dr == 0 and dc == 0)]
+        enemy_color = 'w' if color == 'b' else 'b'
+        for (rr, cc) in king_zone:
+            if 0 <= rr < 8 and 0 <= cc < 8:
+                self.whiteToMove = not self.whiteToMove
+                moves = self.get_all_possible_moves()
+                for move in moves:
+                    if (move.end_row, move.end_col) == (rr, cc):
+                        score -= 20  # enemy attacks near king
+                self.whiteToMove = not self.whiteToMove
+
+        return score
+
+    
+    def get_valid_moves(self):
+        
+        #naive solution
+        #this is very inefficient and generate all moves in two levels for check 
+        #generate all moves 
+        # for all moves try to generate next possible moves
+        #for each opponent move check if he can attack your king
+        #if my king is attacked then it is invalid 
+        
+          
+        # # if u are removing then it is better to traverse list backwards 
+        # #indexes wont shift 
+        # for i in range(len(moves)-1,-1,-1):
+        #     self.make_move(moves[i])
+        #     #swap turns so this will check my check moves 
+        #     self.whiteToMove = not self.whiteToMove
+        #     if self.has_check():
+        #         moves.remove(moves[i])
+        #     self.whiteToMove = not self.whiteToMove
+        #     self.undo_move()
+        
+        # decide algo2 
+        #check for all verticals,horizantals,diagnols  and which peices can attack king
+        #check for kinght attacks 
+        #check for direct checks 
+        #check for if i move this peice can i got any check
+        #ckeck for check where u have to move 
+        self.incheck,self.pins,self.checks = self.check_for_pins_and_checks()
+        if self.whiteToMove:
+            king_row,king_col = self.white_king_location
+        else:
+            king_row,king_col = self.black_king_location
+        if self.incheck:
+            if len(self.checks)==1:
+                
+                moves = self.get_all_possible_moves() 
+                check_row,check_col,x_dist,y_dist = self.checks[0]
+                
+                peice_checking = self.board[check_row][check_col]
+                valid_squares=[]
+                if peice_checking[1]=='N':
+                    valid_squares=[(check_row,check_col)]
+                else:
+                    for i in range(1,8):
+                        valid_square = (king_row + i*x_dist , king_col + i*y_dist)
+                        valid_squares.append(valid_square)
+                        if valid_square[0] == check_row and valid_square[1]==check_col:   #once u get to peice and checks
+                            break
+                for i in range(len(moves)-1,-1,-1):
+                    if moves[i].peice_moved[1] != 'K':
+                        if not ( moves[i].end_row,moves[i].end_col) in valid_squares:  #these moves not blobk check so no need
+                            moves.remove(moves[i])
+            else: # double check king has to move
+                moves=[]
+                moves=self.get_king_moves(king_row,king_col,moves)
+        else:
+            
+            moves = self.get_all_possible_moves() # no check so all moves are fine
+        if self.whiteToMove:
+            self.get_castle_moves(self.white_king_location[0],self.white_king_location[1],moves,'w')
+        else:
+            self.get_castle_moves(self.black_king_location[0],self.black_king_location[1],moves,'b')
+            
+
+        
+        
+        
+        if len(moves)==0:   #either check mate or stealmate
+            if self.has_check():
+                self.check_mate=True
+            else:
+                self.steale_mate=True
+        else:
+            self.check_mate=False
+            self.steale_mate=False
+        
+        return moves 
+    '''
+    determine if current player in check
+    if player in check need to remove check otherwise game over
+    '''
+    
+    def check_for_pins_and_checks(self):
+        pins=[]
+        checks=[]
+        incheck=False
+        if self.whiteToMove:
+            my_color='w'
+            enemy_color='b'
+            start_row,start_col = self.white_king_location
+        else:
+            my_color='b'
+            enemy_color='w'
+            start_row,start_col = self.black_king_location
+            
+        for j,(x,y) in enumerate(self.king_directions):
+            possible_pins = ()
+            for i in range(1,8):
+                new_x,new_y = start_row+ x*i , start_col + y*i
+                if self.is_valid_square(new_x,new_y):
+                    end_peice = self.board[new_x][new_y]
+                    if end_peice[0]==my_color and end_peice[1]!='K':
+                        if possible_pins == (): #first pin could be found 
+                            possible_pins = (new_x,new_y,x,y) #
+                        else: # 2nd allied peice or no pins break
+                            break 
+                    elif end_peice[0] == enemy_color :
+                        type = end_peice[1]
+                        #5 possibilities here in this complex situation 
+                        # orthogonnaly rook
+                        # diagonally king
+                        #anywhere king
+                        # pawn or king at one square distance 
+                        #any direction 1 square away and peice is a king (necessary to not to go in other king's controlled square)
+                        
+   
+                        if (0<=j<=3 and type=='R') or \
+                        (4<=j<=7 and type=='B') or \
+                        (type=='Q') or \
+                        (i==1 and type=='K') or \
+                        (i==1 and type=='p' and (
+                            (enemy_color=='w' and j in [6,7]) or
+                            (enemy_color=='b' and j in [4,5])
+                        )):
+                            if possible_pins == ():
+                                incheck = True
+                                checks.append((new_x,new_y,x,y))
+                            else:
+                                pins.append(possible_pins)
+                                break
+                        else:
+                            break
+                    
+                else:
+                    break
+            
+            
+                        
+        for x,y in self.knight_directions:
+            new_x,new_y =  start_row + x,start_col + y
+            if self.is_valid_square(new_x,new_y):
+                end_peice = self.board[new_x][new_y]
+                if end_peice[1]== 'N' and end_peice[0]==enemy_color:  #kinght attack king
+                    incheck=True
+                    
+                    checks.append((new_x,new_y,x,y))
+        
+        return incheck,pins,checks
+
+    def has_check(self):
+        if self.whiteToMove:
+            return self.square_under_attack(self.white_king_location[0],self.white_king_location[1])
+        else:
+            return self.square_under_attack(self.black_king_location[0],self.black_king_location[1])
+        pass
+        
+    '''
+    this determines if enemy can attack this square
+    '''
+    def square_under_attack(self,r,c):
+        self.whiteToMove = not self.whiteToMove  #change to my opponent
+        opp_moves = self.get_all_possible_moves()
+        for move in opp_moves:
+            if move.end_row == r and move.end_col == c:
+                self.whiteToMove = not self.whiteToMove 
+                return True
+        self.whiteToMove = not self.whiteToMove 
+        return False
+            
+        
+        
+    '''
+    all moves without checks 
+    for each possible move check to see if it is a valid move by doing the following 
+    make a move 
+    generate moves for opposite player 
+    see if any of ur moves ur king is attacked
+    king is move add valid move to the list 
+    '''
+    def get_all_possible_moves(self):
+        moves=[]
+        for r in range(len(self.board)):
+            for c in range(len(self.board[r])):
+                turn = self.board[r][c][0]
+                if (turn == 'w' and self.whiteToMove) or (turn=='b' and not self.whiteToMove):
+                    peice = self.board[r][c][1]
+                    self.move_functions[peice](r,c,moves) #calls the appropriate move functions
+        return moves
+    '''
+    this func return  the pawn moves for particular pawn
+    '''
+    def get_pawn_moves(self,r,c,moves: list):
+        peice_pinned = False
+        pin_direction = ()
+        for i in range(len(self.pins)-1,-1,-1):
+            if self.pins[i][0] == r and self.pins[i][1]==c:
+                peice_pinned=True
+                pin_direction = (self.pins[i][2],self.pins[i][3])
+                self.pins.remove(self.pins[i])
+                break
+        if self.whiteToMove:
+            if r == 6 :
+                if not peice_pinned or pin_direction == (-1,0):
+                    if self.board[4][c]=='--' and self.board[5][c]=='--':
+                        moves.append(Move((6,c),(4,c),self.board))
+            if self.board[r-1][c]=='--':
+                if not peice_pinned or pin_direction == (-1,0):
+                        moves.append(Move((r,c),(r-1,c),self.board))
+            if c>=1: 
+                if not peice_pinned or pin_direction == (-1,-1):
+                    if self.board[r-1][c-1][0]=='b':
+                        moves.append(Move((r,c),(r-1,c-1),self.board))
+                    elif  (r-1,c-1)==self.empassant_moves:
+                        moves.append(Move((r,c),(r-1,c-1),self.board,is_empassant_move=True))
+            if c<=6 :
+                if not peice_pinned or pin_direction == (-1,+1):
+                    if self.board[r-1][c+1][0]=='b':
+                        moves.append(Move((r,c),(r-1,c+1),self.board))
+                    elif  (r-1,c+1)==self.empassant_moves:
+                        moves.append(Move((r,c),(r-1,c+1),self.board,is_empassant_move=True))
+        else :
+            if not peice_pinned or pin_direction == (1,0):
+                if self.board[r+1][c]=='--':
+                    moves.append(Move((r,c),(r+1,c),self.board))
+                if r == 1:
+                    if self.board[3][c]=='--' and self.board[2][c]=='--':
+                        moves.append(Move((1,c),(3,c),self.board))
+            if not peice_pinned or pin_direction == (1,-1):
+                if c>=1:
+                    if self.board[r+1][c-1][0]=='w':
+                        moves.append(Move((r,c),(r+1,c-1),self.board))
+                    elif  (r+1,c-1)==self.empassant_moves:
+                        moves.append(Move((r,c),(r+1,c-1),self.board,is_empassant_move=True))
+            if not peice_pinned or pin_direction == (1,1):
+                if c<=6 :
+                    if  self.board[r+1][c+1][0]=='w':
+                        moves.append(Move((r,c),(r+1,c+1),self.board))
+                    elif  (r+1,c+1)==self.empassant_moves:
+                        moves.append(Move((r,c),(r+1,c+1),self.board,is_empassant_move=True))
+        return moves
+    '''
+    this func return  the rook moves for particular rook
+    '''
+    def get_rook_moves(self,r,c,moves):
+        peice_pinned = False
+        pin_direction = ()
+        for i in range(len(self.pins)-1,-1,-1):
+            if self.pins[i][0] == r and self.pins[i][1]==c:
+                peice_pinned=True
+                pin_direction = (self.pins[i][2],self.pins[i][3])
+                if self.board[r][c][1]!='Q':  #cannot remove queen from pin on rook moves ,onl remove it from bishop moves
+                    self.pins.remove(self.pins[i])
+                break
+        if self.whiteToMove:
+            ur_symbol= 'w'
+            opp = 'b'
+        else:
+            ur_symbol= 'b'
+            opp = 'w'
+        for x,y in [(-1,0),(1,0),(0,1),(0,-1)]:
+            for i in range(1,8):
+                new_x,new_y = r + x*i ,c + y*i
+                if not self.is_valid_square(new_x,new_y):
+                    break
+                else:
+                    if not peice_pinned or pin_direction == (x,y) or pin_direction == (-x,-y):
+                        if self.board[new_x][new_y][0]=='-':
+                            moves.append(Move((r,c),(new_x,new_y),self.board))
+                        elif self.board[new_x][new_y][0]==opp:
+                            moves.append(Move((r,c),(new_x,new_y),self.board))
+                            break
+                        else :
+                            break
+        return moves
+            
+    '''
+    this func return  the knight moves for particular rook
+    '''
+    
+    
+    def get_knight_moves(self,r,c,moves):
+        peice_pinned = False
+        
+        for i in range(len(self.pins)-1,-1,-1):
+            if self.pins[i][0] == r and self.pins[i][1]==c:
+                peice_pinned=True
+                self.pins.remove(self.pins[i])
+                break
+        
+        if self.whiteToMove:
+            ur_symbol= 'w'
+            opp = 'b'
+        else:
+            ur_symbol= 'b'
+            opp = 'w'
+        for x,y in self.knight_directions:
+            new_x,new_y = r+x,c+y
+            if (self.is_valid_square(new_x,new_y)):
+                if not peice_pinned:
+                    if self.board[new_x][new_y][0]!=ur_symbol:
+                        moves.append(Move((r,c),(new_x,new_y),self.board))
+        return moves
+    '''
+    this func return  the bishop moves for particular rook
+    '''
+    def get_bishop_moves(self,r,c,moves):
+        peice_pinned = False
+        pin_direction = ()
+        for i in range(len(self.pins)-1,-1,-1):
+            if self.pins[i][0] == r and self.pins[i][1]==c:
+                peice_pinned=True
+                pin_direction = (self.pins[i][2],self.pins[i][3])
+                self.pins.remove(self.pins[i])
+                break
+        if self.whiteToMove:
+            ur_symbol= 'w'
+            opp = 'b'
+        else:
+            ur_symbol= 'b'
+            opp = 'w'
+        for x,y in self.bishop_directions:
+            for i in range(1,8):
+                new_x,new_y = r + x*i ,c + y*i
+                if not self.is_valid_square(new_x,new_y):
+                    break
+                else:
+                    if not peice_pinned or pin_direction == (x,y) or pin_direction == (-x,-y):
+                        if self.board[new_x][new_y][0]=='-':
+                            moves.append(Move((r,c),(new_x,new_y),self.board))
+                        elif self.board[new_x][new_y][0]==opp:
+                            moves.append(Move((r,c),(new_x,new_y),self.board))
+                            break
+                        else :
+                            break
+        return moves
+                        
+    '''
+    this func return  the king moves for particular king
+    '''
+    def get_king_moves(self,r,c,moves):
+        
+        if self.whiteToMove:
+            ur_symbol= 'w'
+            opp = 'b'
+        else:
+            ur_symbol= 'b'
+            opp = 'w'
+        for x,y in self.king_directions:
+            new_x,new_y = r+x,c+y
+            if (self.is_valid_square(new_x,new_y)):
+                if self.board[new_x][new_y][0]!=ur_symbol:
+                    if ur_symbol == 'w':
+                        self.white_king_location = (new_x,new_y)
+                    else:
+                        self.black_king_location = (new_x,new_y)
+                    incheck,pins,checks = self.check_for_pins_and_checks() #check for pins and checks and if not add the move 
+                    if not incheck:
+                        moves.append(Move((r,c),(new_x,new_y),self.board))
+                    if ur_symbol == 'w':
+                        self.white_king_location = (r,c)
+                    else:
+                        self.black_king_location = (r,c) # place king in original position                
+        return moves
+    '''
+    this func return  the queen moves for particular rook
+    '''
+    def get_queen_moves(self,r,c,moves):
+        return self.get_bishop_moves(r,c,moves) + self.get_rook_moves(r,c,moves)
+
+    
+    '''
+    generate all castle moves 
+    
+    '''
+    def get_castle_moves(self,r,c,moves,my_color):
+        if self.square_under_attack(r,c):
+            return # cannot castle if king is in check
+        if (self.whiteToMove and self.current_castling_rights.wks) or (not self.whiteToMove and self.current_castling_rights.bks):
+            self.king_side_castle_moves(r,c,moves,my_color)
+        if (self.whiteToMove and self.current_castling_rights.wqs) or (not self.whiteToMove and self.current_castling_rights.bqs):
+            self.queen_side_castle_moves(r,c,moves,my_color)
+        
+    def king_side_castle_moves(self,r,c,moves,my_color):
+        if c + 2 <= 7:
+            if self.board[r][c+1]== '--' and self.board[r][c+2]== '--':
+                if not self.square_under_attack(r,c+1) and not self.square_under_attack(r,c+2):
+                    moves.append ( Move((r,c),(r,c+2),self.board,castle=True))
+                
+                
+            
+    
+    
+    def queen_side_castle_moves(self,r,c,moves,my_color):
+        if c-3 >=0: 
+            if self.board[r][c-1]== '--' and self.board[r][c-2]== '--' and self.board[r][c-3]== '--':
+                if not self.square_under_attack(r,c-1) and not self.square_under_attack(r,c-2)  :
+                    moves.append ( Move((r,c),(r,c-2),self.board,castle=True))
+                
+'''
+make castling right class other wise difficult to include it in main code 
+'''
+class Castling_Rights():
+    def __init__(self,wks,wqs,bks,bqs):
+        self.bks=bks
+        self.bqs=bqs
+        self.wks=wks
+        self.wqs=wqs
+    
+class Move():
+    ranks_to_rows = {
+        '1':7,'2':6,'3':5,'4':4,'5':3,'6':2,'7':1,'8':0}
+    rows_to_ranks = {v:k for k,v in ranks_to_rows.items()}
+    files_to_cols = {chr(97+i):i for i in range(8)}
+    cols_to_files={v:k for k,v in files_to_cols.items()}
+    def __init__(self,startsq,endsq,board,choice='Q',is_empassant_move=False,castle=False):     #for undowing the move its better to store the board information
+        self.start_row = startsq[0]
+        self.start_col = startsq[1]
+        self.end_row = endsq[0]
+        self.end_col = endsq[1]
+        
+        self.peice_moved = board[self.start_row][self.start_col]
+        self.peice_captured = board[self.end_row][self.end_col] 
+        self.is_pawn_promotion = False
+        if (self.peice_moved == 'wp' and self.end_row==0) or (self.peice_moved == 'bp' and self.end_row==7):
+            self.is_pawn_promotion=True
+        self.promotion_choice =choice
+        self.is_empassant_move=False
+        if is_empassant_move:
+            self.is_empassant_move=True
+            self.peice_captured = 'wp' if self.peice_moved =='bp' else 'bp'
+        self.castle=castle
+        self.is_capture = self.peice_captured!='--'
+        
+        self.move_id =  self.start_row*1000 + self.start_col * 100 + self.end_row * 10 + self.end_col # generate unique id and since all below 10 we can do this   
+    #have to tell python if two moves are equal
+    '''
+    over writing a method 
+    other wise python check and they are two different objects 
+    ''' 
+    def __eq__(self, value):
+        if isinstance(value,Move):
+            return value.move_id == self.move_id
+        return False
+            
+    def get_chess_notation(self):
+        #make it to look move in chess notation 
+        return self.get_rank_file(self.start_row,self.start_col) + self.get_rank_file(self.end_row,self.end_col)
+    
+    def get_rank_file(self,r,c):
+        return self.cols_to_files[c]+ self.rows_to_ranks[r] #first column than row 
+    def __str__(self):
+        #castle move 
+        if self.castle: 
+            return "o-o" if self.end_col==6 else 'o-o-o'
+        end_square = self.get_rank_file(self.end_row,self.end_col)
+        #pawn move
+        if self.peice_moved[1] == 'p':
+            if self.is_capture:
+                return self.cols_to_files[self.start_col] + 'x'+ end_square
+            else:
+                return end_square
+        # pawn promotion
+        #Nbd2 both knights can move to d2
+        
+        # for check and checkmate
+        # peice moves 
+        move_string = self.peice_moved[1]
+        if self.is_capture:
+            move_string+='x'
+        return move_string + end_square + f"""{self.peice_moved} to {self.get_rank_file(self.end_row, self.end_col)}:{self.get_rank_file(self.start_row, self.start_col)}"""
+    
+    
+        
+        
+        
+        

final.py

@@ -0,0 +1,182 @@
+import chess.svg
+import chess
+import re
+import cv2
+import random as rd
+import numpy as np
+import matplotlib.pyplot as plt
+from tensorflow.keras.models import load_model
+import chess, chess.svg
+from pathlib import Path
+import webbrowser
+piece_symbols = 'prbnkqPRBNKQ-'
+try:
+    model = load_model('./chess_model.h5')
+    print("Model loaded successfully")
+except Exception as e:
+    print(f"Error loading model: {e}")
+    
+def onehot_from_fen(fen):
+    eye = np.eye(13)
+    output = np.empty((0, 13))
+    fen = re.sub('[-]', '', fen)
+
+    for char in fen:
+        if(char in '12345678'):
+            output = np.append(output, np.tile(eye[12], (int(char), 1)), axis=0)
+        else:
+            idx = piece_symbols.index(char)
+            output = np.append(output, eye[idx].reshape((1, 13)), axis=0)
+    return output
+import numpy as np
+import re
+
+
+
+def board_from_fen(fen):
+    board = []
+    fen = fen.split()[0]   # just the board part (ignore turn, castling, etc.)
+    
+    for row in fen.split('/'):
+        row_out = []
+        for char in row:
+            if char.isdigit():
+                # expand empty squares
+                row_out.extend([0] * int(char))
+            else:
+                idx = piece_symbols.index(char) + 1  # +1 so 0 = empty
+                row_out.append(idx)
+        board.append(row_out)
+
+    return np.array(board, dtype=np.int8)  # shape (8,8)
+
+def fen_from_onehot(one_hot):
+    output = ''
+    for j in range(8):
+        for i in range(8):
+            if(one_hot[j][i] == 12):
+                output += ' '
+            else:
+                output += piece_symbols[one_hot[j][i]]
+        if(j != 7):
+            output += '-'
+
+    for i in range(8, 0, -1):
+        output = output.replace(' ' * i, str(i))
+    return output
+
+
+def order_points(pts):
+    # Order 4 points: top-left, top-right, bottom-right, bottom-left
+    rect = np.zeros((4, 2), dtype="float32")
+    s = pts.sum(axis=1)
+    rect[0] = pts[np.argmin(s)]
+    rect[2] = pts[np.argmax(s)]
+    diff = np.diff(pts, axis=1)
+    rect[1] = pts[np.argmin(diff)]
+    rect[3] = pts[np.argmax(diff)]
+    return rect
+
+def preprocess_chessboard(image_path, target_size=(30, 30)):
+    img = cv2.imread(image_path)
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    blur = cv2.GaussianBlur(gray, (5,5), 0)
+    edges = cv2.Canny(blur, 50, 150)
+
+    # Find contours
+    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    cropped_board = None
+    warped = None
+    squares = []
+
+    if contours:
+        cnt = max(contours, key=cv2.contourArea)
+        epsilon = 0.02 * cv2.arcLength(cnt, True)
+        approx = cv2.approxPolyDP(cnt, epsilon, True)
+
+        # If we found 4 corners, warp
+        if len(approx) == 4:
+            pts = approx.reshape(4,2)
+            rect = order_points(pts)
+            board_size = 256  # fixed square board
+            dst = np.array([
+                [0, 0],
+                [board_size-1, 0],
+                [board_size-1, board_size-1],
+                [0, board_size-1]
+            ], dtype="float32")
+
+            M = cv2.getPerspectiveTransform(rect, dst)
+            warped = cv2.warpPerspective(img, M, (board_size, board_size))
+            cropped_board = warped
+        else:
+            # fallback: just resize whole image
+            warped = cv2.resize(img, (256, 256))
+            cropped_board = warped
+    else:
+        # no contours, fallback
+        warped = cv2.resize(img, (256, 256))
+        cropped_board = warped
+
+    # Split into 64 squares
+    board_size = warped.shape[0]
+    sq_size = board_size // 8
+    for row in range(8):
+        for col in range(8):
+            square = warped[row*sq_size:(row+1)*sq_size,
+                            col*sq_size:(col+1)*sq_size]
+            square = cv2.resize(square, target_size)
+            square = square / 255.0
+            squares.append(square)
+
+    return np.array(squares), cropped_board
+
+def display_with_predicted_fen(image):
+    squares,_ = preprocess_chessboard(image)
+    pred = model.predict(squares).argmax(axis=1).reshape(8, 8)
+    fen = fen_from_onehot(pred)
+    return fen
+
+def get_board_from_image(img_path):
+    image = cv2.imread(img_path)
+    if image is None:
+        print('sorry image is null')
+        return
+    ext = img_path.split('.')[-1]
+    if not (ext=='jpg' or ext == 'jpeg' or ext == 'png'):
+        print('sorry image needs to be in jpg/jpeg/png format')
+        return
+    predicted_fen = display_with_predicted_fen(img_path)
+    # Create board from predicted FEN
+    board = chess.Board(predicted_fen.replace('-','/'))
+    return predicted_fen
+def get_board_from_fen(fen:str):
+    print(type(fen))
+    fen=fen.split('-')
+    if len(fen)!=8:
+        return [[]]
+    answers = [[] for _ in range(8)]
+    map={'p':'bp','r':'bR','n':'bN','k':'bK','q':'bQ','b':'bB','P':'wp','R':'wR','N':'wN','K':'wK','Q':'wQ','B':'wB'}
+    for i,f in enumerate(fen):
+        for char in f:
+            
+            if char in '12345678':
+                answers[i].extend(['--']*(int(char)))
+            elif char in piece_symbols:
+                answers[i].append(map[char])
+    return answers
+                
+    
+def get_board(image_path):
+    fen_notation = get_board_from_image(image_path)
+    if fen_notation:
+        board = get_board_from_fen(fen_notation)
+        
+    else:
+        return [[]],""
+    return board,fen_notation.replace('-','/')
+    
+if __name__ == "__main__":
+    get_board()
+    

main.py

@@ -0,0 +1,324 @@
+import chess
+import chess.svg
+import pygame
+import engine
+from pygame import Vector2
+import move_finder
+from multiprocessing import Process,Queue
+from final import get_board
+
+move_width =200
+move_height=0
+width,height=512,512 #can be 768,768
+dimensions = 8 #chess board is 64 squares
+sq_size  = int(height/dimensions)
+max_fps=15
+images ={} 
+#load images 
+#loading image sis very expensive so load only once per game 
+# board = chess.Board('rnbqkbnr/8/8/8/8/8/8/8')
+# svg = chess.svg.board(board)
+
+# make engine that recognize legal chess move or not 
+#hopefully 2 player game
+# with open('b.svg', 'w', encoding="utf-8") as f:
+#     f.write(svg)
+
+
+'''
+load images in global dictionary .
+called exactly on the main
+'''
+def load_images():
+    peices=['bQ','bK','bB','bN','bR','wQ','wK','wB','wN','wR','bp','wp']
+    for peice in peices:
+        images[peice] = pygame.transform.scale(pygame.image.load("./images/"+peice+".png"),(sq_size,sq_size)) #cenetr peice nicely 
+        
+    # we can access an peice by calling image['wp] we added them in the dictionary
+    
+'''
+draw squares on board 
+always top left square is white
+'''
+def draw_board(screen):
+    global colors  #so that we can use them globally
+    colors = [pygame.Color('white'),pygame.Color(194, 194, 194)]
+    for r in range(dimensions):
+        for c in range(dimensions):
+            parity = (r+c) & 1
+            color = colors[parity]
+            pygame.draw.rect(screen,color,pygame.Rect(c*sq_size,r*sq_size,sq_size,sq_size))
+            
+    
+'''
+draw peices using current game state (board)
+'''
+def draw_peices(screen,board):
+    for r in range(dimensions):
+        for c in range(dimensions):
+            peice = board[r][c]
+            if peice !='--':
+                screen.blit(images[peice],pygame.Rect(c*sq_size,r*sq_size,sq_size,sq_size))
+                
+import pygame
+
+scroll_offset = 0  # global scroll variable
+
+def draw_move_log(screen, gs, width, move_width, height):
+    global scroll_offset
+    font = pygame.font.SysFont('Arial', 16, False, False)
+    move_log_rect = pygame.Rect(width, 0, move_width, height)
+
+    # Draw background
+    pygame.draw.rect(screen, pygame.Color('black'), move_log_rect)
+
+    moves = gs.moveLog
+    text_y = 5 - scroll_offset  # apply scroll offset here
+
+    for j, i in enumerate(moves):
+        text = f"{j+1}. {str(i)}"
+        text_object = font.render(text, True, pygame.Color('white'))
+        text_location = move_log_rect.move(5, text_y)
+        screen.blit(text_object, text_location)
+        text_y += text_object.get_height() + 5
+
+
+def handle_scroll(event):
+    """Handles mouse wheel scrolling"""
+    global scroll_offset
+    if event.type == pygame.MOUSEBUTTONDOWN:
+        if event.button == 4:  # scroll up
+            scroll_offset = max(0, scroll_offset - 20)
+        elif event.button == 5:  # scroll down
+            scroll_offset += 20
+
+    
+'''
+rensonsible for graphics in current game state
+'''
+def draw_game_state(screen,gs,valid_moves,sq_selected):
+    draw_board(screen)   #draw squares on board
+    high_light_squares(screen,gs,valid_moves,sq_selected)
+    draw_peices(screen,gs.board)
+    draw_move_log(screen,gs,512,200,512)
+'''
+hgihlight the square selected and moves for peices selected
+'''
+
+def high_light_squares(screen,gs,valid_moves,sqselected):
+    if sqselected != ():
+        r,c = sqselected
+        if gs.board[r][c][0] == ('w' if gs.whiteToMove else 'b'):  #sq selected is a peice 
+            # highlight selected square 
+            # use surface
+            s = pygame.Surface((sq_size,sq_size))
+            
+            s.set_alpha(100)  # transparent 
+            s.fill(pygame.Color('blue'))
+            screen.blit(s,(c*sq_size,r*sq_size))
+            # highlist moves from that square 
+            s.fill(pygame.Color('red'))
+            
+            for move in valid_moves:
+                if move.start_row == r and move.start_col==c:
+                    pygame.draw.circle(screen,pygame.Color(0,255,0),( int(sq_size*(move.end_col + 0.5)),int(sq_size*(move.end_row + 0.5))),7.5)
+                    if gs.board[move.end_row][move.end_col][0]== ('b' if gs.whiteToMove else 'w'):
+                        screen.blit(s,(sq_size*move.end_col,sq_size*move.end_row))
+            if len(gs.moveLog)>=1:
+                prev_move= gs.moveLog[-1]
+                s.set_alpha(100)  # transparent 
+                s.fill(pygame.Color('dark green'))
+                r,c = prev_move.end_row,prev_move.end_col
+                screen.blit(s,(c*sq_size,r*sq_size))
+                
+                  
+    
+#what the board does is redraw images when u move 
+#animation is simply slow the change such that u see every frame 
+
+def main():
+    pygame.init() 
+    screen = pygame.display.set_mode((width+move_width,height+move_height))
+    clock = pygame.time.Clock() #clock 
+    screen.fill(pygame.Color('white'))
+    gs = engine.GameState() #create a game state and craete variables 
+    load_images() # load only once before whilw
+    running  = True
+    sqselected = ()
+    player_clicks=[] #two squares of player clicks 
+    valid_moves = gs.get_valid_moves()
+    game_over=False
+    player_one = True  # white true , machine is playing false
+    player_two = False # similarly but for player two
+    ai_thinking = False
+    move_finder_procee = None
+    move_undone = False
+    if len(valid_moves)<=5:
+        for move in valid_moves:
+            print(move.peice_captured ,move.peice_moved, move.id)
+    move_made = False   #until the valid move we need not generate valid moves
+    # make ui changes
+    animate=False 
+    while running:
+        human_Turn = (gs.whiteToMove and player_one) or (not gs.whiteToMove and player_two)
+        for e in pygame.event.get():
+            #mouse handler
+            if e.type == pygame.QUIT:
+                running=False
+            elif e.type == pygame.MOUSEBUTTONDOWN:
+                if not game_over and human_Turn:
+                    location =pygame.mouse.get_pos() #location of mouse 
+                    col = int(location[0]//sq_size)
+                    row = int(location[1]//sq_size)
+                    if sqselected == (row,col) or col>=8: #user click same square then unmove 
+                        sqselected=()
+                        player_clicks=[]
+                    else:
+                        sqselected = (row,col)
+                        player_clicks.append(sqselected) # append for both first and second cicks 
+                    if len(player_clicks)==2: #after the second click
+                        move = engine.Move(player_clicks[0],player_clicks[1],gs.board) 
+                        for i in range(len(valid_moves)):
+                            if move==valid_moves[i]:#move is pretty cheap
+                                print("move taken",move.get_chess_notation(),"peice_moved:",gs.board[move.start_row][move.start_col])
+                                gs.make_move(valid_moves[i])
+                                move_made=True
+                                animate=True
+                                sqselected=() 
+                                player_clicks=[]
+                        if not move_made:
+                            print("invalid_move",move.get_chess_notation(),move.peice_captured,move.peice_moved) 
+                            player_clicks=[sqselected] #after move is doen reset squares 
+                    if gs.check_mate or gs.steale_mate:
+                        running=False
+                
+            #keyboard handlers
+            elif e.type == pygame.KEYDOWN:
+                if e.key == pygame.K_z:
+                    gs.undo_move()
+                    move_made=True
+                    game_over=False
+                    if ai_thinking:
+                        move_find_process.terminate()
+                        ai_thinking=False
+                    move_undone=True
+                    
+                elif e.key == pygame.K_r:
+                    gs = engine.GameState()
+                    valid_moves=gs.get_valid_moves()
+                    sqselected=()
+                    player_clicks=[]
+                    move_made=False
+                    animate=True
+                    game_over=False
+                    if ai_thinking:
+                        move_find_process.terminate()
+                        ai_thinking=False
+                    move_undone=True
+                    #reset the board 
+        # best moves 
+        if not game_over and not human_Turn and not move_undone:
+            if not ai_thinking:
+                ai_thinking = True  # threads wont share data
+                returnQueue = Queue()  # used to pass data between threads 
+                move_find_process = Process(target=move_finder.find_best_move,args=(gs,valid_moves,returnQueue)) # passing function as parameter
+                
+                move_find_process.start() #creates new thread without waiting this code tun
+            if not move_find_process.is_alive():
+                print('done thinking')
+                move = returnQueue.get()
+                if move is None:
+                    move = move_finder.random_move(valid_moves)
+                gs.make_move(move)
+                move_made = True
+                animate = True
+                ai_thinking = False           
+        if move_made:
+            valid_moves = gs.get_valid_moves()
+            if animate:
+                animateMove(gs.moveLog[-1],screen,gs.board,clock)
+                animate=False
+            print('valid_moves:',len(valid_moves))
+            if len(valid_moves)<=5:
+                for move in valid_moves:
+                    print(move.peice_captured ,move.peice_moved, move.move_id)
+            
+            move_made=False
+            move_undone = False
+            
+        draw_game_state(screen,gs,valid_moves,sqselected)  #add mouse hnadlers
+        if gs.check_mate:
+            game_over=True
+            if gs.whiteToMove:
+                draw_end_game_text(screen,'black wins by checkmate')
+            else:
+                draw_end_game_text(screen,"white wins by checkmate")
+        elif gs.steale_mate:
+            game_over=True
+            draw_end_game_text(screen,'stealmate no moves for king and no check')
+        clock.tick(max_fps)
+        pygame.display.flip()
+from pygame.math import Vector2
+
+def animateMove(move, screen, board, clock):
+    start = Vector2(move.start_col, move.start_row)
+    end = Vector2(move.end_col, move.end_row)
+    distance = end.distance_to(start)
+    frames_per_sq = 10
+    frame_count = int(distance * frames_per_sq)
+
+    for frame in range(frame_count + 1):
+        t = frame / frame_count  # in [0, 1]
+        current = start.lerp(end, t)  # linear interpolation
+        c, r = current.x, current.y
+
+        draw_board(screen)
+        draw_peices(screen, board)
+
+        # erase ending square
+        colour = colors[(move.end_row + move.end_col) & 1]
+        end_sq = pygame.Rect(move.end_col * sq_size, move.end_row * sq_size, sq_size, sq_size)
+        pygame.draw.rect(screen, colour, end_sq)
+
+        # draw captured piece if any
+        if move.peice_captured != '--':
+            if move.is_empassant_move:
+                screen.blit(images[move.peice_captured], end_sq)
+            else:
+                screen.blit(images[move.peice_captured], end_sq)
+
+        # draw moving piece at interpolated position
+        screen.blit(images[move.peice_moved],
+                    pygame.Rect(c * sq_size, r * sq_size, sq_size, sq_size))
+
+        pygame.display.flip()
+        clock.tick(120)
+
+def draw_end_game_text(screen,text):
+    font = pygame.font.SysFont('Helvitca',32,True,False)
+    text_object = font.render(text,0,pygame.Color('Gray'))
+    text_location = pygame.Rect(0,0,width,height).move(width/2,height/2)
+    screen.blit(text_object,text_location)
+    text_object = font.render(text,0,pygame.Color('Black'))
+    screen.blit(text_object,text_location.move(2,2))
+    
+def get_moves(image_path):
+    board,fen = get_board(image_path)
+    gs= engine.GameState(board)
+    moves = move_finder.get_best_n_moves(gs)
+    
+    gs.whiteToMove = not gs.whiteToMove
+    moves2 = move_finder.get_best_n_moves(gs)
+    colour = ('white_moves','black_moves') if not gs.whiteToMove  else ('black_moves','white_moves') 
+    return fen, {colour[0]:moves,colour[1]:moves2}
+
+if __name__=='__main__':
+    #handle and update graphics and input
+    #whenever u import this module else where  this wont run this fucntion 
+    #main()
+    get_moves('./image.png')
+    
+    
+    
+    
+

move_finder.py

@@ -0,0 +1,510 @@
+import random
+
+
+piece_score = {'K': 1000, 'Q': 900, 'R': 500, 'B': 330, 'N': 320, 'p': 100,'--':0,'-':0}
+CHECKMATE = 100000
+STALEMATE = 0
+DEPTH = 3
+
+
+# Pawn (p = 100)
+pawn_table = [
+    [  0,  0,  0,  0,  0,  0,  0,  0],
+    [  5, 10, 10,-20,-20, 10, 10,  5],
+    [  5, -5,-10,  0,  0,-10, -5,  5],
+    [  0,  0,  0, 20, 20,  0,  0,  0],
+    [  5,  5, 10, 25, 25, 10,  5,  5],
+    [ 10, 10, 20, 30, 30, 20, 10, 10],
+    [ 50, 50, 50, 50, 50, 50, 50, 50],
+    [  0,  0,  0,  0,  0,  0,  0,  0]
+]
+
+# Knight (N = 320)
+knight_table = [
+    [-50,-40,-30,-30,-30,-30,-40,-50],
+    [-40,-20,  0,  0,  0,  0,-20,-40],
+    [-30,  0, 10, 15, 15, 10,  0,-30],
+    [-30,  5, 15, 20, 20, 15,  5,-30],
+    [-30,  0, 15, 20, 20, 15,  0,-30],
+    [-30,  5, 10, 15, 15, 10,  5,-30],
+    [-40,-20,  0,  5,  5,  0,-20,-40],
+    [-50,-40,-30,-30,-30,-30,-40,-50]
+]
+
+# Bishop (B = 330)
+bishop_table = [
+    [-20,-10,-10,-10,-10,-10,-10,-20],
+    [-10,  5,  0,  0,  0,  0,  5,-10],
+    [-10, 10, 10, 10, 10, 10, 10,-10],
+    [-10,  0, 10, 10, 10, 10,  0,-10],
+    [-10,  5,  5, 10, 10,  5,  5,-10],
+    [-10,  0,  5, 10, 10,  5,  0,-10],
+    [-10,  0,  0,  0,  0,  0,  0,-10],
+    [-20,-10,-10,-10,-10,-10,-10,-20]
+]
+
+# Rook (R = 500)
+rook_table = [
+    [  0,  0,  0,  0,  0,  0,  0,  0],
+    [  5, 10, 10, 10, 10, 10, 10,  5],
+    [ -5,  0,  0,  0,  0,  0,  0, -5],
+    [ -5,  0,  0,  0,  0,  0,  0, -5],
+    [ -5,  0,  0,  0,  0,  0,  0, -5],
+    [ -5,  0,  0,  0,  0,  0,  0, -5],
+    [ -5,  0,  0,  0,  0,  0,  0, -5],
+    [  0,  0,  0,  5,  5,  0,  0,  0]
+]
+
+# Queen (Q = 900)
+queen_table = [
+    [-20,-10,-10, -5, -5,-10,-10,-20],
+    [-10,  0,  0,  0,  0,  5,  0,-10],
+    [-10,  0,  5,  5,  5,  5,  5,-10],
+    [ -5,  0,  5,  5,  5,  5,  0, -5],
+    [  0,  0,  5,  5,  5,  5,  0, -5],
+    [-10,  5,  5,  5,  5,  5,  0,-10],
+    [-10,  0,  5,  0,  0,  0,  0,-10],
+    [-20,-10,-10, -5, -5,-10,-10,-20]
+]
+
+# King (K = 1000) – Middlegame
+king_table_mid = [
+    [-30,-40,-40,-50,-50,-40,-40,-30],
+    [-30,-40,-40,-50,-50,-40,-40,-30],
+    [-30,-40,-40,-50,-50,-40,-40,-30],
+    [-30,-40,-40,-50,-50,-40,-40,-30],
+    [-20,-30,-30,-40,-40,-30,-30,-20],
+    [-10,-20,-20,-20,-20,-20,-20,-10],
+    [ 20, 20,  0,  0,  0,  0, 20, 20],
+    [ 20, 30, 10,  0,  0, 10, 30, 20]
+]
+
+# King (K = 1000) – Endgame
+king_table_end = [
+    [-50,-40,-30,-20,-20,-30,-40,-50],
+    [-30,-20,-10,  0,  0,-10,-20,-30],
+    [-30,-10, 20, 30, 30, 20,-10,-30],
+    [-30,-10, 30, 40, 40, 30,-10,-30],
+    [-30,-10, 30, 40, 40, 30,-10,-30],
+    [-30,-10, 20, 30, 30, 20,-10,-30],
+    [-30,-30,  0,  0,  0,  0,-30,-30],
+    [-50,-30,-30,-30,-30,-30,-30,-50]
+]
+
+king_scores = [[0]*8 for _ in range(8)]
+for r in range(8):
+    for c in range(8):
+        king_scores[r][c]= king_table_end[r][c]+ king_table_end[r][c]
+for r in range(4):
+    for c in range(8):
+        pawn_table[r][c],pawn_table[7-r][c]=pawn_table[r][c],pawn_table[7-r][c]
+    
+
+
+
+peice_position_scores = {'N':knight_table,'K':king_scores,'N':knight_table,'B':bishop_table,'Q':queen_table,'p':pawn_table,'R':rook_table}
+
+'''
+use openings 
+use numpy and better board representation
+better use p.q or something like that
+transposition tables 
+save the evaluation  zobra hash 
+add which moves it is stoping 
+add attacking and defensive 
+we can teach end game theory 
+if apeice is attacked try to move that first 
+storing  the data of moves not to recalculate 
+'''
+
+
+
+
+
+def random_move(valid_moves):
+    ind=random.randint(0,len(valid_moves)-1)
+    return valid_moves[ind]
+
+
+## checking for greedy 
+# for all moves check where i can have more peices/value 
+#but we also need to score_material the next move so that the best possible comes out 
+
+
+#greedy algorithim and try to get better position 
+#score material on board
+#assume black playing ai and check mate is worst
+# go for level 2 
+# we want to minize the maximum of opponent score 
+
+
+def find_best_move_non_recursion(gs,valid_moves):
+    turn = 1 if gs.whiteToMove else -1
+    opponent_min_max_score=  CHECKMATE  #smallest of their maximums
+    best_player_move = None
+    random.shuffle(valid_moves)
+    for  player_move in valid_moves:
+        gs.make_move(player_move)
+        opponent_moves = gs.get_valid_moves()
+        if gs.check_mate:
+                    opponent_max_score = -CHECKMATE
+        elif gs.steale_mate:
+                    opponent_max_score=STALEMATE
+        else:
+            opponent_max_score = -CHECKMATE
+            random.shuffle(opponent_moves)
+            for opponent_move in opponent_moves:
+                gs.make_move(opponent_move)
+                gs.get_valid_move()
+                if gs.check_mate:
+                        score =  CHECKMATE
+                elif gs.steale_mate:
+                        score=STALEMATE
+                else:
+                        score = -turn * score_material(gs.board)
+                    
+                if (score>opponent_max_score):
+                        opponent_max_score=score   # try to find best move for opponent
+                        
+                gs.undo_move()
+        if opponent_min_max_score> opponent_max_score:
+            opponent_min_max_score = opponent_max_score # try to find best move for u which is worst(best) move 
+            best_move  = player_move  # my new best is least of  all opponent bests 
+        
+        gs.undo_move()
+            
+    return best_move
+# solve this recursively
+# prune the branches we do not need
+
+
+'''
+helper method for best method 
+'''
+def find_best_move(gs, valid_moves, return_queue):
+    global count, best_moves
+    count = 0
+    score = find_move_nega_max_alpha_beta(
+        gs, gs.get_valid_moves(), DEPTH, -2*CHECKMATE, 2*CHECKMATE, 1
+    )
+
+    print("Top moves:")
+    for score, mv in best_moves:
+        print(mv.get_chess_notation(), "score:", score)
+
+    # pick a random move among top N
+    chosen_move = random.choice(best_moves)[1]
+    return_queue.put(chosen_move)
+    
+
+
+'''
+find min max move  
+'''
+def find_move_min_max(gs,valid_moves,depth,whiteToMove):
+    global next_move
+    if depth == 0 :
+        return score_material(gs)
+    if whiteToMove:  #maximize score 
+        max_score = - CHECKMATE
+        for move in valid_moves:
+            gs.make_move(move)
+            next_moves = gs.get_valid_moves()
+            score = find_move_min_max(gs,next_moves,depth-1,False)
+            if score>max_score:
+                max_score=score
+                if depth == DEPTH :
+                    next_move = move 
+            gs.undo_move()
+        return max_score
+    else:
+        min_score =  CHECKMATE
+        for move in valid_moves:
+            gs.make_move(move)
+            next_moves = gs.get_valid_moves()
+            score = find_move_min_max(gs,next_moves,depth-1,True)
+            if score<min_score:
+                min_score=score
+                if depth == DEPTH :
+                    next_move = move 
+            gs.undo_move()
+        return min_score
+    
+
+'''
+combine if else to one
+'''
+
+def find_move_nega_max(gs,valid_moves,depth,turn):
+    #always try to maximize but with multilier
+    global next_move,count
+    count +=1
+    if depth == 0 :
+        return turn *  score_material(gs)
+    
+    max_score = CHECKMATE
+    for move in valid_moves:
+            gs.make_move(move)
+            next_moves = gs.get_valid_moves()
+            score = -find_move_nega_max(gs,next_moves,depth-1,-1 * turn) #this is very important 
+            if score>max_score:
+                max_score=score
+                if depth == DEPTH :
+                    next_move = move 
+            gs.undo_move()
+    return max_score
+
+'''
+the alpha beta pruning 
+remove branches that wont make any good 
+also depends on scoring algorithim
+also add positional scores 
+need to control more squares and attack more squares 
+alpha beta these are the maximum and minimum u can acheive  values overall
+
+if max_score>alpha then max_score is alpha
+if alpha>beta then prune that branch 
+ugot best else where no need for it 
+'''
+# Killer moves: 2 per depth (ply)
+killer_moves = {}
+
+# History heuristic: success count
+history_heuristic = {
+    'w': [[0 for _ in range(8)] for _ in range(8)],
+    'b': [[0 for _ in range(8)] for _ in range(8)]
+}
+def order_moves(gs, moves):
+    scored_moves = []
+
+    for move in moves:
+        score=0
+        score -= score_material(gs)
+
+        # 1. Captures (MVV-LVA style)
+        if move.is_capture:
+            attacker = move.peice_moved[1]
+            victim = move.peice_captured[1] if move.peice_captured[1]!='-' else '--'
+            score += ( piece_score.get(victim, 0))*10 - piece_score.get(attacker, 0) 
+
+        # 2. Checks (simulate move and test)
+        gs.make_move(move)
+        if gs.incheck:
+            score += 80
+        gs.undo_move()
+
+        # 3. Promotions
+        if move.is_pawn_promotion:
+            score += 150 + piece_score['Q']*10
+
+        # 4. Castling (good for king safety)
+        if move.castle:
+            score += 50
+
+        # 5. 
+        for dr, dc in [(-1,0),(1,0),(0,-1),(0,1),(-1,-1),(1,1),(-1,1),(1,-1)]:
+            rr, cc = move.end_row + dr, move.end_col + dc
+            if 0 <= rr < 8 and 0 <= cc < 8:
+                piece = gs.board[rr][cc]
+                if piece != "--" and piece[0] == move.peice_moved[0]:  # same color
+                    score += 1 
+        score += score_material(gs)
+        scored_moves.append((score, move))
+
+    # Sort by score descending
+    scored_moves.sort(key=lambda x: x[0], reverse=True)
+    return [m for _, m in scored_moves]
+
+# def find_move_nega_max_alpha_beta(gs, valid_moves, depth, alpha, beta, turn):
+#     global count, next_move
+#     count += 1  # counts all nodes visited
+
+#     if depth == 0:
+#         return turn * score_material(gs)
+
+#     max_score = -CHECKMATE
+#     valid_moves=order_moves(gs,valid_moves)
+#     for move in valid_moves:
+#         gs.make_move(move)
+#         next_moves = gs.get_valid_moves()
+#         score = -find_move_nega_max_alpha_beta(
+#             gs, next_moves, depth - 1, -beta, -alpha, -turn
+#         )
+#         gs.undo_move()
+
+#         if score > max_score:
+#             max_score = score
+#             if depth == DEPTH:
+#                 next_move = move
+
+#         alpha = max(alpha, max_score)
+#         if alpha >= beta:
+#             break
+
+#     return max_score
+
+
+TOP_N = 5  # number of best moves you want
+
+def find_move_nega_max_alpha_beta(gs, valid_moves, depth, alpha, beta, turn): 
+    if depth == 0:
+        return turn * score_material(gs)
+
+    max_score = -CHECKMATE
+    scored_moves = [] 
+
+    # move ordering to improve pruning
+    valid_moves = order_moves(gs, valid_moves)
+
+    for move in valid_moves:
+        gs.make_move(move)
+        next_moves = gs.get_valid_moves()
+        score = -find_move_nega_max_alpha_beta(
+            gs, next_moves, depth - 1, -beta, -alpha, -turn
+        )
+        gs.undo_move()
+
+        scored_moves.append((score, move))
+
+        max_score = max(max_score, score)
+        alpha = max(alpha, max_score)
+        if alpha >= beta:
+            break  # alpha-beta cutoff
+
+    # Only save best moves at root depth
+    if depth == DEPTH:
+        scored_moves.sort(key=lambda x: x[0], reverse=True)
+        best_moves = [(score, move) for score, move in scored_moves[:TOP_N]]
+
+    return max_score
+
+
+'''
+score the board
+positive score good for white 
+a negative score good for black
+increase the scoring function 
+counting attacking and defending moves 
+'''
+
+
+
+def score_material(self):
+    """Full evaluation of the board with material, positional, mobility, defense, etc."""
+
+    if self.check_mate:
+        if self.whiteToMove:
+            return -CHECKMATE 
+        else:
+            return CHECKMATE   
+    elif self.steale_mate:
+        return STALEMATE
+
+    board = self.board
+    score = 0
+
+    white_squares_controlled = set()
+    black_squares_controlled = set()
+
+    # Material, piece-square, and piece defense evaluation
+    for r in range(8):
+        for c in range(8):
+            square = (r, c)
+            piece_info = board[r][c]
+
+            if piece_info == "--":
+                continue
+
+            color, piece = piece_info[0], piece_info[1]
+
+            base_value = piece_score[piece]
+
+            if color == 'w':
+                # Material value
+                score += base_value 
+
+                
+                score += peice_position_scores[piece][r][c]
+
+                # 
+                moves = self.move_functions[piece](r,c,[])
+                for move in moves:
+                    white_squares_controlled.add((move.end_row, move.end_col))
+
+                    # Bonus for defending own piece
+                    if board[move.end_row][move.end_col][0] == 'w':
+                        defended_piece = board[move.end_row][move.end_col][1]
+                        score += piece_score[defended_piece] 
+
+                    # Bonus for killing enemy valuable piece
+                    if board[move.end_row][move.end_col][0] == 'b':
+                        victim = board[move.end_row][move.end_col][1]
+                        score += piece_score[victim]  *10
+            elif color == 'b':
+                score -= base_value 
+                score -= peice_position_scores[piece][7 - r][c]
+
+                moves = self.move_functions[piece](r,c,[])
+                for move in moves:
+                    black_squares_controlled.add((move.end_row, move.end_col))
+
+                    # Defense bonus
+                    if board[move.end_row][move.end_col][0] == 'b':
+                        defended_piece = board[move.end_row][move.end_col][1]
+                        score -= piece_score[defended_piece] 
+
+                    # Killing enemy valuable piece
+                    if board[move.end_row][move.end_col][0] == 'w':
+                        victim = board[move.end_row][move.end_col][1]
+                        score -= piece_score[victim] *10
+
+
+    # Bishop pair bonus
+    white_bishops = sum(1 for r in range(8) for c in range(8) if board[r][c] == 'wB')
+    black_bishops = sum(1 for r in range(8) for c in range(8) if board[r][c] == 'bB')
+    if white_bishops >= 2:
+        score += 50
+    if black_bishops >= 2:
+        score -= 50
+
+    # King safety (penalize exposed kings)
+    score += self.king_safety( "w") - self.king_safety("b")
+    score += (len(white_squares_controlled) - len(black_squares_controlled))*5
+   
+
+    return score
+
+def get_best_n_moves(gs, n=5):
+    """
+    Returns best n moves for both White and Black.
+    """
+    best_white, best_black = [], []
+
+    # White to move
+    if gs.whiteToMove:
+        moves = gs.get_valid_moves()
+        scored = []
+        for move in moves:
+            gs.make_move(move)
+            score = -find_move_nega_max_alpha_beta(
+                gs, gs.get_valid_moves(), DEPTH - 1, -CHECKMATE, CHECKMATE, -1
+            )
+            gs.undo_move()
+            scored.append((score, str(move)))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        best_white = scored[:n]
+
+    # Black to move
+    else:
+        moves = gs.get_valid_moves()
+        scored = []
+        for move in moves:
+            gs.make_move(move)
+            score = -find_move_nega_max_alpha_beta(
+                gs, gs.get_valid_moves(), DEPTH - 1, -CHECKMATE, CHECKMATE, 1
+            )
+            gs.undo_move()
+            scored.append((score, str(move)))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        best_black = scored[:n]
+    return best_white if best_white else best_black