Besoin d'aide pour la programmation d'un jeu (Reversi/Othello) avec des listes.

Bonjour,
j'ai récemment commencer a apprendre a coder. Je dois programmer un jeu d'othello a deux joueurs en phyton avec l'aide des listes. Malheureusement je me retrouve bloquer depuis plusieurs semaine sur celui-ci, en effet je n'arrive pas a faire en sorte que les pions puissent changer de couleur en diagonale, j'y arrive si il change par le haut, le bas, la droite et la gauche mais pas par la diagonale.
Je n'arrive pas non plus a faire en sorte de détecter si le joueur a la possibilité de jouer et si non a passer le tour de celui-ci
Serait-il possible d'avoir de l'aide
Merci beaucoup

voici le code:

from fltk import *
from time import sleep


def dessine_tableau():
    """
    On crée une fonction sans argument qui permet de tracer le terrain de jeu,
    alias le plateau. Ce plateau est un plateau composer de 8 cases par 8 case
    Fonctions graphique
    
    Parametre
    -------
        None

    Returns
    -------
    Un plateau complet de 8 case sur 8 cases, des lignes horizontal et
    verticales a meme distance entre elle.

    """
    for i in range(9):
        ligne(i * 75, 0, i * 75, 600)

    for i in range(9):
        ligne(0, i * 75, 600, i * 75)


def dessine_du_piont(i,j,remplissage):
    """
    Cette fonction permet de tracer une piece, soit un rond rempli avec une 
    couleur choisit le remplissant, son perimetre est noir.
    

    Parametre
    ----------
    i: Int, coordonné en x
    j: Int, coordonné en y
    remplissage: String, est la couleur de la piece

    Returns
    -------
    Un cercle faisant la taille d'une case avec une couleur choisie

    """
    cercle((j+1) * 75 - 37.5, (i+1) * 75 - 37.5, 35, 'black', remplissage = remplissage)

def dessine_piece(plateau):
    """
    La fonction permet de tracer un pion de la couleur du joueur qui la place,
    on utilise la fonction qui permet de tracer un pion pour cela
    
    Parametre
    ----------
    plateau: Case ou l'on joue
    
    Returns
    -------
    Un pion noir si le joueur 1 joue
    Un pion blanc si le joueur 2 joue
    """
    for i in range(8):
        for j in range(8):
            if plateau[i][j] == 1:
                dessine_du_piont(i, j, "black")
            elif plateau[i][j] == 2:
                dessine_du_piont(i, j, "white")


def inversement(inverse):
    """
    Fonction permettant d'inverser la couleur des pionts
    
    Parametre
    ----------
    inverse: liste
    
    Return
    ------
    Inverse l'etat des pionts
    """
    print("c'est l'invers",inverse)
    for i in range(len(inverse)):
        x = inverse[i][0]
        y = inverse[i][1]
        print(i)
        print(x)
        print(y)
        if plateau[x][y] == 1:
            plateau[x][y] = 2
        else:
            plateau[x][y] = 1


def possible_jouer():
    """
    Cette fontion permet de savoir si le joueur peut jouer et si il doit passer
    son tour

    Returns
    -------
    None.

    """
    for i in range(8):
        for j in range(8):
            if plateau[i][j] == 1 and plateau[i+1][j+1] == 2:
                cercle((j+2) * 75 - 37.5, (i+2) * 75 - 37.5, 35, 'black', remplissage = "green")

def valide(x,y,tour):
    """
    La fonction permet de savoir si la piece posé est valide d'apres les regles
    Si on peut bien poser cette piece

    Parameters
    ----------
    x : TYPE int
        DESCRIPTION. coordonné en x
    y : TYPE int
        DESCRIPTION. coordonné en y
    tour : TYPE int
        DESCRIPTION. Savoir si c'est le joueur 1 ou 2 joue

    Returns
    -------
    bool
        dit si il y a eu un depassement par le bas, le haut, la droite, 
        la gauche. Soit si il y a une piece qui a ete posé

    """
    inverse=[]
    z=[] #Coordoné pionts inversé
    '#depasse par le bas'
    for i in range(1, x):
        if plateau[x-i][y] != tour and plateau[x-i][y] != 0:
            z.append((x-i,y))
        elif plateau[x-i][y] == tour :
            for pos in range(len(z)):
                inverse.append(z[pos])
            z=[]
            break
        elif plateau[x-i][y] == 0:
            z=[]
            break
    '#depasse par le haut'
    for i in range(1, 8-x):
        if plateau[x+i][y] != tour and plateau[x+i][y] != 0:
            z.append((x+i,y))
        elif plateau[x+i][y] == tour :
            for pos in range(len(z)):
                inverse.append(z[pos])
            z=[]
            break
        elif plateau[x+i][y] == 0:
            z=[]
            break
    '#depasse par la droite'
    for i in range(1,y):
        if plateau[x][y-i] != tour and plateau[x][y-i] != 0:
            z.append((x,y-i))
        elif plateau[x][y-i] == tour :
            for pos in range(len(z)):
                inverse.append(z[pos])
            z=[]
            break
        elif plateau[x][y-i] == 0:
            z=[]
            break
    '#depasse par la gauche'
    for i in range(1, 8-y):
        if plateau[x][y+i] != tour and plateau[x][y+i] != 0:
            z.append((x, y+i))
        elif plateau[x][y+i] == tour:
            for pos in range(len(z)):
                inverse.append(z[pos])
            z = []
            break
        elif plateau[x][y+i] == 0:
            z = []
            break
    if inverse != []:
        return (True, inverse)
    else:
        return (False, None)



def interaction_tableau(tour):
    """
    La fonction permet de cliquer sur la tableau, et renvoir les coordonnées ou
    le joueur a cliquer

    Parameters
    ----------
    tour : TYPE, int
        DESCRIPTION. Savoir quel joueur joue

    Returns
    -------
    coordonnée d'ou le joueur a cliqué

    """
    ev = donne_ev()
    ty = type_ev(ev)
    if ty == 'Quitte':
        return False
    if ty == 'ClicGauche':
        y=abscisse(ev)
        x=ordonnee(ev)
        x //= 75
        y //= 75
        'permet de quitter'
        if y >= 8:
            ferme_fenetre()
        if valide(x, y, tour)[0] and plateau[x][y] == 0:
            plateau[x][y] = tour
            inversement(valide(x, y, tour)[1])
            print(y, x)
            return True, True
        if x >= 8 and x <= 9 and y == 0:
            return False, False
    return True, False


if __name__ == "__main__":
    cree_fenetre(800, 600)
    jouer = True
    plateau = [[0 for x in range(8)] for y in range(8)]
    plateau[3][3] = 1
    plateau[4][4] = 1
    plateau[3][4] = 2
    plateau[4][3] = 2
    tour = 1
    continuer_jeu = 0
    a_lautre_joueur = 0
    print(plateau)
    print("à joueur", str(tour), "de jouer")
    while jouer:
        efface_tout()
        dessine_tableau()
        dessine_piece(plateau)
        rectangle(605, 2, 750, 75, couleur = 'red', remplissage = 'white', epaisseur= 4)
        texte(675, 85/2, "Quitter", police="Impact", taille="20", couleur="red", ancrage='center')
        (continuer_jeu, a_lautre_joueur) = interaction_tableau(tour)
        if not(continuer_jeu):
            jouer = False
        if a_lautre_joueur:
            if tour == 1:
                tour = 2
            else:
                tour = 1
            print("à joueur", str(tour), "de jouer")
        mise_a_jour()






        sleep(0.001)

    ferme_fenetre()