Jeu alquerque en python avec tkinter

Bonjour,

Je réalise un jeu d'alquerque en python mais je suis perdu quelqu'un peut-il m'aider?

from tkinter import *
from tkinter import messagebox
from math import *

class valeur:
    def __init__(self,value):
        self.__value=value
        
    def couleur_pion(self):
        if self.__value==0:
            return 'white'
        if self.__value==1:
            return '#c3daea'
        if self.__value==2:
            return '#2b4c07'
        if self.__value==3:
            return 'red'
        if self.__value==4:
            return 'green'
        
        
    def getnumber(self):
        return self.__value

    def setvaleur(self,x):
        self.__value = x
    
    def clic(self):
        if self==TRUE:
            return FALSE
        else :
            return TRUE    
    def color_case(self):
        if valeur.clic(self)==FALSE:
            return 'red' 
        else: 
            return 'white'   
class Plateau:
    def __init__(self,nbrows,nbcolumns):
        self.__j=jeu()
        self.fen = Tk()
        self.fen.title('Alquerque')
        self.fen.geometry('600x600')
        self.__dessin = Canvas(self.fen, width=500, height=500, bg='white')
        self.__dessin.pack(expand=YES)
        self.__dessin.bind('<Button>',self.verifclic)
        self.__nbrows = nbrows
        self.__nbcolumns = nbcolumns
        self.__grid = [[valeur(0)for i in range(self.__nbrows)]for j in range (self.__nbcolumns)]
        self.__board=[
                    [1,1,1,1,1],
                    [1,1,1,1,1],
                    [1,1,0,2,2],
                    [2,2,2,2,2],
                    [2,2,2,2,2]
                    ]
        
        self.initialisationgrille()
        self.create_case()
        self.create_pion()
            
    def initialisationgrille(self):
        for i in range(len(self.__board)):
            for j in range(len(self.__board)):
                self.__grid[i][j].setvaleur(self.__board[i][j])

    def create_case(self):
        x0=0
        y0=0
        x1=100
        y1=100
        stock_case=[]
        for j in range (self.__nbcolumns):
            for i in range(self.__nbrows):
                self.__dessin.create_rectangle(x0,y0,x1,y1,fill=valeur.color_case(self))
                stock_case.append(self.__dessin)
                x0+=100
                x1+=100
            x0=0
            y0+=100 
            x1=100
            y1+=100
            
       
    
    def create_pion(self):
        x0=5
        y0=5
        x1=95
        y1=95
        for j in range (5):
            for i in range(5):
                self.__dessin.create_oval(x0,y0,x1,y1,fill=self.__grid[i][j].couleur_pion())
                x0+=100
                x1+=100
            x0=5
            y0+=100
            x1=95
            y1+=100
    def verifclic(self,event):
        
        clicx=floor(event.x/100)
        clicy=floor(event.y/100)
        
        if self.__board[clicx][clicy]==self.__j.getplayer() :
            print(clicx,clicy)
            self.__board[clicx][clicy]=3
            self.boardupdate()
        for i in range(len(self.__j.possible())):
            self.__board.insert(self.__j.possible(clicx,clicy),4)
            
        

        
    def boardupdate(self):
        
        
        self.__grid = [[valeur(0)for i in range(self.__nbrows)]for j in range (self.__nbcolumns)]
        
        self.initialisationgrille()
        self.create_case()
        self.create_pion()
        
    # def newparty(self):
  	
    #     result=messagebox.askquestion("Nouvelle partie", "Voulez-vous faire une nouvelle partie ?",icon="info")
    #     if result == 'yes':
    #         jeu.gameturn()
    #     else:
    #         Plateau.fen.destroy()
        
# class party:
#      def __init__(self):
#         Plateau()    
    

class jeu:
    

    def __init__(self):
        self.__player=2
    def getplayer(self):
        return self.__player

    def getBoard(self, x, y):
        return self.__board[x][y]

    def setBoard(self, x, y, value ):
        self.__board[y][x] = value

    def saisieCoord(self):
        l = int(l)-1
        h = int(h)-1
        x= int(x)-1
        y= int(y)-1
        
        return l, h

    def possible(self, x, y, precx = None, precy = None):
        
        possibilities = []
        for i in range(y-1, y+2):
            for j in range(x-1, x+2):
                if 0 < x < len(Plateau.__board) and 0 < y < len(Plateau.__board):
                    if (i != y or j != x) or ((precx == None and precy == None) and (i != precy or j != precx)):
                        if Plateau.__board[i][j] == 0 and best < 2: 
                            best = 1
                            possibilities.append((j, i))
                        elif Plateau.__board[i][j] == self.__player%2+1 and Plateau.__board[i + (i-y)][j + (j-x)] == 0:
                            best = 2
                            possibilities.append((j, i))
                            new_possibilities, new_best = self.possible(i, j, x, y)
                            if new_best == 2:
                                best += 1
                                possibilities = possibilities + new_possibilities

        return possibilities
    def best():
        best=1
        return best
    def findepartie(self,possibilities):
        possibilities,best = self.possible()
        if best==0:
            return True 
        else:
            return False
        
    def again(self):
        compteur=0
        for i in range(len(Plateau.__board)):
            for j in range(len(Plateau.__board)):
                if self.getBoard(i,j)== self.__player:
                    compteur+=1

        if compteur>0:
            return True
        else :
            return False

    def gameturn(self):
    

        while (self.again()):
            jeu()
            clicx,clicy=Plateau.verifclic(self,event)
                        
            x=clicx
            y= clicy
            l, h  = self.saisieCoord()
            possibilities, best = self.possible(x,y)
            if (l,h) in possibilities and best ==1 :
                self.setBoard(l,h,self.__player)
                self.setBoard(x,y,0)
                
                self.__player = self.__player%2+1
            elif (l,h) in possibilities and best ==2 :
                self.setBoard(l,h,self.__player)
                self.setBoard(x,y,0)
                if (x,y)>(l,h):
                    self.setBoard(x-1,y-1,self.__player)
                else:
                    self.setBoard(x+1,y+1,self.__player)
                    
                
            else:
                self.setBoard(x,y,0)

                self.__player = self.__player%2+1

        else:
            print ("fin du jeu ")
           
Plateau(5,5)
mainloop()

Voici les règles:

• Un pion peut se déplacer vers une case vide adjacente reliée par un trait.
• Un pion peut capturer un pion adverse en passant par dessus et en retombant sur une case vide. Cela nécessite que les trois cases soit alignées, adjacentes et reliées par un trait.
• Si une capture est possible elle doit obligatoirement être effectuée, sinon le pion en question est retiré du jeu.
• Si après une capture un pion peut en effectuer une autre il doit nécessairement le faire (comme à la règle précédente).
• Si plusieurs captures sont possibles, on doit choisir celle conduisant à l'élimination du plus de pions adverses.

Merci d'avance.

Windows / Chrome 109.0.0.0