Upload 40 files

app.py

@@ -0,0 +1,322 @@
+import chess
+import chess.svg
+import pygame
+import engine
+from pygame import Vector2
+import move_finder
+from multiprocessing import Process,Queue
+
+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 = engine.GameState(board)
+#     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')
+    
+    
+    
+    

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/app.py

@@ -0,0 +1,322 @@
+import chess
+import chess.svg
+import pygame
+import engine
+from pygame import Vector2
+import move_finder
+from multiprocessing import Process,Queue
+
+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 = engine.GameState(board)
+#     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')
+    
+    
+    
+    

final/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/games_play.py

@@ -0,0 +1,137 @@
+from collections import deque
+import random
+import torch
+import torch
+from engine import GameState
+from move_finder import find_best_move_shallow
+from infer_nnue import gs_to_nnue_features
+from nnue_model import NNUE
+from tqdm import tqdm
+from infer_nnue import NNUEInfer
+NNUE_FEATURES = 32
+def pad_features(feats):
+    if len(feats) < NNUE_FEATURES:
+        return feats + [0] * (NNUE_FEATURES - len(feats))
+    return feats[:NNUE_FEATURES]
+
+import pickle
+
+def load_pgn_dataset(path):
+    trajectories = []
+    current_traj = []
+
+    with open(path, "rb") as f:
+        while True:
+            try:
+                chunk = pickle.load(f)
+                for item in chunk:
+                    current_traj.append(item)
+
+                    # heuristic: end trajectory on side-to-move flip
+                    if len(current_traj) > 1 and \
+                       current_traj[-1]["stm"] != current_traj[-2]["stm"]:
+                        trajectories.append(current_traj)
+                        current_traj = []
+
+            except EOFError:
+                break
+
+    if current_traj:
+        trajectories.append(current_traj)
+
+    return trajectories
+
+
+@torch.no_grad()
+@torch.no_grad()
+def td_targets_from_traj(model, traj, gamma=0.99):
+    if len(traj) == 1:
+        return [0.0]
+
+    feats = [pad_features(x["features"]) for x in traj]
+    stm   = [x["stm"] for x in traj]
+
+    feats = torch.tensor(feats, dtype=torch.long, device="cuda")
+    stm   = torch.tensor(stm, dtype=torch.long, device="cuda")
+
+    values = model(feats, stm).view(-1)
+
+    targets = torch.empty_like(values)
+
+    # TD(0) with turn flip
+    targets[:-1] = gamma * (-values[1:])
+    targets[-1]  = values[-1].detach()
+
+    # value clipping (STOCKFISH STYLE)
+    targets = torch.clamp(targets, -1.0, 1.0)
+
+    return targets.cpu().tolist()
+
+
+
+from collections import deque
+import random
+
+class ReplayBuffer:
+    def __init__(self, capacity=300_000):
+        self.buf = deque(maxlen=capacity)
+
+    def add(self, f, stm, t):
+        self.buf.append((f, stm, t))
+
+    def sample(self, n):
+        return random.sample(self.buf, n)
+
+    def __len__(self):
+        return len(self.buf)
+
+
+def train_from_replay(model, optimizer, replay, batch_size):
+    if len(replay) < batch_size:
+        return
+
+    batch = replay.sample(batch_size)
+    feats, stm, targets = zip(*batch)
+
+    feats = torch.tensor(feats, dtype=torch.long, device="cuda")
+    stm   = torch.tensor(stm, dtype=torch.long, device="cuda")
+    targ  = torch.tensor(targets, dtype=torch.float, device="cuda")
+
+    preds = model(feats, stm).view(-1)
+
+    loss = torch.nn.functional.smooth_l1_loss(preds, targ)
+
+    optimizer.zero_grad(set_to_none=True)
+    loss.backward()
+    optimizer.step()
+
+
+from tqdm import tqdm
+device = "cuda"
+model = NNUE().to(device)
+model.load_state_dict(torch.load("nnue_model.pt", weights_only=True))
+optimizer = torch.optim.Adam(model.parameters(), lr=5e-5)
+
+replay = ReplayBuffer()
+trajectories = load_pgn_dataset("nnue_dataset.pkl")
+
+for epoch in range(3):
+    print(f"Epoch {epoch}")
+
+    for traj in tqdm(trajectories):
+        if len(traj) < 2:
+            continue
+
+        targets = td_targets_from_traj(model, traj)
+
+        for x, t in zip(traj, targets):
+            replay.add(
+                pad_features(x["features"]),
+                x["stm"],
+                t
+            )
+
+        for _ in range(3):
+            train_from_replay(model, optimizer, replay, batch_size=512)
+
+    torch.save(model.state_dict(), "nnue_model_td.pt")

final/infer_nnue.py

@@ -0,0 +1,86 @@
+
+PIECE_TO_INDEX = {
+    'wp': 0, 'wN': 1, 'wB': 2, 'wR': 3, 'wQ': 4,
+    'bp': 5, 'bN': 6, 'bB': 7, 'bR': 8, 'bQ': 9
+}
+
+
+NUM_PIECES = 10
+NUM_SQUARES = 64
+NUM_FEATURES = NUM_PIECES * NUM_SQUARES * NUM_SQUARES
+
+PAD_IDX = NUM_FEATURES  
+def find_king_squares(board):
+    wk = bk = None
+    for r in range(8):
+        for c in range(8):
+            if board[r][c] == "wK":
+                wk = r * 8 + c
+            elif board[r][c] == "bK":
+                bk = r * 8 + c
+    return wk, bk
+
+def gs_to_nnue_features(gs):
+    board = gs.board
+    wk, bk = find_king_squares(board)
+
+    features = []
+
+    for r in range(8):
+        for c in range(8):
+            piece = board[r][c]
+            if piece == "--" or piece[1] == "K":
+                continue
+
+            p_idx = PIECE_TO_INDEX[piece]
+            sq = r * 8 + c
+
+            if piece[0] == 'w':
+                king_sq = wk
+            else:
+                king_sq = bk
+
+            if king_sq is None:
+                continue
+
+            # index = p * 64 * 64 + king * 64 + piece_square
+            idx = (
+                p_idx * 64 * 64 +
+                king_sq * 64 +
+                sq
+            )
+            features.append(idx)
+
+    return features
+
+import torch
+
+class NNUEInfer:
+    def __init__(self, model, device="cpu"):
+        self.device = device
+        self.model = model.to(device)
+        self.model.eval()
+
+    @torch.no_grad()
+    def __call__(self, features, stm):
+        """
+        features : List[int]
+        stm      : 1 if white to move, 0 if black
+        returns  : float score
+        """
+        if not features:
+            features = [PAD_IDX]
+
+        feats = torch.tensor(
+            features,
+            dtype=torch.long,
+            device=self.device
+        ).unsqueeze(0)
+
+        stm = torch.tensor(
+            [stm],
+            dtype=torch.long,
+            device=self.device
+        )
+
+        return self.model(feats, stm).item()

final/move_finder.py

@@ -0,0 +1,579 @@
+import random
+import torch 
+from nnue_model import NNUE
+from infer_nnue import NNUEInfer
+import infer_nnue
+
+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_moves()
+                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):
+    result = find_move_nega_max_alpha_beta(
+        gs, valid_moves, DEPTH, -2*CHECKMATE, 2*CHECKMATE, 1
+    )
+
+    score, best_moves = result
+
+    print("Top moves:")
+    for sc, mv in best_moves:
+        print(mv.get_chess_notation(), "score:", sc)
+
+    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 
+'''
+
+def order_moves(gs, moves):
+    return 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 = 1  # 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
+
+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
+    best_local_moves = []
+
+    valid_moves = order_moves(gs, valid_moves)
+
+    for move in valid_moves:
+        gs.make_move(move)
+        score = -find_move_nega_max_alpha_beta(
+            gs, gs.get_valid_moves(), depth - 1, -beta, -alpha, -turn
+        )
+        gs.undo_move()
+
+        if score > max_score:
+            max_score = score
+            best_local_moves = [(score, move)]
+        elif score == max_score:
+            best_local_moves.append((score, move))
+
+        alpha = max(alpha, max_score)
+        if alpha >= beta:
+            break
+
+    # ONLY at root
+    if depth == DEPTH:
+        best_local_moves.sort(key=lambda x: x[0], reverse=True)
+        return max_score, best_local_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_hand(gs):
+    """Full evaluation of the board with material, positional, mobility, defense, etc."""
+    self=gs
+    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]  *1
+            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] *1
+
+
+    # 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
+
+
+device='cuda'
+model = NNUE().to(device)
+model.load_state_dict(torch.load("nnue_phase4_final.pt", map_location=device,weights_only=True))
+nnue_eval = NNUEInfer(model, device)
+CHECKMATE = 5000
+STALEMATE = 0
+MAX_RAW_EVAL = 2500      # hard clamp
+TANH_SCALE = 1000.0     # controls steepness
+import math
+
+def clamp_eval(x):
+    return max(-MAX_RAW_EVAL, min(MAX_RAW_EVAL, x))
+
+def tanh_scale_eval(x):
+    # maps to (-1, 1)
+    return math.tanh(x / TANH_SCALE)
+def score_material(gs):
+    # Terminal positions
+    if gs.check_mate:
+        return -1 if gs.whiteToMove else 1
+    if gs.steale_mate:
+        return STALEMATE
+
+    # 1️⃣ Extract NNUE features
+    features = infer_nnue.gs_to_nnue_features(gs)
+
+    # 2️⃣ Side to move
+    stm = 1 if gs.whiteToMove else 0
+
+    # 3️⃣ NNUE inference
+    score = nnue_eval(features, stm)
+    return float(score)
+
+    
+def score_nnue(gs, nnue_eval):
+    if gs.check_mate:
+        return -1.0 if gs.whiteToMove else 1.0
+    if gs.steale_mate:
+        return 0.0
+
+    feats = infer_nnue.gs_to_nnue_features(gs)
+    stm = 1 if gs.whiteToMove else 0
+    return float(nnue_eval(feats, stm))
+
+def get_best_n_moves(gs, n=1):
+    """
+    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
+
+
+def find_best_move_shallow(gs, depth=2):
+    valid_moves = gs.get_valid_moves()
+    best_score = -1e9
+    best_move = None
+
+    for move in valid_moves:
+        gs.make_move(move)
+        score = -find_move_nega_max_alpha_beta(
+            gs, gs.get_valid_moves(), depth - 1,
+            -CHECKMATE, CHECKMATE,
+            -1 if gs.whiteToMove else 1
+        )
+        gs.undo_move()
+
+        if score > best_score:
+            best_score = score
+            best_move = move
+
+    return best_move, best_score
+
+
+
+
+# def score_nnue(gs, nnue_eval):
+#     if gs.check_mate:
+#         return -1.0 if gs.whiteToMove else 1.0
+#     if gs.steale_mate:
+#         return 0.0
+
+#     feats = infer_nnue.gs_to_nnue_features(gs)
+#     stm = 1 if gs.whiteToMove else 0
+#     return float(nnue_eval(feats, stm))

final/nnue_model.py

@@ -0,0 +1,54 @@
+import torch
+import torch.nn as nn
+import onnx
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+NUM_FEATURES = 10 * 64 * 64     # NNUE feature space
+PAD_IDX = NUM_FEATURES
+
+class NNUE(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.embed = nn.Embedding(NUM_FEATURES + 1, 256, padding_idx=PAD_IDX)
+        self.fc1 = nn.Linear(256 + 1, 256)
+        self.fc2 = nn.Linear(256, 64)
+        self.fc3 = nn.Linear(64, 1)
+
+    def forward(self, feats, stm):
+        # feats: [B, N] long
+        x = self.embed(feats).sum(dim=1)
+
+        # stm: [B] -> [-1, +1]
+        stm = stm.float().unsqueeze(1) * 2 - 1
+        x = torch.cat([x, stm], dim=1)
+
+        x = torch.relu(self.fc1(x))
+        x = torch.relu(self.fc2(x))
+        return self.fc3(x).squeeze(1)
+
+
+# ------------------------------
+# Create model
+# ------------------------------
+torch_model = NNUE()
+torch_model.eval()
+
+# ------------------------------
+# Correct example inputs
+# ------------------------------
+BATCH = 1
+ACTIVE_FEATURES = 32  # typical NNUE sparse feature count
+
+# Feature indices (LONG!)
+feats = torch.randint(
+    low=0,
+    high=NUM_FEATURES,
+    size=(BATCH, ACTIVE_FEATURES),
+    dtype=torch.long
+)
+
+# Side to move: 0 = black, 1 = white
+stm = torch.randint(0, 2, (BATCH,), dtype=torch.long)
+
+example_inputs = (feats, stm)

final/nnue_phase4_final.pt

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

games_play.py

@@ -0,0 +1,137 @@
+from collections import deque
+import random
+import torch
+import torch
+from engine import GameState
+from move_finder import find_best_move_shallow
+from infer_nnue import gs_to_nnue_features
+from nnue_model import NNUE
+from tqdm import tqdm
+from infer_nnue import NNUEInfer
+NNUE_FEATURES = 32
+def pad_features(feats):
+    if len(feats) < NNUE_FEATURES:
+        return feats + [0] * (NNUE_FEATURES - len(feats))
+    return feats[:NNUE_FEATURES]
+
+import pickle
+
+def load_pgn_dataset(path):
+    trajectories = []
+    current_traj = []
+
+    with open(path, "rb") as f:
+        while True:
+            try:
+                chunk = pickle.load(f)
+                for item in chunk:
+                    current_traj.append(item)
+
+                    # heuristic: end trajectory on side-to-move flip
+                    if len(current_traj) > 1 and \
+                       current_traj[-1]["stm"] != current_traj[-2]["stm"]:
+                        trajectories.append(current_traj)
+                        current_traj = []
+
+            except EOFError:
+                break
+
+    if current_traj:
+        trajectories.append(current_traj)
+
+    return trajectories
+
+
+@torch.no_grad()
+@torch.no_grad()
+def td_targets_from_traj(model, traj, gamma=0.99):
+    if len(traj) == 1:
+        return [0.0]
+
+    feats = [pad_features(x["features"]) for x in traj]
+    stm   = [x["stm"] for x in traj]
+
+    feats = torch.tensor(feats, dtype=torch.long, device="cuda")
+    stm   = torch.tensor(stm, dtype=torch.long, device="cuda")
+
+    values = model(feats, stm).view(-1)
+
+    targets = torch.empty_like(values)
+
+    # TD(0) with turn flip
+    targets[:-1] = gamma * (-values[1:])
+    targets[-1]  = values[-1].detach()
+
+    # value clipping (STOCKFISH STYLE)
+    targets = torch.clamp(targets, -1.0, 1.0)
+
+    return targets.cpu().tolist()
+
+
+
+from collections import deque
+import random
+
+class ReplayBuffer:
+    def __init__(self, capacity=300_000):
+        self.buf = deque(maxlen=capacity)
+
+    def add(self, f, stm, t):
+        self.buf.append((f, stm, t))
+
+    def sample(self, n):
+        return random.sample(self.buf, n)
+
+    def __len__(self):
+        return len(self.buf)
+
+
+def train_from_replay(model, optimizer, replay, batch_size):
+    if len(replay) < batch_size:
+        return
+
+    batch = replay.sample(batch_size)
+    feats, stm, targets = zip(*batch)
+
+    feats = torch.tensor(feats, dtype=torch.long, device="cuda")
+    stm   = torch.tensor(stm, dtype=torch.long, device="cuda")
+    targ  = torch.tensor(targets, dtype=torch.float, device="cuda")
+
+    preds = model(feats, stm).view(-1)
+
+    loss = torch.nn.functional.smooth_l1_loss(preds, targ)
+
+    optimizer.zero_grad(set_to_none=True)
+    loss.backward()
+    optimizer.step()
+
+
+from tqdm import tqdm
+device = "cuda"
+model = NNUE().to(device)
+model.load_state_dict(torch.load("nnue_model.pt", weights_only=True))
+optimizer = torch.optim.Adam(model.parameters(), lr=5e-5)
+
+replay = ReplayBuffer()
+trajectories = load_pgn_dataset("nnue_dataset.pkl")
+
+for epoch in range(3):
+    print(f"Epoch {epoch}")
+
+    for traj in tqdm(trajectories):
+        if len(traj) < 2:
+            continue
+
+        targets = td_targets_from_traj(model, traj)
+
+        for x, t in zip(traj, targets):
+            replay.add(
+                pad_features(x["features"]),
+                x["stm"],
+                t
+            )
+
+        for _ in range(3):
+            train_from_replay(model, optimizer, replay, batch_size=512)
+
+    torch.save(model.state_dict(), "nnue_model_td.pt")

infer_nnue.py

@@ -0,0 +1,86 @@
+
+PIECE_TO_INDEX = {
+    'wp': 0, 'wN': 1, 'wB': 2, 'wR': 3, 'wQ': 4,
+    'bp': 5, 'bN': 6, 'bB': 7, 'bR': 8, 'bQ': 9
+}
+
+
+NUM_PIECES = 10
+NUM_SQUARES = 64
+NUM_FEATURES = NUM_PIECES * NUM_SQUARES * NUM_SQUARES
+
+PAD_IDX = NUM_FEATURES  
+def find_king_squares(board):
+    wk = bk = None
+    for r in range(8):
+        for c in range(8):
+            if board[r][c] == "wK":
+                wk = r * 8 + c
+            elif board[r][c] == "bK":
+                bk = r * 8 + c
+    return wk, bk
+
+def gs_to_nnue_features(gs):
+    board = gs.board
+    wk, bk = find_king_squares(board)
+
+    features = []
+
+    for r in range(8):
+        for c in range(8):
+            piece = board[r][c]
+            if piece == "--" or piece[1] == "K":
+                continue
+
+            p_idx = PIECE_TO_INDEX[piece]
+            sq = r * 8 + c
+
+            if piece[0] == 'w':
+                king_sq = wk
+            else:
+                king_sq = bk
+
+            if king_sq is None:
+                continue
+
+            # index = p * 64 * 64 + king * 64 + piece_square
+            idx = (
+                p_idx * 64 * 64 +
+                king_sq * 64 +
+                sq
+            )
+            features.append(idx)
+
+    return features
+
+import torch
+
+class NNUEInfer:
+    def __init__(self, model, device="cpu"):
+        self.device = device
+        self.model = model.to(device)
+        self.model.eval()
+
+    @torch.no_grad()
+    def __call__(self, features, stm):
+        """
+        features : List[int]
+        stm      : 1 if white to move, 0 if black
+        returns  : float score
+        """
+        if not features:
+            features = [PAD_IDX]
+
+        feats = torch.tensor(
+            features,
+            dtype=torch.long,
+            device=self.device
+        ).unsqueeze(0)
+
+        stm = torch.tensor(
+            [stm],
+            dtype=torch.long,
+            device=self.device
+        )
+
+        return self.model(feats, stm).item()

move_finder.py

@@ -0,0 +1,579 @@
+import random
+import torch 
+from nnue_model import NNUE
+from infer_nnue import NNUEInfer
+import infer_nnue
+
+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_moves()
+                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):
+    result = find_move_nega_max_alpha_beta(
+        gs, valid_moves, DEPTH, -2*CHECKMATE, 2*CHECKMATE, 1
+    )
+
+    score, best_moves = result
+
+    print("Top moves:")
+    for sc, mv in best_moves:
+        print(mv.get_chess_notation(), "score:", sc)
+
+    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 
+'''
+
+def order_moves(gs, moves):
+    return 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 = 1  # 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
+
+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
+    best_local_moves = []
+
+    valid_moves = order_moves(gs, valid_moves)
+
+    for move in valid_moves:
+        gs.make_move(move)
+        score = -find_move_nega_max_alpha_beta(
+            gs, gs.get_valid_moves(), depth - 1, -beta, -alpha, -turn
+        )
+        gs.undo_move()
+
+        if score > max_score:
+            max_score = score
+            best_local_moves = [(score, move)]
+        elif score == max_score:
+            best_local_moves.append((score, move))
+
+        alpha = max(alpha, max_score)
+        if alpha >= beta:
+            break
+
+    # ONLY at root
+    if depth == DEPTH:
+        best_local_moves.sort(key=lambda x: x[0], reverse=True)
+        return max_score, best_local_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_hand(gs):
+    """Full evaluation of the board with material, positional, mobility, defense, etc."""
+    self=gs
+    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]  *1
+            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] *1
+
+
+    # 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
+
+
+device='cuda'
+model = NNUE().to(device)
+model.load_state_dict(torch.load("nnue_phase4_final.pt", map_location=device,weights_only=True))
+nnue_eval = NNUEInfer(model, device)
+CHECKMATE = 5000
+STALEMATE = 0
+MAX_RAW_EVAL = 2500      # hard clamp
+TANH_SCALE = 1000.0     # controls steepness
+import math
+
+def clamp_eval(x):
+    return max(-MAX_RAW_EVAL, min(MAX_RAW_EVAL, x))
+
+def tanh_scale_eval(x):
+    # maps to (-1, 1)
+    return math.tanh(x / TANH_SCALE)
+def score_material(gs):
+    # Terminal positions
+    if gs.check_mate:
+        return -1 if gs.whiteToMove else 1
+    if gs.steale_mate:
+        return STALEMATE
+
+    # 1️⃣ Extract NNUE features
+    features = infer_nnue.gs_to_nnue_features(gs)
+
+    # 2️⃣ Side to move
+    stm = 1 if gs.whiteToMove else 0
+
+    # 3️⃣ NNUE inference
+    score = nnue_eval(features, stm)
+    return float(score)
+
+    
+def score_nnue(gs, nnue_eval):
+    if gs.check_mate:
+        return -1.0 if gs.whiteToMove else 1.0
+    if gs.steale_mate:
+        return 0.0
+
+    feats = infer_nnue.gs_to_nnue_features(gs)
+    stm = 1 if gs.whiteToMove else 0
+    return float(nnue_eval(feats, stm))
+
+def get_best_n_moves(gs, n=1):
+    """
+    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
+
+
+def find_best_move_shallow(gs, depth=2):
+    valid_moves = gs.get_valid_moves()
+    best_score = -1e9
+    best_move = None
+
+    for move in valid_moves:
+        gs.make_move(move)
+        score = -find_move_nega_max_alpha_beta(
+            gs, gs.get_valid_moves(), depth - 1,
+            -CHECKMATE, CHECKMATE,
+            -1 if gs.whiteToMove else 1
+        )
+        gs.undo_move()
+
+        if score > best_score:
+            best_score = score
+            best_move = move
+
+    return best_move, best_score
+
+
+
+
+# def score_nnue(gs, nnue_eval):
+#     if gs.check_mate:
+#         return -1.0 if gs.whiteToMove else 1.0
+#     if gs.steale_mate:
+#         return 0.0
+
+#     feats = infer_nnue.gs_to_nnue_features(gs)
+#     stm = 1 if gs.whiteToMove else 0
+#     return float(nnue_eval(feats, stm))

nnue_model.py

@@ -0,0 +1,54 @@
+import torch
+import torch.nn as nn
+import onnx
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+NUM_FEATURES = 10 * 64 * 64     # NNUE feature space
+PAD_IDX = NUM_FEATURES
+
+class NNUE(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.embed = nn.Embedding(NUM_FEATURES + 1, 256, padding_idx=PAD_IDX)
+        self.fc1 = nn.Linear(256 + 1, 256)
+        self.fc2 = nn.Linear(256, 64)
+        self.fc3 = nn.Linear(64, 1)
+
+    def forward(self, feats, stm):
+        # feats: [B, N] long
+        x = self.embed(feats).sum(dim=1)
+
+        # stm: [B] -> [-1, +1]
+        stm = stm.float().unsqueeze(1) * 2 - 1
+        x = torch.cat([x, stm], dim=1)
+
+        x = torch.relu(self.fc1(x))
+        x = torch.relu(self.fc2(x))
+        return self.fc3(x).squeeze(1)
+
+
+# ------------------------------
+# Create model
+# ------------------------------
+torch_model = NNUE()
+torch_model.eval()
+
+# ------------------------------
+# Correct example inputs
+# ------------------------------
+BATCH = 1
+ACTIVE_FEATURES = 32  # typical NNUE sparse feature count
+
+# Feature indices (LONG!)
+feats = torch.randint(
+    low=0,
+    high=NUM_FEATURES,
+    size=(BATCH, ACTIVE_FEATURES),
+    dtype=torch.long
+)
+
+# Side to move: 0 = black, 1 = white
+stm = torch.randint(0, 2, (BATCH,), dtype=torch.long)
+
+example_inputs = (feats, stm)

nnue_phase4_final.pt

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