Jeu des carrés ou pipopipette

Bonjour à tous. J'espère que vous allez super bien.
Je débute en python et j'aimerais concevoir le jeu pipopipette (jeu des carrés) en utilisant les notions de class, mais j'ai quelques difficultés à le faire. J'ai écrit en détail les étapes que je veux suivre et chaque niveau à compléter, j'ai noter un TODO: a compléter. J'ai 6 fichiers dont 3 à programmer soit la classe planche, la classe partie et la classe joueur. Merci d'avance à ceux qui pourront m'aider. Voici les 6 fichiers.

1er fichier, fichier __main__.py

"""
Module de lancement du package pipopipette.

C'est ce module que nous allons exécuter pour démarrer votre jeu.
"""

from partie import PartiePipopipette

if __name__ == '__main__':
    partie = PartiePipopipette()

    # Pour charger d'une partie déjà sauvegardée
    # partie = PartiePipopipette('partie_sauvegardee.txt')

    # Pour sauvegarder une partie
    # partie.sauvegarder('partie_sauvegardee.txt')

    partie.jouer()

2e fichier, fichier boite.py

class Boite:
    """
    Classe représentant une boîte de la planche de jeu.

    Une boîte est constituée d'un attribut couleur de type str
    et d'un attribut pleine de type bool.

    Cette classe vous est fournie, vous n'avez pas à la modifier.
    """
    DICT_COULEURS = {'': 'grey', 'bleu': 'blue', 'rouge': 'red'}

    def __init__(self):
        self.couleur = ''
        self.pleine = False

    def assigner_couleur(self, couleur):
        self.couleur = couleur
        self.pleine = True

    def couleur_formattee(self):
        """
        Nécessaire pour l'affichage en console, NE PAS MODIFIER.
        """
        if self.pleine:
            return self.couleur[0].upper()
        else:
            return ''

    def couleur_affichage(self):
        """
        NE PAS MODIFIER.
        """
        return Boite.DICT_COULEURS[self.couleur]

    def __repr__(self):
        """
        Nécessaire pour les tests, NE PAS MODIFIER.
        """
        if self.pleine:
            return 'Boîte pleine de couleur {}'.format(self.couleur)
        else:
            return 'Boîte non pleine'

3e fichier, fichier joueur.py

import random


class Joueur:
    """
    Classe générale de joueur.
    """

    def __init__(self, couleur):
        """
        Le constructeur global de Joueur.

        Args :
            couleur (str): la couleur qui sera jouée par le joueur.
        """
        assert couleur in ['bleu', 'rouge'], 'Piece: couleur invalide.'

        self.couleur = couleur

    def obtenir_type_joueur(self):
        """
        Cette méthode sera implémentée par JoueurHumain et JoueurOrdinateur

        Returns :
            'Ordinateur' ou 'Humain'
        """
        pass

    def choisir_coup(self, planche):
        """
        Cette méthode sera implémentée par JoueurHumain et JoueurOrdinateur.

        Args :
            planche (Planche): la planche sur laquelle le joueur choisit son coup

        Returns:
            (int, int, str): L'index du la ligne (le coup) choisi par le joueur.
        """
        pass


class JoueurHumain(Joueur):
    """
    Classe modélisant un joueur humain.
    """

    def __init__(self, couleur):
        """
        Cette méthode va construire un objet Joueur et
        l'initialiser avec la bonne couleur.
        """
        super().__init__(couleur)

    def obtenir_type_joueur(self):
        return 'Humain'

    def choisir_coup(self, planche):
        """
        ÉTAPE 5

        Demande à l'usager quel coup il désire jouer. Comme un coup est
        constitué d'une ligne, d'une colonne et d'une orientation, on doit
        demander chacune des trois valeurs à l'usager.

        On retourne ensuite l'index correspondant aux trois valeurs dans l'ordre
        (ligne, colonne, orientation).

        Args :
            planche (Planche): la planche sur laquelle le joueur choisit son coup

        Returns:
            (int, int, str): L'index du la ligne (le coup) choisi par le joueur.

        TODO: compléter le corps de cette fonction.
        """
        pass


class JoueurOrdinateur(Joueur):
    """
    Classe modélisant un joueur ordinateur.
    """

    def __init__(self, couleur):
        """
        Cette méthode va construire un objet Joueur et
        l'initialiser avec la bonne couleur.
        """
        super().__init__(couleur)

    def obtenir_type_joueur(self):
        return 'Ordinateur'

    def choisir_coup(self, planche):
        """
        ÉTAPE 5

        Méthode qui va choisir aléatoirement un coup parmi les
        coups possibles sur la planche. Pensez à utiliser
        random.choice() et planche.obtenir_coups_possibles() pour
        vous faciliter la tâche.

        N.B. Vous pouvez sans aucun problème implémenter un
                joueur ordinateur plus avancé qu'un simple choix
                aléatoire. Il s'agit seulement du niveau minimum requis.

        Args :
            planche (Planche): la planche sur laquelle le joueur choisit son coup

        Returns:
            (int, int, str): L'index du la ligne (le coup) choisi par le joueur.

        TODO: compléter le corps de cette fonction.
        """
        pass

4e fichier, fichier ligne.py

class Ligne:
    """
    Classe représentant une ligne.

    Une ligne est constituée d'un attribut booléen jouee.
    """
    COULEUR_JOUEE = 'black'
    COULEUR_NON_JOUEE = 'white'

    def __init__(self):
        self.jouee = False

    def couleur_affichage(self):
        """
        NE PAS MODIFIER.
        """
        if self.jouee:
            return Ligne.COULEUR_JOUEE
        else:
            return Ligne.COULEUR_NON_JOUEE

    def __repr__(self):
        """
        Nécessaire pour les tests, NE PAS MODIFIER.
        """
        return 'Ligne {} jouée'.format('' if self.jouee else 'non')

5e fichier, fichier partie.py

from planche import Planche
from joueur import JoueurOrdinateur, JoueurHumain


class PartiePipopipette:
    def __init__(self, nom_fichier=None):
        """
        Méthode d'initialisation d'une partie de pipopipette.
        """
        self.planche = Planche()

        self.gagnant_partie = None
        self.partie_nulle = False

        if nom_fichier is not None:
            self.charger(nom_fichier)
        else:
            self.initialiser_joueurs()

    def initialiser_joueurs(self):
        """
        ÉTAPE 4

        On initialise ici quatre attributs : joueur_rouge,
        joueur_bleu, joueur_courant et couleur_joueur_courant.

        Pour créer les objets joueur_rouge et joueur_bleu, faites
        appel à creer_joueur().

        joueur_courant est initialisé par défaut au joueur_rouge
        et couleur_joueur_courant est initialisée à 'rouge'.

        TODO: compléter le corps de cette fonction.
        """
        pass

    def creer_joueur(self, couleur):
        """
        ÉTAPE 4

        Demande à l'usager quel type de joueur ('Humain' ou
        'Ordinateur') il désire pour le joueur de la couleur
        en entrée.

        Tant que l'entrée n'est pas valide, on continue de
        demander à l'utilisateur.

        Faire appel à self.creer_joueur_selon_type() pour créer
        le joueur lorsque vous aurez un type valide.

        Args :
            couleur (str): la couleur pour laquelle on veut le type
                de joueur.

        Returns :
            Joueur : Un objet Joueur, de type JoueurHumain si l'usager a
                entré 'Humain', JoueurOrdinateur s'il a entré
                'Ordinateur'.

        TODO: compléter le corps de cette fonction.
        """
        pass

    def creer_joueur_selon_type(self, type_joueur, couleur):
        """
        ÉTAPE 4

        Crée l'objet Joueur approprié, selon le type passé en
        paramètre.

        Pour créer les objets, vous n'avez qu'à faire appel à
        leurs constructeurs, c'est-à-dire à
        JoueurHumain(couleur), par exemple.

        Args :
            type (str): le type de joueur, 'Ordinateur' ou 'Humain'
            couleur (str): la couleur du pion joué par le joueur,
                'rouge' ou 'bleu'.

        Returns :
            Joueur: Un objet JoueurHumain si le type est 'Humain',
                JoueurOrdinateur sinon.

        TODO: compléter le corps de cette fonction.
        """
        pass

    def jouer(self):
        """
        ÉTAPE 5

        Méthode représentant la boucle principale de jeu.

        On commence par faire afficher un message indiquant le début
        de la partie ainsi que l'état de départ de la planche.

        Ensuite on fonctionne comme une boucle. Pour chaque
        itération, on joue un tour et si la partie est terminée,
        on quitte la boucle.

        Quand on sort de la boucle principale, on fait afficher le
        message de fin de la partie.

        Utilisez les fonctions partie_terminee(), jouer_tour() et
        message_fin_partie() pour vous faciliter la tâche.

        TODO: compléter le corps de cette fonction.
        """
        pass

    def jouer_tour(self):
        """
        ÉTAPE 5

        Cette méthode commence par afficher à quel joueur c'est
        le tour de jouer et faire imprimer l'état de la planche avec
        print(self.planche).

        On va ensuite chercher le coup choisi par le joueur courant
        avec la méthode choisir_coup() de Joueur en lui passant la
        planche de jeu courante (self.planche). Tant que le coup choisi
        par un joueur n'est pas valide, on affiche la raison de
        l'invalidité du coup et on redemande au joueur de choisir un
        coup. Voir les commentaires de la méthode valider_coup() de Planche
        pour plus de détails.

        On finit par jouer le coup (validé) avec la méthode self.jouer_coup().

        TODO: compléter le corps de cette fonction.
        """
        pass

    def jouer_coup(self, coup):
        """
        ÉTAPE 5

        Joue un coup sur la planche, fait la mise à jour de l'état
        des boîtes et change de joueur au besoin (si aucune boîte
        n'a été remplie en jouant le coup).

        Faites appel aux méthodes jouer_coup() et maj_boites() de
        Planche ainsi qu'à self.changer_joueur()

        Args:
            coup (int, int, str): L'index de la ligne à jouer

        TODO: compléter le corps de cette fonction.
        """
        pass

    def partie_terminee(self):
        """
        ÉTAPE 5

        Méthode vérifiant si la partie est terminée.

        Pour savoir si la planche de jeu est pleine, on peut
        directement faire appel à self.planche.est_pleine(). Si
        la planche est pleine, c'est que la partie est terminée.
        On fait donc imprimer un message indiquant la fin de la
        partie ainsi que l'état final de planche.

        Il nous reste maintenant à savoir qui est le gagnant de
        la partie. Pour obtenir le nombre de boîtes remplies par chacun
        des joueurs, faites appel à la fonction bilan_boites()
        de l'attribut self.planche. On assigne la couleur du
        joueur gagnant (celui avec le plus de boîtes) à l'attribut
        self.gagnant_partie.

        Returns :
            True si la partie est terminée, False sinon

        TODO: compléter le corps de cette fonction.
        """
        pass

    def changer_joueur(self):
        """
        ÉTAPE 5

        En fonction de la couleur du joueur courant, met à
        jour les attributs joueur_courant et couleur_joueur_courant.

        TODO: compléter le corps de cette fonction.
        """
        pass

    def message_fin_partie(self):
        """
        ÉTAPE 5

        Méthode qui gère le comportement de fin de partie.

        On retourne un message approprié pour féliciter le gagnant.
        Le joueur gagnant est contenu dans l'attribut
        self.gagnant_partie.

        Returns:
            str: le message de félicitations du gagnant de la partie.

        TODO: compléter le corps de cette fonction.
        """
        pass

    def sauvegarder(self, nom_fichier):
        """
        ÉTAPE 6

        Sauvegarde une partie dans un fichier. Le fichier
        contiendra:
        - Une ligne indiquant la couleur du joueur courant.
        - Une ligne contenant le type du joueur rouge.
        - Une ligne contenant le type du joueur bleu.
        - Le reste des lignes correspondant aux lignes et aux boîtes. Voir la
          méthode convertir_en_chaine() de la planche pour le
          format.

        Faites appel à la fonction obtenir_type_joueur() de
        la classe Joueur pour savoir le type d'un Joueur.

        Args :
            nom_fichier, le string du nom du fichier où sauvegarder.

        TODO: compléter le corps de cette fonction.
        """
        pass

    def charger(self, nom_fichier):
        """
        Charge une partie à partir d'un fichier. Le fichier
        a le même format que la méthode de sauvegarde.

        Args:
            nom_fichier (str): Le du nom du fichier à charger.

        TODO: compléter le corps de cette fonction.
        """
        pass

6e fichier, fichier planche.py

from ligne import Ligne
from boite import Boite


class Planche:
    """
    Classe représentant la planche de jeu de Pipopipette.

    Le système de position de la planche fonctionne comme suit:

        - Les points sont représentés par un tuple (ligne, colonne)
          respectant l'indexage habituel d'une matrice; le point
          en haut à gauche est représenté par le tuple (0, 0) alors
          que le point en bas à droite est représenté par le tuple
          (Planche.N_BOITES_H, Planche.N_BOITES_V).

        - Les boîtes sont représentées par l'index du point se situant
          dans leur coin supérieur gauche. Cela veut donc dire que la
          boîte du coin en haut à gauche est représentée par le tuple
          (0, 0) alors que celle en bas à droite est représentée par
          le tuple (Planche.N_BOITES_H - 1, Planche.N_BOITES_V - 1).
          Remarques bien ici les -1: ils sont présents pour la dernière
          boîte mais pas pour le dernier point car il y a plus de points
          que de boîtes dans une partie de pipopipette.

        - Il existe deux types de lignes: les lignes verticales et
          horizontales. On considérera qu'une ligne est représentée
          notamment par une chaîne de caractères 'orientation', laquelle
          vaudra 'H' pour une ligne horizontale et 'V' pour une ligne
          verticale. Enfin, une ligne est aussi reliée à l'index (ligne,
          colonne) d'un point de la planche. Pour une ligne verticale,
          le point de connexion est celui du haut de la ligne, alors que
          pour une ligne horizontale, il s'agit du point à gauche. Ainsi,
          chaque ligne se voit attribuer un tuple (ligne, colonne, orientation)
          unique.
    """
    # Attributs globaux de la classe Planche.
    # Vous pouvez leur accéder avec Planche.N_BOITES_H par exemple.
    # Noter que dans le vidéo explicatif, self.N_BOITES_V représentait
    # self.N_BOITES_V et ainsi de suite.
    N_BOITES_V = 3
    N_BOITES_H = 3

    def __init__(self):
        """
        Méthode spéciale initialisant une nouvelle planche.
        """
        self.initialisation_par_defaut()

        self.position_dernier_coup = None
        self.couleur_dernier_coup = None

    def initialisation_par_defaut(self):
        """
        Méthode initialisant les dictionnaires de lignes et de boîtes
        de la planche.
        """
        self.initialiser_lignes()
        self.initialiser_boites()

    def initialiser_lignes(self):
        """
        ÉTAPE 1

        Méthode d'initialisation des lignes contenues dans self.lignes.
        Cet attribut permettra d'accéder à une ligne de la planche à partir
        de son index comme suit :

            self.lignes[(ligne, colonne, orientation)]

        On débute par créer un dictionnaire vide de lignes dans l'attribut
        self.lignes. On crée et on ajoute ensuite les lignes à self.lignes
        au bon index pour chacun des trois types de ligne suivants :

        - La ligne verticale à droite : Toutes les lignes verticales qui ont
          comme colonne la valeur Planche.N_BOITES_V. Notez qu'il y en aura
          précisément Planche.N_BOITES_H.

        - La ligne horizontale du bas : Toutes les lignes horizontales qui ont
          comme index de ligne la valeur Planche.N_BOITES_H. Notez qu'il y en aura
          précisément Planche.N_BOITES_V.

        - Les lignes dites 'de base' : Toutes les lignes horizontales et verticales
          qui ne sont pas dans la ligne du bas ni celle de droite (cas plus haut).
          Notez qu'il y en aura précisément Planche.N_BOITES_V * Planche.N_BOITES_H.

        L'index d'une ligne (sa clé dans self.lignes) doit correspondre à un tuple
        (ligne, colonne, orientation) tel que décrit dans les commentaires au haut
        de cette classe. Pour créer un objet Ligne, faites simplement appel au
        constructeur Ligne().

        TODO: compléter le corps de cette fonction.
        """
        pass

    def initialiser_boites(self):
        """
        ÉTAPE 1

        Méthode d'initialisation des boîtes contenues dans self.boites.
        Cet attribut permet d'accéder à une boîte de la planche à partir
        de son index comme suit :

            self.boites[(ligne, colonne)]

        On débute par créer un dictionnaire vide de boîtes dans l'attribut
        self.boites. On crée et on ajoute ensuite les boîtes à self.boites
        au bon index pour toutes les boîtes de la planche. Notez qu'il y en
        aura précisément Planche.N_BOITES_V * Planche.N_BOITES_H.

        L'index d'une boîte (sa clé dans self.boites) doit correspondre à un tuple
        (ligne, colonne) tel que décrit dans les commentaires au haut de cette
        classe. Pour créer un objet Boite, faites simplement appel au
        constructeur Boite().

        TODO: compléter le corps de cette fonction.
        """
        pass

    def coup_dans_les_limites(self, index_ligne):
        """
        ÉTAPE 2

        Vérifie si un coup est dans les limites de la planche.
        Dans notre cas, comme tous les index valides de lignes
        dans la planche sont des clés dans le dictionnaire
        self.lignes, il nous suffit de vérifier que l'index
        en entrée est contenu dans les clés de self.lignes.

        Args :
            coup (int, int, str): index de la ligne

        Returns :
            bool: True si le coup est dans les limites, False sinon

        TODO: compléter le corps de cette fonction.
        """
        pass

    def est_pleine(self):
        """
        ÉTAPE 2

        Méthode qui vérifie si la planche est pleine.

        Une planche est pleine si toutes ses lignes sont
        jouées.

        N.B. Chaque ligne possède un attribut booléen
            ligne.jouee qui est à True si la ligne est jouée.

        Returns :
            bool : True si la grille est pleine, False sinon

        TODO: compléter le corps de cette fonction.
        """
        pass

    def jouer_coup(self, index_ligne, couleur):
        """
        ÉTAPE 2

        Méthode qui va gérer la logique de jeu d'un coup dans
        la planche de pipopipette.

        Cette méthode doit donc:
        - Mettre à jour les attributs couleur_dernier_coup et
          position_dernier_coup
        - Mettre à jour l'attribut jouee de la ligne située à
          l'index joué

        Args :
            index_ligne (int, int, str): L'index de la ligne jouée
            couleur (str): La couleur du joueur qui joue la ligne

        TODO: compléter le corps de cette fonction.
        """
        pass

    def valider_coup(self, index_ligne):
        """
        ÉTAPE 2

        Méthode permettant de vérifier la validité d'un coup.

        Dans le contexte du jeu de pipopipette, un coup est un
        index de ligne au format (int, int, str).

        Un coup est invalide (1) si son orientation n'est pas
        'H' ni 'V', (2) s'il n'est pas dans les limites
        ou (3) s'il est tenté sur une ligne déjà jourée. On
        retourne False ainsi qu'un message d'erreur approprié
        selon la raison de l'échec pour un coup invalide.

        Pour le cas (2), la classe Planche possède la méthode
        coup_dans_les_limites(), utilisez la !

        N.B. : Pour retourner deux valeurs comme vous le demande
            cette fonction, vous n'avez qu'à les séparer d'une virgule:

            return valeur_1, valeur_2

        Args :
            coup (int, int, str): l'index de la ligne jouée

        Returns :
            bool: True si le coup est valide, False sinon

            str: message d'erreur approprié si le coup est invalide, None sinon

        TODO: compléter le corps de cette fonction.
        """
        pass

    def obtenir_coups_possibles(self):
        """
        ÉTAPE 2

        Obtient la liste de tous les coups possibles.

        Returns :
            List[(int, int, str)]: liste de toutes les lignes non jouées de la planche

        TODO: compléter le corps de cette fonction.
        """
        pass

    def maj_boites(self):
        """
        ÉTAPE 3

        Cette méthode effectue la mise à jour des boîtes après un coup.

        Elle commence par obtenir les index des boîtes à valider (seulement
        les boîtes qui touchent à la ligne jouée) avec la méthode
        self.valider_boites() et ensuite leur assigner la bonne couleur
        au besoin avec la méthode self.valider_boites().

        Returns:
            bool: Le retour de self.valider_boites(). (True si une boîte a
                été remplie par le dernier coup, False sinon.)

        TODO: compléter le corps de cette fonction.
        """
        pass

    def obtenir_idx_boites_a_valider(self):
        """
        ÉTAPE 3

        Méthode qui retourne les index de toutes les boîtes qui touchent à
        la dernière ligne jouée. Vous pouvez accéder à l'index de la dernière
        ligne jouée avec l'attribut self.position_dernier_coup.

        La ou les boîtes à valider dépendent de l'orientation du dernier coup :

        - Si la dernière ligne était verticale (orientation == 'V'), les boîtes
          lui touchant sont celles correspondant à (ligne, colonne) et
          (ligne, colonne - 1), soit les boîtes inférieure et supérieure à la ligne.

        - Si la dernière ligne était horizontale (orientation == 'H'), les boîtes
          lui touchant sont celles correspondant à (ligne, colonne) et
          (ligne - 1, colonne), soit les boîtes à droite et à gauche de la ligne.

        Notez qu'il est possible que l'une des deux boîtes énoncées plus haut
        soit hors limites. Par exemple, si la dernière ligne jouée était la
        ligne horizontale du haut gauche (0, 0, 'H'), on aura une boîte inférieure
        à l'index (0, 0) mais aucune boîte supérieure à l'index (0, -1) car l'index
        est en dehors des limites de la planche.

        La fonction doit donc s'assurer que chacun des index retournés correspond
        à l'index d'une boîte valide. Pour faire la validation qu'un index de boîte
        est valide, vous pouvez simplement vérifier si ledit index est présent dans les
        clés de self.boites.

        Returns:
            List[(int, int)]: la liste des index des boîtes touchées par le dernier coup

        TODO: compléter le corps de cette fonction.
        """
        pass

    def compter_lignes_jouees_boite(self, idx_boite):
        """
        ÉTAPE 3

        Méthode qui compte le nombre de lignes qui sont jouées autour de l'index
        d'une boîte.

        On vérifie donc les lignes (1) verticale supérieure, (2) verticale
        inférieure, (3) horizontale gauche et (4) horizontale droite de la boîte.
        Vous devez utiliser l'index de la boîte pour retrouver l'index de chacune
        des quatre lignes à valider.

        Pour savoir si une ligne est jouée, il suffit de vérifier si son attribut
        ligne.jouee est True.

        Args:
            idx_boite (int, int): L'index la boîte autour de laquelle on valide.

        Returns:
            int: le nombre de lignes jouées autour de la boîte.

        TODO: compléter le corps de cette fonction.
        """
        pass

    def valider_boites(self, idx_boites):
        """
        ÉTAPE 3

        Méthode qui fait la validation de l'état des boîtes dans une liste
        d'index.

        La validation d'une boîte se fait comme suit:

        - Si la boîte est déjà pleine (son attribut pleine est True),
          on ne fait rien et on passe à la prochaine boîte.

        - Sinon, on compte les nombre de lignes jouées autour de la boîte
          avec la méthode self.compter_lignes_jouees_boites(). Si le nombre
          de lignes autour de la boite est 4, c'est que la boîte est maintenant
          pleine. Si la boîte est maintenant pleine, on fait appel à la méthode
          assigner_couleur() de Boite en passant comme argument la couleur du
          dernier coup contenue dans self.couleur_dernier_coup.

        Enfin, on retourne une valeur booléene correspondant à si au moins une
        des boîtes est maintenant remplie.

        Args:
            idx_boites (List[(int, int)]): la liste des index des boîtes à valider

        Returns:
            bool: True si au moins une des boîtes est maintenant remplie, False
                sinon.

        TODO: compléter le corps de cette fonction.
        """
        pass

    def bilan_boites(self):
        """
        ÉTAPE 3

        Méthode qui calcule le nombre de boîtes associées à chacun des joueurs en
        fonction de leur couleur.

        On itère donc sur toutes les boîtes de l'attribut self.boites et, pour savoir
        si une boîte est de la couleur rouge, on teste seulement si son attribut
        boite.couleur est égal à 'rouge'. Idem pour la couleur bleue.

        On retourne ensuite, dans l'ordre, le nombre de boîte bleues et de boîtes rouges.

        N.B. Pour retourner plus d'une valeur dans une fonction, il suffit de les
             séparer par une virgule i.e.

             return valeur_1, valeur_2

        Returns:
            int: Le nombre de boîtes bleues dans la planche
            int: le nombre de boîtes rouges dans la planche

        TODO: compléter le corps de cette fonction.
        """
        pass

    def convertir_en_chaine(self):
        """
        ÉTAPE 6

        Retourne une chaîne de caractères correspond à l'état actuel
        de la planche. Cette chaîne contiendra l'information relative
        aux lignes ainsi qu'aux boîtes.

        On ajoute d'abord l'information des lignes: pour chaque ligne
        jouée (où l'attribut ligne.jouee est True), on ajoute une entrée
        ligne,colonne,orientation\n correspondant à l'index de la ligne
        et un changement de ligne à la chaîne de caractères.

        On ajoute ensuite l'information des boîtes: pour chaque boîte
        pleine (où l'attribut boite.pleine est True), on ajoute une
        entrée ligne,colonne,couleur\n correspondant à l'index de la boîte,
        sa couleur et un changement de ligne à la chaine de caractères.

        Returns:
            str: La chaîne de caractères représentant la planche.

        TODO: compléter le corps de cette fonction.
        """
        pass

    def charger_dune_chaine(self, chaine):
        """
        ÉTAPE 6

        Remplit la grille à partir d'une chaîne de caractères comportant
        l'information sur les lignes et les boîtes.

        Chaque ligne du fichier contient l'information suivante :
        ligne,colonne,attribut

        Si l'attribut est 'H' ou 'V', c'est que la ligne du fichier
        contient l'information relative à une ligne jouée et attribut
        représente l'orientation de la ligne. Dans ce cas, on va chercher
        la ligne correspondant à l'index (ligne, colonne, attribut) de
        self.lignes et on assigne la valeur True à son attribut jouee.

        Sinon, cela veut dire que attribut correspond à la couleur d'une
        boîte pleine. Dans ce cas, on va donc chercher la boîte à l'index
        (ligne, colonne) et on appelle sa méthode assigner_couleur() avec
        l'argument attribut (la couleur de la boîte à cet index).

        Args :
            chaine (str): la chaîne de caractères représentant la planche

        TODO: compléter le corps de cette fonction.
        """
        pass

    def __repr__(self):
        """
        Cette méthode spéciale permet de modifier le comportement
        d'une instance de la classe Planche pour l'affichage.

        Faire un print(une_planche) affichera la planche à l'écran.
        """
        decalage_nouvelle_ligne = '\n' + ' ' * 3
        planche = ''

        planche += decalage_nouvelle_ligne

        for idx_colonne in range(Planche.N_BOITES_V + 1):
            planche += '{:<4}'.format(idx_colonne)

        for idx_ligne in range(Planche.N_BOITES_H):
            planche += decalage_nouvelle_ligne

            # On commence par dessiner la ligne du haut de la planche
            for idx_colonne in range(Planche.N_BOITES_V):
                planche += '+'
                planche += '---' if self.lignes[(idx_ligne, idx_colonne, 'H')].jouee else '   '

            planche += '+{:>2}'.format(idx_ligne) + decalage_nouvelle_ligne

            # On rajoute les lignes verticales et la couleur des boîtes
            for idx_colonne in range(Planche.N_BOITES_V):
                planche += '|' if self.lignes[(idx_ligne, idx_colonne, 'V')].jouee else ' '
                planche += '{:^3}'.format(self.boites[(idx_ligne, idx_colonne)].couleur_formattee())

            # On rajoute la ligne verticale du bout
            planche += '|' if self.lignes[(idx_ligne, Planche.N_BOITES_V, 'V')].jouee else ' '

        planche += decalage_nouvelle_ligne

        # On rajoute la ligne horizontale du bas
        for idx_colonne in range(Planche.N_BOITES_V):
            planche += '+'
            planche += '---' if self.lignes[(Planche.N_BOITES_H, idx_colonne, 'H')].jouee else '   '

        planche += '+{:>2}'.format(Planche.N_BOITES_H) + decalage_nouvelle_ligne

        return planche

J'ai également 2 fichiers .txt utiles pour le code
le fichier partie_en_cours.txt et le fichier partie_vierge.txt

fichier partie_en_cours.txt

rouge
Humain
Humain
0,3,V
1,3,V
2,3,V
3,0,H
3,1,H
3,2,H
0,0,H
1,0,H
1,0,V
2,0,H
2,0,V
0,1,H
0,1,V
1,1,H
1,1,V
2,1,H
2,1,V
0,2,H
0,2,V
1,2,H
2,2,H
2,2,V
1,0,rouge
2,0,rouge
0,1,bleu
2,1,rouge
0,2,rouge
2,2,rouge

fichier partie_vierge.txt

rouge
Humain
Humain