from echecClases import *

#Mes variables.
j = Joueur()
p = Piece()

#Le programme principale
j.selectPiece()
j.updatePlateau()
print(P.get_plateau()) #On veut voir le résultat

##
#Nombre de classes: (3)
#  - Mere
#  | - __init__()
#  | - updatePlateau()
#  |
#  - Piece(Mere)
#  | - __init__()
#  | - verifCoup()
#  | - bougerPiece()
#  | - get_plateau() 
#  |
#  - Joueur(Mere)
#  |  - __init__()
#  |  - property(_get_nom, _set_nom)
#  |  - selectPiece()
 
 
#Classe (1)
class Mere(object):
    """
    Initialisation du plateau de jeu
    du temps, du score, (de la map?),
    qui doit jouer
    """
    def __init__(self):
        self.plateau = {
                       "a1":"tourG-b", "b1":"cavalierG-b", "c1":"fouG-b", "d1":"dame-b",
                       "e1":"roi-b", "f1":"fouD-b", "g1":"cavalierD-b", "h1":"tourD-b",
 
                       "a2":"pion-b", "b2":"pion-b", "c2":"pion-b", "d2":"pion-b",
                       "e2":"pion-b", "f2":"pion-b", "g2":"pion-b", "h2":"pion-b",
 
                       "a3":None, "b3":None, "c3":None, "d3":None,
                       "e3":None, "f3":None, "g3":None, "h3":None,
 
                       "a4":None, "b4":None, "c4":None, "d4":None,
                       "e4":None, "f4":None, "g4":None, "h4":None,
 
                       "a5":None, "b5":None, "c5":None, "d5":None,
                       "e5":None, "f5":None, "g5":None, "h5":None,
 
                       "a6":None, "b6":None, "c6":None, "d6":None,
                       "e6":None, "f6":None, "g6":None, "h6":None,
 
                       "a7":"pion-n", "b7":"pion-n", "c7":"pion-n", "d7":"pion-n",
                       "e7":"pion-n", "f7":"pion-n", "g7":"pion-n", "h7":"pion-n",
 
                       "a8":"tourG-n", "b8":"cavalierG-n", "c8":"fouG-n", "d8":"dame-n",
                       "e8":"roi-n", "f8":"fouD-n", "g8":"cavalierD-n", "h8":"tourD-n"
                       }
        self.case = "a1a2a3a4a5a6a7a8b1b2b3b4b5b6b7b8c1c2c3c4c5c6c7c8d1d2d3d4d5d6d7d8 \
                     e1e2e3e4e5e6e7e8f1f2f3f4f5f6f7f8g1g2g3g4g5g6g7g8h1h2h3h4h5h6h7h8" #Toutes les cases de l'échiquier
        self.score = 0
        self.etatPartie = True

    def updatePlateau(self):
        """Met à jour le plateau"""
        self.newPlateau = self.bougerPiece()
        self.plateau = self.newPlateau
 
 
#Classe (2)
class Piece(Mere):
    """
    Classe definissant où sont les pièces
    sur l'échiquiquier du plateauActuel:
    
    Méthodes:(3)
     - verifCoup()
     - bougerPiece()
     - get_plateau()
    """
    def __init__(self):
        """Initialise la classe <Mere>"""
        Mere.__init__(self)
 
 
    def verifCoup(self):
        """
        Verifie si le coup que le
        joueur souhaite faire est
        possible ou non
        """
        self.variable = True
        return self.variable #Essai. Ne tapez pas ;p
    
    def bougerPiece(self):
        """
        Applique les coordonées changées par le joueur
        sur le plateauActuel
        """ 
        self.numCase, self.goToCase = self.selectPiece()             #On récupère les coord de la piece sélectionnée + celui de son déplacement
        self.verificationCoup = self.verifCoup()
        if self.verificationCoup == True:
            self.plateau[self.goToCase] = self.plateau[self.numCase] #La variable de 'goToCase' devient la variable de 'numCase'
            self.plateau[self.numCase]  = None                       #Il n'y a donc plus rien dans la case précédante. *None*
            self.updatePlateau()                                     #On appelle automatiquement la méthode *updatePlateau()* de la classe <Mere>
        
    def get_plateau(self):
        """
        Donne les positions des pièces sur l'achiquier
        """
        return self.plateau
     
 
#classe (3) 
class Joueur(Mere):
    """
    Tout ce qui se rapporte aux
    actions du/des joueur/s ainsi que
    de l'I.A.:
 
    Méthodes:(2)
     - property(_get_nom, _set_nom)
     - selectPiece()
    """
    def __init__(self, _nom = "Joueur_1"):
        """
        Initialise le nom du joueur ainsi
        que la classe principale
        """
        Mere.__init__(self)
        self._nom = _nom
 
    def _get_nom(self):        #Voir proprety 
        """
        Donne le nom du joueur
        actuel
        """
        return self._nom
    
    def _set_nom(self, newNom): #Voir proprety 
        """
        Attribut un nouveau nom
        au joueur
        """
        self._nom = newNom
 
    def selectPiece(self):
        """
        Sélectionne une pièce de
        l'échiquier à bouger
        """
        while(True):
            self.numCase = input("""Entrez les coordonées du pion à déplacer\n 
                                    sous forme d'une lettre suivit d'un chiffre. Exemple:\n    
                                    a1, c2, h3\n=>""")
            
            if len(self.numCase) == 2 and self.numCase in self.case:
                self.goToCase = input("""Entrez les coordonées de la case\n
                                      où vous voulez bouger votre pièce\n=>""")
                
                if len(self.goToCase) == 2 and self.goToCase in self.case:
                    return self.numCase, self.goToCase #Si le num est correct, on retourne coord de la pièce+son déplacement.
                    break                              #Sans oublier de breaker pour éviter les loop infinies
            else:
                continue
            
                  
    nom = property(_get_nom, _set_nom)      #De la classe <Joueur>
    
if __name__ == "__main__":
    Piece()
    Joueur()

# - Plateau
# | - __init()__
# | - get_etatCase()
# |
# - Juridique
# | - __init()__
# | - legalite(nomDeLaPiece, coordonnee)
# |
# - Piece
# | - __init()__
# | - g_mouv_possible(x, y) 
# |       Retourne une liste des coordonnées (x,y) 
# |       que la pièce peut atteindre en un coup
# |       dans la classe plateau
# |
# | - ... autres méthodes communes à toutes les pièces
# |
# - Pion(Piece)
# | - __init__()
# | - g_mouv_possible(x, y)  [surcharge]
# |
# - Tour(Piece)
# | - __init__()
# | - g_mouv_possible(x, y)  [surcharge]
# |
#      ... etc pour chaque type de pièce. La suite viendra une fois les deux finient ...
#

class Plateau(object):
    """Verifie l'état du plateau et les pièces présentes""" 
    def __init__(self):
        self.partieEnCours = True
        self.nbrPiece = 16
        #Je pense mettre ici mon plateau sous forme d'un dico. Mais il faut
        #bien que mon dico connaisse les coord de mes pièces :/

    def get_etatCase(self):
        """
        Retourne toutes les pièces présentes
        sur chacunes des cases de l'échiquier
        """
        return self.liste_etateCase #Retourne ce que contient les cases
        
    
#Fin de la classe   <Plateau>
#Début de la classe <Juridique>

class Juridique(object):
    """Au 'dessus' de la classe <Piece>. Gère les mouvements"""  
    def __init__(self):
        pass

    def legalite(self, nomDeLaPiece, coordonnee):
        """Est-ce un mouvement légale/possible ?"""
        pass
    
#Fin de la classe   <Juridique>
#Début de la classe <Piece>
    
class Piece(object): #Utile car le 'roi' est une pièce spéciale
    """Classe mère pour toutes les pièces du jeu"""   
    def __init__(self):
        pass
    
    def g_mouv_possible(self, x, y):
        """Permet de voir les déplacements possibles"""
        pass
    
#Héritage des pièces de la classe <Piece> sur <Pion>
    
class Pion(Piece):
    """Rôle du 'pion'sur l'echequier"""
    def __init__(self, x = 1, y = 2):
        self.x = x #Icij'instensirai automatiquement ...
        self.y = y # ... mes variables en début de jeu

    def g_mouv_possible(self, x, y):
        """Permet de voir les déplacements possibles d'un pion"""
        self.liste_coordPossible = []
        
        if y == 2:
            self.liste_coordPossible.append([x,y+1]) #On ajoute la case d'après.(+1)
            self.liste_coordPossible.append([x,y+2]) #Et l'autre case possible. (+2)          
        else:
            self.liste_coordPossible.append([x,y+1]) #Sinon on ajoute la case d'après.(+1)
            
        return self.liste_coordPossible #On retourne cette liste de coordonée possible

class Plateau(object):
    """Verifie l'état du plateau et les pièces présentes""" 
    def __init__(self):
        """Initialisation des variables utiles + instances"""
        self.partieEnCours = True
        self.nbrPiece = 16

        pionA = Pion(1, 2) #(a;2)
        pionB = Pion(2, 2) #(b;2)
        #De même jusqu'à 'H' et pour chacune des pièces
        #Cela m'évite de créer un dico et à le mettre à jour

    def get_etatCase(self):
        """
        Retourne toutes les pièces présentes
        sur chacunes des cases de l'échiquier
        """
        return self.liste_etateCase #Retourne ce que contient les cases
        
    
#Fin de la classe   <Plateau>
#Début de la classe <Juridique>

class Juridique(Plateau): #Hérite de <plateau>

from echecClasse import *

j = Piece()
j.g_mouvPossible(9, 9) #Que peut t'il faire en (9;9) ?
#-----------------------Il peut aller en (9;10)

j.g_mouvPossible(2, 2)
#-----------------------Il peut aller en (2;3) ou en (2;4)

# - Plateau
# | - __init()__
# | - get_etatCase()
# |
# - Juridique
# | - __init()__
# | - legalite(nomDeLaPiece, coordonnee)
# | - choicirPion()
# |
# - Piece
# | - __init()__
# | - g_mouv_possible(x, y) 
# |       Retourne une liste des coordonnées (x,y) 
# |       que la pièce peut atteindre en un coup
# |       dans la classe plateau
# |
# | - ... autres méthodes communes à toutes les pièces
# |
# - Pion(Piece)
# | - __init__()
# | - g_mouv_possible(x, y)  [surcharge]
# |
# - Tour(Piece)
# | - __init__()
# | - g_mouv_possible(x, y)  [surcharge]
# |
#      ... etc pour chaque type de pièce. La suite viendra une fois les deux finient ...
#

class Plateau(object):
    """Verifie l'état du plateau et les pièces présentes""" 
    def __init__(self):
        self.partieEnCours = True
        self.nbrPiece = 16

    def get_etatCase(self):
        """
        Retourne toutes les pièces présentes
        sur chacunes des cases de l'échiquier
        """
        return self.liste_etateCase #Retourne ce que contient les cases
        
    
#Fin de la classe   <Plateau>
#Début de la classe <Juridique>

class Juridique(Plateau):
    """
    Au 'dessus' de la classe <Piece>.Gère les mouvements"""  
    def __init__(self):
        """
        Initialise diférentes variables
        telle qu'une liste de booléens

        """
        pass
       
    def legalite(self, nomDeLaPiece, coordonnee):
        """Est-ce un mouvement légale/possible ?"""
        pass

    def choisirPion(self):
        """Selectionne un pièce pour le joueur"""
        #Retourne les coordonnées demandées
        pass
    
#Fin de la classe   <Juridique>
#Début de la classe <Piece>
    
class Piece(object): #Utile car le 'roi' est une pièce spéciale
    """Classe mère pour toutes les pièces du jeu"""   
    def __init__(self):
        """
        Instantation des pièces
        ainsi que leur coordonnée
        
        """
        self.x, self.y = 0, 0
        self.pionA = Pion(self.x+1, self.y+2) #(a;2)
        self.pionB = Pion(self.x+2, self.y+2) #(b;2)
    
    def g_mouv_possible(self, x, y):
        """Permet de voir les déplacements possibles"""
        self.mouvPossible = self.pionA.g_mouv_possible(x, y)
        print(self.mouvPossible)
        
    
#Héritage des pièces de la classe <Piece> sur <Pion>
    
class Pion(Piece):
    """Rôle du 'pion'sur l'echequier"""
    def __init__(self, x , y, couleur = True):
        """
        Pour l'instant gère la couleur du pion
        True = Blanc; False = Noir

        """
        self.couleur = couleur 
        
    def g_mouv_possible(self, x, y):
        """Permet de voir les déplacements possibles d'un pion"""
        self.liste_coordPossible = [] #On a besoin d'une liste
        
        if y == 2:
            self.liste_coordPossible.append([x,y+1]) #On ajoute la case d'après.(+1)
            self.liste_coordPossible.append([x,y+2]) #Et l'autre case possible. (+2)          
        else:
            self.liste_coordPossible.append([x,y+1]) #Sinon on ajoute la case d'après.(+1)
           
        return self.liste_coordPossible #On retourne cette liste de coordonée possible

# - Plateau
# | - __init()__
# | - get_etatCase()
# |
# - Juridique
# | - __init()__
# | - legalite()
# | - choisirPion()
# | - choisirDestination()
# | - bouger()
# |
# - Piece
# | - __init()__
# | - g_mouv_possible(x, y) 
# |       Retourne une liste des coordonnées (x,y) 
# |       que la pièce peut atteindre en un coup
# |       dans la classe plateau
# |
# | - ... autres méthodes communes à toutes les pièces
# |
# - Pion(Piece)
# | - __init__()
# | - g_mouv_possible(x, y)  [surcharge]
# |
# - Tour(Piece)
# | - __init__()
# | - g_mouv_possible(x, y)  [surcharge]
# |
#      ... etc pour chaque type de pièce. La suite viendra une fois les deux finient ...
#

class Plateau(object):
    """Verifie l'état du plateau et les pièces présentes""" 
    def __init__(self):
        """
        Instancie les pièces de l'échiquier
        ainsi que les informations du plateau

        """
        self.partieEnCours = True
        self.nbrPiece = 16

        self.x = 0
        self.y = 0
        
        self.pionA = Pion(self.x+1, self.y+2) #(a;2)
        self.pionB = Pion(self.x+2, self.y+2) #(b;2)
        
    def get_etatCase(self):
        """
        Retourne toutes les pièces présentes
        sur chacunes des cases de l'échiquier
        """
        return self.liste_etateCase #Retourne ce que contient les cases
        
    
#Fin de la classe   <Plateau>
#Début de la classe <Juridique>

class Juridique(Plateau):
    """
    Au 'dessus' de la classe <Piece>.Gère les mouvements"""  
    def __init__(self):
        """
        Initialise diférentes variables
        telle qu'une liste de booléens

        """
        Plateau.__init__(self)
        pass
       
    def legalite(self, nomDeLaPiece, coordonnee):
        """Est-ce un mouvement légale/possible ?"""
        #Si le déplacement est possible
        #return True
        pass

    def choisirPion(self):
        """Selectionne un pièce pour le joueur"""
        self.caseX = input("Choisissez une abscisse")
        self.caseY = input("Choisissez une ordonnée")
        return self.caseX, self.caseY

    def choisirDestination(self):
        """Ou voulons-nous bouger la pièce ?"""
        self.destinationX = input("Choisissez une abscisse de destination")
        self.destinationY = input("Choisissez une ordonnée de destination")
        #Appel de la fonction légalité
        #Si True alors on modifie les position
        #On modifie donc le plateau

    def bouger(self):
        """
        Permet de bouger une pièce:
        1) Appel la fonction choisirPion()
        2) Appel de la fonction choisirDestination()
        2,A) - Appel de la fonction legalite()
        2,B) - Le déplacement s'effectue
          """
        self.choisirPion()
        self.choisirDestination()

        
#Fin de la classe   <Juridique>
#Début de la classe <Piece>
    
class Piece(object): #Utile car le 'roi' est une pièce spéciale
    """Classe mère pour toutes les pièces du jeu"""   
    def __init__(self):
        """
        Ne sert à rien
        pour le moment
        
        """
        pass
    
    def g_mouv_possible(self, x, y):
        """Permet de voir les déplacements possibles"""
        self.mouvPossible = self.pionA.g_mouv_possible(x, y)
        
    
#Héritage des pièces de la classe <Piece> sur <Pion>
    
class Pion(Piece):
    """Rôle du 'pion'sur l'echiquier"""
    def __init__(self, x , y, couleur = True):
        """
        Pour l'instant gère la couleur du pion
        True = Blanc; False = Noir

        """
        self.couleur = couleur 
        
    def g_mouv_possible(self, x, y):
        """Permet de voir les déplacements possibles d'un pion"""
        self.liste_coordPossible = [] #On a besoin d'une liste
        
        if y == 2:
            self.liste_coordPossible.append([x,y+1]) #On ajoute la case d'après.(+1)
            self.liste_coordPossible.append([x,y+2]) #Et l'autre case possible. (+2)          
        else:
            self.liste_coordPossible.append([x,y+1]) #Sinon on ajoute la case d'après.(+1)
          
        return self.liste_coordPossible #On retourne cette liste de coordonée possible

# -*- coding: utf-8 -*-

from __future__ import print_function

###############################################################################
# fonctions utilitaires et constantes globales

NOIR  = 0
BLANC = 1

VIDE = None

SYMBOLE_PION = '*'
SYMBOLE_TOUR = 'T'
SYMBOLE_CAVALIER = 'C'
SYMBOLE_FOU = 'F'
SYMBOLE_REINE = '&'
SYMBOLE_ROI = '@'

COULEUR_SURLIGNE = '\033[7m'
COULEUR_STOP = '\033[0m'

def surligne(texte):
    """
    Surligne le texte dans la console (affiche en noir sur blanc)
    Fonctionne sur toutes les plate-formes 
    (sous windows, il faut s'assurer que ansi.sys est activé)

    """
    return '{0}{1}{2}'.format(COULEUR_SURLIGNE, texte, COULEUR_STOP)

###############################################################################

class Piece(object):
    """
    Interface commune à toutes les pièces.
    Ne s'utilise pas directement.

    """
    def __init__(self, echiquier, couleur, symbole):
        """
        Construit une pièce.
        echiquier : echiquier sur lequel se trouve la pièce
        couleur : NOIR ou BLANC.
        symbole : caractère symbolisant la pièce.
        
        """
        self.__echiquier = echiquier
        self.__couleur = couleur
        self.__symbole = symbole

    def get_mouvements_possibles(self, pos_x, pos_y): 
        """ 
        Retourne la liste des cases que peut atteindre la pièce sachant qu'elle
        se trouve actuellement en (pos_x, pos_y). 
        
        """ 
        # return []
        raise NotImplementedError(
            "{0}.get_mouvements_possibles".format(self.nom)
            )

    def is_mouvement_possible(self, pos_x, pos_y, dest_x, dest_y):
        """
        Retourne True si la pièce, actuellement (pos_x, pos_y) peut se
        déplacer vers (dest_x, dest_y) en un tour.

        """
        # Il est possible, suivant le type de la pièce, d'utiliser des règles
        # de calcul plus efficaces que de parcourir linéairement la liste des
        # mouvements possibles... 
        return (dest_x, dest_y) in self.get_mouvements_possibles(pos_x, pos_y)

    def get_attaques_possibles(self, pos_x, pos_y):
        """
        Retourne une liste des mouvements d'attaque possible.
        Concrêtement, la pièce peut se déplacer différemment quand elle attaque
        ou quand elle bouge simplement (le pion, par exemple).
        Cette méthode permet donc de retourner les cases sur lesquelles la
        pièce peut attaquer.

        """
        # cas général, la pièce attaque exactement comme elle bouge
        return self.get_mouvements_possibles(pos_x, pos_y)

    def is_attaque_possible(self, pos_x, pos_y, dest_x, dest_y):
        """
        True si la pièce peut attaquer la case dest_x, dest_y depuis pos_x,
        pos_y.
        False sinon.
        """
        return (dest_x, dest_y) in self.get_attaques_possibles(pos_x, pos_y)

    @property
    def nom(self):
        """
        Retourne le nom de la pièce sous forme de chaîne de caractères.

        Par exemple:
        >>> p = Reine()
        >>> p.nom
        'Reine'
        """
        return type(self).__name__

    @property
    def couleur(self):
        return self.__couleur
    
    def __str__(self):
        """
        Retourne une représentation de la pièce et de sa couleur sur un
        caractère (Noir sur blanc si la pièce est noire, blanc sur noir si la
        pièce est blanche).
        """
        return surligne(self.__symbole) if self.__couleur == NOIR \
                else self.__symbole

    def __repr__(self):
        return "Piece({0}, {1})".format(self.nom, self.couleur)

###############################################################################
# classes dérivées de Piece

class Tour(Piece):
    def __init__(self, echiquier, couleur):
        Piece.__init__(self, echiquier, couleur, SYMBOLE_TOUR)

class Pion(Piece):
    def __init__(self, echiquier, couleur):
        Piece.__init__(self, echiquier, couleur, SYMBOLE_PION)

class Cavalier(Piece):
    def __init__(self, echiquier, couleur):
        Piece.__init__(self, echiquier, couleur, SYMBOLE_CAVALIER)

class Fou(Piece):
    def __init__(self, echiquier, couleur):
        Piece.__init__(self, echiquier, couleur, SYMBOLE_FOU)

class Reine(Piece):
    def __init__(self, echiquier, couleur):
        Piece.__init__(self, echiquier, couleur, SYMBOLE_REINE)

class Roi(Piece):
    def __init__(self, echiquier, couleur):
        Piece.__init__(self, echiquier, couleur, SYMBOLE_ROI)

###############################################################################

POS_PIECES = [Tour, Cavalier, Fou, Roi, Reine, Fou, Cavalier, Tour]

class Echiquier(object):
    """
    Echiquier. 
    Tient à jour l'échiquier de la partie : l'état du jeu
    """
    def __init__(self):
        """ 
        Initialise l'échiquier en plaçant les pièces à leur position initiale.

        """
        self.__plateau = [[VIDE for _ in range(8)] for _ in range(8)]
        # initialisation des pions
        for x in range(8):
            self.__plateau[x][0] = POS_PIECES[x](self, BLANC)
            self.__plateau[x][1] = Pion(self, BLANC)
            self.__plateau[x][6] = Pion(self, NOIR)
            self.__plateau[x][7] = POS_PIECES[7-x](self, NOIR)

        # ...
    
    def get(self, x, y):
        """
        Retourne la pièce à la position x, y

        """
        return self.__plateau[x][y]

    def put(self, piece, x, y):
        """
        Place une pièce à la position x, y

        """
        self.__plateau[x][y] = piece

    def libre(self, x, y):
        """
        retourne True si la case aux coordonnées (x, y) est libre

        """
        return self.piece_at(x, y) is VIDE

    def mouvement(self, pos_x, pos_y, dest_x, dest_y):
        """
        Bouge la pièce aux coordonnées pos_x, pos_y vers la position dest_x,
        dest_y.

        """
        if not self.libre(pos_x, pos_y):
            piece = self.get(pos_x, pos_y)
            if piece.is_mouvement_possible(pos_x, pos_y, dest_x, dest_y):
                self.put(piece, dest_x, dest_y)
                self.put(VIDE, pos_x, pos_y)

    def attaque(self, pos_x, pos_y, dest_x, dest_y):
        """
        Attaque la pièce en position (dest_x, dest_y) avec la pièce en position 
        (pos_x, pos_y)

        """
        raise NotImplementedError('Plateau.attaque')

    def __str__(self):
        """
        Retourne une représentation de l'échiquier affichable dans la console.

        """
        str_plateau = ''
        for yc in range(23,-1,-1):
            y = yc // 3
            if yc % 3 == 1:
                str_plateau += ' ' + str(y+1) + '  '
            else:
                str_plateau += '    '

            for xc in range(48):
                x = xc // 6
                if xc % 6 == 2 and yc % 3 == 1:
                    piece = self.__plateau[x][y]
                    if piece is not None:
                        str_plateau += str(piece)
                    else:
                        str_plateau += surligne(' ') if (x + y) % 2 else ' '
                else:
                    str_plateau += surligne(' ') if (x + y) % 2 else ' '
            str_plateau += '\n'
        str_plateau += '\n      A     B     C     D     E     F     G     H\n'
        return str_plateau

###############################################################################

class Jeu(object):
    """
    Classe permettant de gérer une partie.

    """
    def __init__(self):
        """
        initialise une partie.

        """
        self.selection_x = -1
        self.selection_y = -1
        self.tour_actuel = BLANC
        self.echiquier = Echiquier()
        # ...

    def selectionner_piece(self, pos_x, pos_y):
        """
        Sélectionne la pièce avec laquelle jouer.
        Vérifie qu'elle appartient bien au joueur dont c'est le tour de
        jouer...

        """
        raise NotImplementedError("jeu.selectionner_piece")

    def jouer_case(self, pos_x, pos_y):
        """
        Joue la case (pos_x, pos_y) avec la pièce sélectionnée.

        """
        raise NotImplementedError("jeu.jouer_case")

    def verifier_echec_mat(self):
        """ 
        Vérifie si le joueur actuel est en position d'echec et mat.
        """
        raise NotImplementedError("jeu.verifier_echec_mat")


if __name__ == '__main__':
    ech = Echiquier()
    print(ech)