Jeu des carrés ou pipopipette [Résolu]

A voir également:Jeu des carrés ou pipopipettePC plante pendant jeu écran carré puis bleu ✓ - Forum - Matériel informatique Jeu du carré rouge - Forum - Jeux vidéo Jeu ps3 sur ps4 ✓ - Forum - PS4 Jeu google halloween 2018 - Actualités Jeu concours facebook - Conseils pratiques - e-communication

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  

Forum

A voir également:Jeu des carrés ou pipopipettePC plante pendant jeu écran carré puis bleu ✓ - Forum - Matériel informatique Jeu du carré rouge - Forum - Jeux vidéo Jeu ps3 sur ps4 ✓ - Forum - PS4 Jeu google halloween 2018 - Actualités Jeu concours facebook - Conseils pratiques - e-communication

Web: www.shapebootstrap.net

7 réponses

Marsh

NOVEMBER 9, 2013 AT 9:15 PM

bonjour, tu ne précises pas ce que tu attends précisément de nous. nous demandes-tu de faire l'exercice à ta place? dans quel but?

Reply

Marsh

NOVEMBER 9, 2013 AT 9:15 PM

Hello
J'aime concevoir des jeux et j'aimerais juste le faire pour le plaisir. Je le faisais en VBA et là, je veux me lancer en python.
Merci

Reply
réponses:
  • auteur

Marsh

NOVEMBER 9, 2013 AT 9:15 PM

bonjour. As-tu trouvee la resolution pour ton TP? si oui, envoye le moi aussi j'en ai besoin. merci

Reply

Marsh

NOVEMBER 9, 2013 AT 9:15 PM

Bonjour. Belle journée. J'ai commencé et voici, j'ai un soucis au niveau de la première fonction avec orientation.
Voici ce que j'ai fait dans


def initialiser_lignes(self):
"""
self.lignes = {}
for i in range(Planche.N_BOITES_V):
for j in range(Planche.N_BOITES_H):
self.lignes [(i, j, orientation)] = Ligne()
return self.lignes

Reply
réponses:
  • auteur

  • auteur

Marsh

NOVEMBER 9, 2013 AT 9:15 PM

Bonjour, j'espère que vous allez bien.
J'ai presque terminé le jeu en question, mais là, j'ai un soucis au niveau de def initialiser_lignes(self), fichier planche.py (voir message source, tout en haut). Merci de bien vouloir m'éclairer .

     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().         """         self.lignes = {}         orientations = ["H", "V"]         for ligne in range(Planche.N_BOITES_H + 1):             for colonne in range(Planche.N_BOITES_V + 1):                 for orientation in orientations:                        self.lignes[(ligne, colonne, orientation)] = Ligne()         return self.lignes 


Aussi au niveau de def est_pleine(self), j'ai une erreur qui s'affiche: TypeError: 'dict' object is not callable
     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         """         for ligne in range(Planche.N_BOITES_H):             for colonne in range(Planche.N_BOITES_V + 1):                 if self.lignes(ligne) == False:                     return False         return True 

Reply
réponses:
  • auteur

Marsh

NOVEMBER 9, 2013 AT 9:15 PM

Bonjour,
Peux tu nous montrer ton code final pour le jeu pipopipette cela m'intringue et j'ai vraiment envie de voir ce code car n'etant pas capable de le faire merci a toi.

Reply

Marsh

NOVEMBER 9, 2013 AT 9:15 PM

Svp merci

Reply

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed