def __init__(self): threading.Thread.__init__(self) super().__init__() # tailles de cases self.width = 20 self.height = 20 # espace entre les cases self.margin = 5 # les tableaux self.grid = [] self.case = [] self.case1 = [] n = -1 p = -1 self.b = 0 self.c = 0 self.test = 0 self.a = 0 nbr_generation = 0 self.nbx = Damier.longueur(n) self.nby = Damier.largeur(p) self.nbr_generation = Simulation.nbr_génération(nbr_generation) for row in range(self.nbx): # Add an empty array that will hold each cell # in this row self.grid.append([]) for column in range(self.nby): self.grid[row].append(0) # Append a cell
def __init__(self): """Constructeur de la classe Partie. Initialise les attributs à leur valeur par défaut. Le damier est construit avec les pièces à leur valeur initiales, le joueur actif est le joueur blanc, et celui-ci n'est pas forcé de prendre une pièce adverse. Aucune position source n'est sélectionnée, et aucune position source n'est forcée. """ self.damier = Damier() self.couleur_joueur_courant = "blanc" self.doit_prendre = False self.position_source_selectionnee = None self.position_source_forcee = None
def __init__(self): """ Méthode d'initialisation d'une partie. On initialise 4 membres: - damier: contient le damier de la partie, celui-ci contenant le dictionnaire de pièces. - couleur_joueur_courant: le joueur à qui c'est le tour de jouer. - doit_prendre: un booléen représentant si le joueur actif doit absoluement effectuer une prise de pièce. - position_source_forcee: Une position avec laquelle le joueur actif doit absoluement jouer. Le seul moment où cette position est utilisée est après une prise: si le joueur peut encore prendre d'autres pièces adverses, il doit absolument le faire. Ce membre contient None si aucune position n'est forcée. """ self.damier = Damier() self.couleur_joueur_courant = "blanc" self.doit_prendre = False self.position_source_forcee = None
def piece_peut_sauter_vers_modif(position_piece, position_cible, dic): """Cette méthode détermine si une pièce (à la position reçue) peut sauter vers une certaine position cible. On parle ici d'un déplacement qui "mange" une pièce adverse. Une pièce doit être positionnée à la position_piece reçue en argument (retourner False autrement). Une pièce ne peut que sauter de deux cases en diagonale. N'importe quel type de pièce (pion ou dame) peut sauter vers l'avant ou vers l'arrière. Une pièce ne peut pas sauter vers une case qui est déjà occupée par une autre pièce. Une pièce ne peut faire un saut que si elle saute par dessus une pièce de couleur adverse. Args: position_piece (Position): La position de la pièce source du saut. position_cible (Position): La position cible du saut. dic (dict): Dictionnaire des positions. Returns: bool: True si la pièce peut sauter vers la position cible, False autrement. """ position_piece_mange = position_piece.position_mange(position_cible) #s'il y a une piece à manger if position_piece_mange in dic: piece_mange = dic[position_piece_mange] # Si la position est dans le damier, s'il y a une pièce sur la case et si la position_cible est libre" if Damier().position_est_dans_damier( position_cible ) and position_piece in dic and not position_cible in dic: # Si la piece est adverse if dic[position_piece].est_noire() and piece_mange.est_blanche(): return True elif dic[position_piece].est_blanche() and piece_mange.est_noire(): return True else: return False else: return False else: return False
def print_damier(dic): """Affiche un damier. Args: dic (dict): Dictionnaire d'une position. Returns: (str): Représentation des pieces du damier. """ return Damier().print_damier(dic)
def position_cible_valide(self, position_cible): """Vérifie si la position cible est valide (en fonction de la position source sélectionnée). Doit non seulement vérifier si le déplacement serait valide (utilisez les méthodes que vous avez programmées dans le Damier!), mais également si le joueur a respecté la contrainte de prise obligatoire. Returns: bool, str: Deux valeurs, la première étant Booléenne et indiquant si la position cible est valide, et la seconde valeur est une chaîne de caractères indiquant un message d'erreur (ou une chaîne vide s'il n'y a pas d'erreur). """ #TODO: À compléter # On vérifie en premier si la position sont dans les bornes du damier et qu'elle est valide # On retour une Booléenne et on indique si la position cible if (Damier.piece_peut_se_deplacer(self,position_cible)): valide_str = "" valide = True return [valide, valide_str] else: valide_str = "erreur" valide = False return [valide, valide_str]
def piece_peut_se_deplacer_vers_modif(position_piece, position_cible, dic): """Cette méthode détermine si une pièce (à la position reçue) peut se déplacer à une certaine position cible. On parle ici d'un déplacement standard (et non une prise). Une pièce doit être positionnée à la position_piece reçue en argument (retourner False autrement). Une pièce de type pion ne peut qu'avancer en diagonale (vers le haut pour une pièce blanche, vers le bas pour une pièce noire). Une pièce de type dame peut avancer sur n'importe quelle diagonale, peu importe sa couleur. Une pièce ne peut pas se déplacer sur une case déjà occupée par une autre pièce. Une pièce ne peut pas se déplacer à l'extérieur du damier. Args: position_piece (Position): La position de la pièce source du déplacement. position_cible (Position): La position cible du déplacement. dic (dict): Dictionnaire des positions. Returns: bool: True si la pièce peut se déplacer à la position cible, False autrement. """ #si la position est dans le damier et s'il y a une piece sur la case et si la position_cible n'est pas occupée if Damier().position_est_dans_damier( position_cible ) and position_piece in dic and not position_cible in dic: if dic[position_piece].est_dame(): if position_cible in position_piece.quatre_positions_diagonales(): return True else: return False elif dic[position_piece].est_noire(): if position_cible in position_piece.positions_diagonales_bas(): return True else: return False elif dic[position_piece].est_blanche(): if position_cible in position_piece.positions_diagonales_haut(): return True else: return False else: return False
self.couleur_joueur_courant = ofich.readline( ) # Lecture de la premiere ligne du fichier self.doit_prendre = ofich.readline( ) # Lecture de la deuxime ligne du fichier self.position_source_forcee = ofich.readline( ) # Lecture de la troisieme ligne du fichier while 1: # Lecture du reste du fichier jusqu'à sa fin ligne = ofich.readline() if ligne == "": # Si on arrive à la fin du fichier on arrête break self.damier.charger_dune_chaine( ligne) # chargement du Damier ligne par ligne ofich.close() # Fermeture du fichier ouvert if __name__ == "__main__": # Point d'entrée du programme. On initialise une nouvelle partie, et on appelle la méthode jouer(). print(Damier()) partie = Partie() # Si on veut sauvegarder une partie. #partie.sauvegarder("ma_partie.txt") # Si on veut charger un fichier. #partie.charger("exemple_partie.txt") gagnant = partie.jouer() print("------------------------------------------------------") print("Partie terminée! Le joueur gagnant est le joueur", gagnant)
class Partie: """Gestionnaire de partie de dames. Attributes: damier (Damier): Le damier de la partie, contenant notamment les pièces. couleur_joueur_courant (str): Le joueur à qui c'est le tour de jouer. doit_prendre (bool): Un booléen représentant si le joueur actif doit absolument effectuer une prise de pièce. Sera utile pour valider les mouvements et pour gérer les prises multiples. position_source_selectionnee (Position): La position source qui a été sélectionnée. Utile pour sauvegarder cette information avant de poursuivre. Contient None si aucune pièce n'est sélectionnée. position_source_forcee (Position): Une position avec laquelle le joueur actif doit absolument jouer. Le seul moment où cette position est utilisée est après une prise: si le joueur peut encore prendre d'autres pièces adverses, il doit absolument le faire. Ce membre contient None si aucune position n'est forcée. """ def __init__(self): """Constructeur de la classe Partie. Initialise les attributs à leur valeur par défaut. Le damier est construit avec les pièces à leur valeur initiales, le joueur actif est le joueur blanc, et celui-ci n'est pas forcé de prendre une pièce adverse. Aucune position source n'est sélectionnée, et aucune position source n'est forcée. """ self.damier = Damier() self.couple_de_position = None self.couleur_joueur_courant = "blanc" self.doit_prendre = False self.position_source_selectionnee = None self.position_source_forcee = None def position_source_valide(self, position_source): """Vérifie la validité de la position source, notamment: - Est-ce que la position contient une pièce? - Est-ce que cette pièce est de la couleur du joueur actif? - Si le joueur doit absolument continuer son mouvement avec une prise supplémentaire, a-t-il choisi la bonne pièce? Cette méthode retourne deux valeurs. La première valeur est Booléenne (True ou False), et la seconde valeur est un message d'erreur indiquant la raison pourquoi la position n'est pas valide (ou une chaîne vide s'il n'y a pas d'erreur). ATTENTION: Utilisez les attributs de la classe pour connaître les informations sur le jeu! (le damier, le joueur actif, si une position source est forcée, etc. ATTENTION: Vous avez accès ici à un attribut de type Damier. vous avez accès à plusieurs méthodes pratiques dans le damier qui vous simplifieront la tâche ici :) Args: position_source (Position): La position source à valider. Returns: bool, str: Un couple où le premier élément représente la validité de la position (True ou False), et le deuxième élément est un message d'erreur (ou une chaîne vide s'il n'y a pas d'erreur). """ piece_source = self.damier.recuperer_piece_a_position(position_source) if piece_source is None: return False, "Position source invalide: aucune pièce à cet endroit" if not piece_source.couleur == self.couleur_joueur_courant: return False, "Position source invalide: pièce de mauvaise couleur" if self.position_source_forcee is not None: if not (self.position_source_forcee == position_source): return False, "Position source invalide: vous devez faire jouer avec la pièce " + \ "en ({},{})".format(self.position_source_forcee.ligne, self.position_source_forcee.colonne) return True, "" def position_cible_valide(self, position_cible): """Vérifie si la position cible est valide (en fonction de la position source sélectionnée). Doit non seulement vérifier si le déplacement serait valide (utilisez les méthodes que vous avez programmées dans le Damier!), mais également si le joueur a respecté la contrainte de prise obligatoire. Returns: bool, str: Deux valeurs, la première étant Booléenne et indiquant si la position cible est valide, et la seconde valeur est une chaîne de caractères indiquant un message d'erreur (ou une chaîne vide s'il n'y a pas d'erreur). """ if self.damier.piece_peut_se_deplacer_vers(self.position_source_selectionnee, position_cible): if not self.doit_prendre: return True, "" else: return False, "Le déplacement demandé n'est pas une prise alors qu'une prise est possible" elif self.damier.piece_peut_sauter_vers(self.position_source_selectionnee, position_cible): return True, "" return False, "Position cible invalide" def demander_positions_deplacement(self): """Demande à l'utilisateur les positions sources et cible, et valide ces positions. Cette méthode doit demander les positions à l'utilisateur tant que celles-ci sont invalides. Cette méthode ne doit jamais planter, peu importe ce que l'utilisateur entre. Returns: Position, Position: Un couple de deux positions (source et cible). """ position_source = None position_cible = None positions_valides = False while not positions_valides: source_ligne = "" while not source_ligne.isnumeric(): source_ligne = input("Position source) Numéro de ligne : ") source_colonne = "" while not source_colonne.isnumeric(): source_colonne = input("Position source) Numéro de colonne : ") position_source = Position(int(source_ligne), int(source_colonne)) position_valide, message = self.position_source_valide(position_source) if not position_valide: print("Erreur: {}.\n".format(message)) continue self.position_source_selectionnee = position_source cible_ligne = "" while not cible_ligne.isnumeric(): cible_ligne = input("Position cible) Numéro de ligne : ") cible_colonne = "" while not cible_colonne.isnumeric(): cible_colonne = input("Position cible) Numéro de colonne : ") position_cible = Position(int(cible_ligne), int(cible_colonne)) position_valide, message = self.position_cible_valide(position_cible) if not position_valide: print(message + "\n") continue self.position_source_selectionnee = None positions_valides = True return position_source, position_cible def tour(self): """Cette méthode effectue le tour d'un joueur, et doit effectuer les actions suivantes: - Assigne self.doit_prendre à True si le joueur courant a la possibilité de prendre une pièce adverse. - Affiche l'état du jeu - Demander les positions source et cible (utilisez self.demander_positions_deplacement!) - Effectuer le déplacement (à l'aide de la méthode du damier appropriée) - Si une pièce a été prise lors du déplacement, c'est encore au tour du même joueur si celui-ci peut encore prendre une pièce adverse en continuant son mouvement. Utilisez les membres self.doit_prendre et self.position_source_forcee pour forcer ce prochain tour! - Si aucune pièce n'a été prise ou qu'aucun coup supplémentaire peut être fait avec la même pièce, c'est le tour du joueur adverse. Mettez à jour les attributs de la classe en conséquence. """ # Détermine si le joueur courant a la possibilité de prendre une pièce adverse. if self.damier.piece_de_couleur_peut_faire_une_prise(self.couleur_joueur_courant): self.doit_prendre = True # Demander les positions position_source, position_cible = self.couple_de_position # Effectuer le déplacement (à l'aide de la méthode du damier appropriée) resultat_deplacement = self.damier.deplacer(position_source, position_cible) if resultat_deplacement == "erreur": print("Une erreur s'est produite lors du déplacement.") return # Mettre à jour les attributs de la classe self.doit_prendre = False self.position_source_forcee = None if resultat_deplacement == "prise" and self.damier.piece_peut_faire_une_prise(position_cible): self.doit_prendre = True self.position_source_forcee = position_cible elif self.couleur_joueur_courant == "blanc": self.couleur_joueur_courant = "noir" else: self.couleur_joueur_courant = "blanc" # Affiche l'état du jeu print(self.damier) print("") print("Tour du joueur", self.couleur_joueur_courant, end=".") if self.doit_prendre: if self.position_source_forcee is None: print(" Doit prendre une pièce.") else: print(" Doit prendre avec la pièce en position {}.".format(self.position_source_forcee)) else: print("") self.position_source_selectionnee = None def jouer(self): """Démarre une partie. Tant que le joueur courant a des déplacements possibles (utilisez les méthodes appriopriées!), un nouveau tour est joué. Returns: str: La couleur du joueur gagnant. """ while self.damier.piece_de_couleur_peut_se_deplacer(self.couleur_joueur_courant) or \ self.damier.piece_de_couleur_peut_faire_une_prise(self.couleur_joueur_courant): self.tour() print(self.damier) if self.couleur_joueur_courant == "blanc": return "noir" else: return "blanc"
class Partie: """Gestionnaire de partie de dames. Attributes: damier (Damier): Le damier de la partie, contenant notamment les pièces. couleur_joueur_courant (str): Le joueur à qui c'est le tour de jouer. doit_prendre (bool): Un booléen représentant si le joueur actif doit absolument effectuer une prise de pièce. Sera utile pour valider les mouvements et pour gérer les prises multiples. position_source_selectionnee (Position): La position source qui a été sélectionnée. Utile pour sauvegarder cette information avant de poursuivre. Contient None si aucune pièce n'est sélectionnée. position_source_forcee (Position): Une position avec laquelle le joueur actif doit absolument jouer. Le seul moment où cette position est utilisée est après une prise: si le joueur peut encore prendre d'autres pièces adverses, il doit absolument le faire. Ce membre contient None si aucune position n'est forcée. """ def __init__(self): """Constructeur de la classe Partie. Initialise les attributs à leur valeur par défaut. Le damier est construit avec les pièces à leur valeur initiales, le joueur actif est le joueur blanc, et celui-ci n'est pas forcé de prendre une pièce adverse. Aucune position source n'est sélectionnée, et aucune position source n'est forcée. """ self.damier = Damier() self.couleur_joueur_courant = "blanc" self.doit_prendre = False self.position_source_selectionnee = None self.position_source_forcee = None def position_source_valide(self, position_source): """Vérifie la validité de la position source, notamment: - Est-ce que la position contient une pièce? - Est-ce que cette pièce est de la couleur du joueur actif? - Si le joueur doit absolument continuer son mouvement avec une prise supplémentaire, a-t-il choisi la bonne pièce? Cette méthode retourne deux valeurs. La première valeur est Booléenne (True ou False), et la seconde valeur est un message d'erreur indiquant la raison pourquoi la position n'est pas valide (ou une chaîne vide s'il n'y a pas d'erreur). ATTENTION: Utilisez les attributs de la classe pour connaître les informations sur le jeu! (le damier, le joueur actif, si une position source est forcée, etc. ATTENTION: Vous avez accès ici à un attribut de type Damier. vous avez accès à plusieurs méthodes pratiques dans le damier qui vous simplifieront la tâche ici :) Args: position_source (Position): La position source à valider. Returns: bool, str: Un couple où le premier élément représente la validité de la position (True ou False), et le deuxième élément est un message d'erreur (ou une chaîne vide s'il n'y a pas d'erreur). """ #TODO: À compléter return ( #position_source in self.cases ) def position_cible_valide(self, position_cible): """Vérifie si la position cible est valide (en fonction de la position source sélectionnée). Doit non seulement vérifier si le déplacement serait valide (utilisez les méthodes que vous avez programmées dans le Damier!), mais également si le joueur a respecté la contrainte de prise obligatoire. Returns: bool, str: Deux valeurs, la première étant Booléenne et indiquant si la position cible est valide, et la seconde valeur est une chaîne de caractères indiquant un message d'erreur (ou une chaîne vide s'il n'y a pas d'erreur). """ #TODO: À compléter # On vérifie en premier si la position sont dans les bornes du damier et qu'elle est valide # On retour une Booléenne et on indique si la position cible if (Damier.piece_peut_se_deplacer(self,position_cible)): valide_str = "" valide = True return [valide, valide_str] else: valide_str = "erreur" valide = False return [valide, valide_str] def demander_positions_deplacement(self): """Demande à l'utilisateur les positions sources et cible, et valide ces positions. Cette méthode doit demander les positions à l'utilisateur tant que celles-ci sont invalides. Cette méthode ne doit jamais planter, peu importe ce que l'utilisateur entre. Returns: Position, Position: Un couple de deux positions (source et cible). """ #TODO: À compléter # On veut convertir la réponse de l'utilisateur en tuple # On ne valide pas l'input de l'utilisateur position_source = tuple( [eval(i) for i in input("Veuillez entrer les coordonnées de votre position source (ex. 3,3): ").split(',')]) position_cible = tuple( map(int, input("Veuillez entrer les coordonnées de votre position cible (ex. 5,5): ").split(','))) return position_source, position_cible def tour(self): """Cette méthode effectue le tour d'un joueur, et doit effectuer les actions suivantes: - Assigne self.doit_prendre à True si le joueur courant a la possibilité de prendre une pièce adverse. - Affiche l'état du jeu - Demander les positions source et cible (utilisez self.demander_positions_deplacement!) - Effectuer le déplacement (à l'aide de la méthode du damier appropriée) - Si une pièce a été prise lors du déplacement, c'est encore au tour du même joueur si celui-ci peut encore prendre une pièce adverse en continuant son mouvement. Utilisez les membres self.doit_prendre et self.position_source_forcee pour forcer ce prochain tour! - Si aucune pièce n'a été prise ou qu'aucun coup supplémentaire peut être fait avec la même pièce, c'est le tour du joueur adverse. Mettez à jour les attributs de la classe en conséquence. """ # Détermine si le joueur courant a la possibilité de prendre une pièce adverse. if self.damier.piece_de_couleur_peut_faire_une_prise(self.couleur_joueur_courant): self.doit_prendre = True # Affiche l'état du jeu print(self.damier) print("") print("Tour du joueur", self.couleur_joueur_courant, end=".") if self.doit_prendre: if self.position_source_forcee is None: print(" Doit prendre une pièce.") else: print(" Doit prendre avec la pièce en position {}.".format(self.position_source_forcee)) else: print("") # Demander les positions # TODO: À compléter self.position_source_selectionnee # Effectuer le déplacement (à l'aide de la méthode du damier appropriée) # TODO: À compléter # Mettre à jour les attributs de la classe # TODO: À compléter def jouer(self): """Démarre une partie. Tant que le joueur courant a des déplacements possibles (utilisez les méthodes
class Partie: """Gestionnaire de partie de dames. Attributes: damier (Damier): Le damier de la partie, contenant notamment les pièces. couleur_joueur_courant (str): Le joueur à qui c'est le tour de jouer. doit_prendre (bool): Un booléen représentant si le joueur actif doit absolument effectuer une prise de pièce. Sera utile pour valider les mouvements et pour gérer les prises multiples. position_source_selectionnee (Position): La position source qui a été sélectionnée. Utile pour sauvegarder cette information avant de poursuivre. Contient None si aucune pièce n'est sélectionnée. position_source_forcee (Position): Une position avec laquelle le joueur actif doit absolument jouer. Le seul moment où cette position est utilisée est après une prise: si le joueur peut encore prendre d'autres pièces adverses, il doit absolument le faire. Ce membre contient None si aucune position n'est forcée. """ def __init__(self): """Constructeur de la classe Partie. Initialise les attributs à leur valeur par défaut. Le damier est construit avec les pièces à leur valeur initiale, le joueur actif est le joueur blanc, et celui-ci n'est pas forcé de prendre une pièce adverse. Aucune position source n'est sélectionnée, et aucune position source n'est forcée. """ self.damier = Damier() self.couleur_joueur_courant = "blanc" self.doit_prendre = False self.position_source_selectionnee = None self.position_source_forcee = None def position_source_valide(self, position_source): """Vérifie la validité de la position source, notamment: - Est-ce que la position contient une pièce? - Est-ce que cette pièce est de la couleur du joueur actif? - Si le joueur doit absolument continuer son mouvement avec une prise supplémentaire, a-t-il choisi la bonne pièce? Cette méthode retourne deux valeurs. La première valeur est Booléenne (True ou False), et la seconde valeur est un message d'erreur indiquant la raison pourquoi la position n'est pas valide (ou une chaîne vide s'il n'y a pas d'erreur). ATTENTION: Utilisez les attributs de la classe pour connaître les informations sur le jeu! (le damier, le joueur actif, si une position source est forcée, etc. ATTENTION: Vous avez accès ici à un attribut de type Damier. vous avez accès à plusieurs méthodes pratiques dans le damier qui vous simplifieront la tâche ici :) Args: position_source (Position): La position source à valider. Returns: bool, str: Un couple où le premier élément représente la validité de la position (True ou False), et le deuxième élément est un message d'erreur (ou une chaîne vide s'il n'y a pas d'erreur). """ if position_source in self.damier.cases: if self.doit_prendre == False: if self.damier.cases[position_source].couleur == self.couleur_joueur_courant: return [True, ""] else: return [False, "Le pion sur la case n'est pas de la couleur qui vous a été attribuée. Choisissez" " une autre pièce."] elif self.damier.piece_peut_faire_une_prise(position_source): return [True, ""] else: return [False, "Vous devez choisir une pièce qui peut prendre une pièce adverse."] else: return [False, "Il n'y a pas de pièce sur la case que vous avez sélectionnée. Veuillez faire un autre choix."] def position_cible_valide(self, position_cible): """Vérifie si la position cible est valide (en fonction de la position source sélectionnée). Doit non seulement vérifier si le déplacement serait valide (utilisez les méthodes que vous avez programmées dans le Damier!), mais également si le joueur a respecté la contrainte de prise obligatoire. Returns: bool, str: Deux valeurs, la première étant Booléenne et indiquant si la position cible est valide, et la seconde valeur est une chaîne de caractères indiquant un message d'erreur (ou une chaîne vide s'il n'y a pas d'erreur). """ if self.damier.position_est_dans_damier(position_cible): return [True, ""] else: return [False, "La position choisie doit être dans le damier."] def demander_positions_deplacement(self): """Demande à l'utilisateur les positions sources et cible, et valide ces positions. Cette méthode doit demander les positions à l'utilisateur tant que celles-ci sont invalides. Cette méthode ne doit jamais planter, peu importe ce que l'utilisateur entre. Returns: Position, Position: Un couple de deux positions (source et cible). """ verif_source_cible = True while verif_source_cible: valeur_non_valide = True while valeur_non_valide: try: position_source = input('Quelle pièce désirez-vous déplacer ("ligne" "colonne" séparées par un ' 'espace)? ').strip() # Ne considère que les caractères "0" et "2" self.ligne = int(position_source[0]) except: if ValueError: print("L'entrée devrait être un nombre et est invalide. Veuillez essayer de nouveau!") else: print("L'entrée est invalide. Veuillez essayer de nouveau!") else: valeur_non_valide = False try: self.colonne = int(position_source[2]) except: valeur_non_valide = True while valeur_non_valide: try: colonne_test = input('La valeur entrée comme colonne est invalide. Veuillez entrer de nouveau ' 'la colonne (Entrer un nombre entre "0" et "7")!').strip() self.colonne = int(colonne_test) except: print("La pièce que vous désirez déplacer est dans la rangée {}.\n".format(self.ligne)) if ValueError: print("L'entrée devrait être un nombre et est invalide. Veuillez essayer de nouveau!") else: print("L'entrée est invalide. Veuillez essayer de nouveau!") else: valeur_non_valide = False position_source_selectionnee = "Position(" + str(self.ligne) + "," + str(self.colonne) + ")" position_source_selectionnee = eval(position_source_selectionnee) if self.position_source_valide(position_source_selectionnee)[0]: if self.doit_prendre == True: if self.position_source_forcee is None: verif_source_cible = False else: if self.position_source_forcee == position_source_selectionnee: print("Vous devez prendre. La pièce en position {} a été sélectionnée.".format(self.position_source_forcee)) # self.damier.piece_peut_faire_une_prise(self.position_source_forcee) verif_source_cible = False else: print("Vous devez prendre. La pièce choisie ne peut pas être sélectionnée") elif self.damier.piece_peut_se_deplacer(position_source_selectionnee): verif_source_cible = False else: print("La pièce que vous avez sélectionnée ne peut pas se déplacer. Veuillez faire un autre choix.") else: print(self.position_source_valide(position_source_selectionnee)[1]) verif_source_cible = True while verif_source_cible: valeur_non_valide = True while valeur_non_valide: try: position_cible = input("Destination choisie : ").strip() self.ligne = int(position_cible[0]) except: if ValueError: print("L'entrée devrait être un nombre et est invalide. Veuillez essayer de nouveau!") else: print("L'entrée est invalide. Veuillez essayer de nouveau!") else: valeur_non_valide = False try: self.colonne = int(position_cible[2]) except: valeur_non_valide = True while valeur_non_valide: try: colonne_test = input( "La valeur entrée comme colonne est invalide. Veuillez entrer de nouveau la colonne! ").strip() self.colonne = int(colonne_test) except: print("La pièce que vous désirez déplacer est dans la rangée {}.\n".format(self.ligne)) if ValueError: print("L'entrée devrait être un nombre et est invalide. Veuillez essayer de nouveau!") else: print("L'entrée est invalide. Veuillez essayer de nouveau!") else: valeur_non_valide = False position_cible = eval("Position(" + str(self.ligne) + ", " + str(self.colonne) + ")") if self.position_cible_valide(position_cible)[0]: if self.doit_prendre == True: if self.damier.piece_peut_sauter_vers(position_source_selectionnee, position_cible, self.couleur_joueur_courant): verif_source_cible = False else: print("La pièce choisie doit prendre une pièce adverse. La cible choisie doit être modifiée.") elif self.damier.piece_peut_se_deplacer_vers(position_source_selectionnee, position_cible): verif_source_cible = False else: print("La pièce choisie ne peut pas être déplacée vers cette case.\n") else: print(self.position_cible_valide(position_cible)[1]) return [position_source_selectionnee, position_cible] def tour(self): """Cette méthode effectue le tour d'un joueur, et doit effectuer les actions suivantes: - Assigne self.doit_prendre à True si le joueur courant a la possibilité de prendre une pièce adverse. - Affiche l'état du jeu - Demander les positions source et cible (utilisez self.demander_positions_deplacement!) - Effectuer le déplacement (à l'aide de la méthode du damier appropriée) - Si une pièce a été prise lors du déplacement, c'est encore au tour du même joueur si celui-ci peut encore prendre une pièce adverse en continuant son mouvement. Utilisez les membres self.doit_prendre et self.position_source_forcee pour forcer ce prochain tour! - Si aucune pièce n'a été prise ou qu'aucun coup supplémentaire peut être fait avec la même pièce, c'est le tour du joueur adverse. Mettez à jour les attributs de la classe en conséquence. """ # Détermine si le joueur courant a la possibilité de prendre une pièce adverse. if self.damier.piece_de_couleur_peut_faire_une_prise(self.couleur_joueur_courant): self.doit_prendre = True # Affiche l'état du jeu print(self.damier) print("") print("Tour du joueur", self.couleur_joueur_courant, end=".") if self.doit_prendre: if self.position_source_forcee is None: print(" Le joueur doit prendre une pièce.") else: print(" La pièce en position {} doit faire une autre prise.".format(self.position_source_forcee)) else: print("") # Demander les positions [position_source, position_cible] = self.demander_positions_deplacement() # Effectue le déplacement (à l'aide de la méthode du damier appropriée) retour_apres_deplacement = self.damier.deplacer(position_source, position_cible) # ok, prise ou erreur # Met à jour les attributs de la classe if retour_apres_deplacement == "ok": pass elif retour_apres_deplacement == "prise": if self.damier.piece_peut_faire_une_prise(position_cible): self.position_source_forcee = position_cible self.doit_prendre = True else: self.doit_prendre = False self.position_source_selectionnee = None self.position_source_forcee = None else: print("Il y a erreur dans le code!") if self.doit_prendre == False: if self.couleur_joueur_courant == "blanc": self.couleur_joueur_courant = "noir" else: self.couleur_joueur_courant = "blanc" # @property def jouer(self): """Démarre une partie. Tant que le joueur courant a des déplacements possibles (utilisez les méthodes appriopriées!), un nouveau tour est joué. Returns: str: La couleur du joueur gagnant. """ while self.damier.piece_de_couleur_peut_se_deplacer(self.couleur_joueur_courant) or \ self.damier.piece_de_couleur_peut_faire_une_prise(self.couleur_joueur_courant): print("\n") self.tour() if self.couleur_joueur_courant == "blanc": return "noir" else: return "blanc"
def run(self, n=-1, p=-1, x="", flag=1, g=-1, w=-1, y=-1, j=-1, o=-1, nbr_generation=-1): # Initialize pygame pygame.init() WINDOW_SIZE = [ self.nbx * (self.width + self.margin), self.nby * (self.height + self.margin) ] screen = pygame.display.set_mode(WINDOW_SIZE) pygame.display.set_caption(Damier.nom(x)) # Loop until the user clicks the close button. done = False clock = pygame.time.Clock() # -------- Main Program Loop ----------- while not done: for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user clicked close done = True # Flag that we are done so we exit this loop elif event.type == pygame.MOUSEBUTTONDOWN: # User clicks the mouse. Get the position pos = pygame.mouse.get_pos() # Change the x/y screen coordinates to grid coordinates column = pos[0] // (self.width + self.margin) row = pos[1] // (self.height + self.margin) # Set that location to one self.grid[row][column] = 1 print("Click ", pos, "Grid coordinates: ", row, column) # Set the screen background screen.fill(BLACK) # Draw the grid for row in range(self.nbx): for column in range(self.nby): color = WHITE if self.grid[row][column] == 1: color = GREEN if self.grid[row][column] == 2: color = RED if self.grid[row][column] == 3: color = BLACK if self.grid[row][column] == 0: color = WHITE pygame.draw.rect( screen, color, [(self.margin + self.width) * column + self.margin, (self.margin + self.height) * row + self.margin, self.width, self.height]) if self.c == 0: self.b = int( input("recupérer la sauvegarde précédente (oui:1/non:0)")) if self.b == 1: with open('save_self_case.txt', 'r') as f: self.case = f.read().splitlines() self.case = list(map(int, self.case)) with open('save_self_case1.txt', 'r') as d: self.case1 = d.read().splitlines() self.case1 = list(map(int, self.case1)) self.c = self.c + 1 else: self.c = self.c + 1 self.cellulenaissante() self.colornewcell() self.cellulemorte() if self.test == 1: self.a = self.a + 1 time.sleep(1) # Limit to 60 frames per second clock.tick(1) test = 0 # Go ahead and update the screen with what we've drawn. pygame.display.flip() # Be IDLE friendly. If you forget this line, the program will 'hang' # on exit. pygame.quit()
def game_window(size): # Création du widget principal ("maître") : fen1 = Tk() fen1.title('Othello') fen1.iconbitmap('icon3.ico') # Création des widgets "esclaves" : can1 = Canvas(fen1, bg='light steel blue', height=70 + size * 30, width=70 + size * 30) can1.pack(anchor='center') # Creation du damier d = Damier(can1) #points p1 = d.p1_var_str p2 = d.p2_var_str #Affichage des joueurs, points sur la grille p1_color = Label(fen1, anchor='w', text='Blanc: ') points1 = Label(fen1, anchor='w', textvariable=p1) p2_color = Label(fen1, anchor='w', text='Noir: ') points2 = Label(fen1, anchor='w', textvariable=p2) p1_color.pack() points1.pack() p2_color.pack() points2.pack() current_player = d.current_player turn_label = Label(fen1, anchor='w', text='le tour est au: ') turn_player = Label(fen1, anchor='w', textvariable=current_player) turn_label.pack() turn_player.pack() #buttons bou1 = Button(fen1, text='Quitter', command=fen1.quit) bou1.pack(side='right') can1.bind("<Button-1>", d.posePion ) # on rajoute un evenement "pointeur" quand on clique gauche bou3 = Button(fen1, text='Effacer', command=d.clear) bou3.pack(side='right') bou2 = Button(fen1, text='Jouer', command=lambda: d.creation_grille(size)) bou2.pack(side='right') d.countpass = 0 # Fonction permettant de passer son tour def skip_turn(): d.move_counter += 1 d.countpass += 1 if d.countpass == 2: # Si le tour est passé de fois (par les deux joueurs), la partie se termine d.game_over() else: if d.current_color == 'snow': d.current_player.set(value='Noir') elif d.current_color == 'gray24': d.current_player.set(value='Blanc') else: pass bou4 = Button(fen1, text='Passer son tour', command=skip_turn) bou4.pack(side='bottom') fen1.mainloop() # démarrage du réceptionnaire d'événement fen1.destroy() # destruction (fermeture) de la fenêtre
class Partie: def __init__(self): """ Méthode d'initialisation d'une partie. On initialise 4 membres: - damier: contient le damier de la partie, celui-ci contenant le dictionnaire de pièces. - couleur_joueur_courant: le joueur à qui c'est le tour de jouer. - doit_prendre: un booléen représentant si le joueur actif doit absoluement effectuer une prise de pièce. - position_source_forcee: Une position avec laquelle le joueur actif doit absoluement jouer. Le seul moment où cette position est utilisée est après une prise: si le joueur peut encore prendre d'autres pièces adverses, il doit absolument le faire. Ce membre contient None si aucune position n'est forcée. """ self.damier = Damier() self.couleur_joueur_courant = "blanc" self.doit_prendre = False self.position_source_forcee = None def valider_position_source(self, position_source): """ Vérifie la validité de la position source, notamment: - Est-ce que la position contient une pièce? - Est-ce que cette pièce est de la bonne couleur? - Si le joueur doit absolument faire une prise, est-ce que la pièce choisie en la la possibilité? - Si le joueur doit absoluement continuer son mouvement avec une prise supplémentaire, a-t-il choisi la bonne pièce? ATTENTION: Utilisez self.couleur_joueur_courant, self.doit_prendre et self.position_source_forcee pour connaître les informations nécessaires. ATTENTION: Bien que cette méthode valide plusieurs choses, les méthodes programmées dans le damier vous simplifieront la tâche! :param position_source: La position source à valider. :return: Un couple où le premier élément représente la validité de la position (True ou False), et le deuxième élément est un éventuel message d'erreur. """ good_source = False msg = "" if not self.damier.position_valide(position_source): msg = "saisie de la source en dehors du Damier" # vérifie que la saisie est dans les bornes du damier good_source = False #Contient une piece à la source de la bonne couleur? : elif self.damier.get_piece( position_source) == None or self.damier.cases[ position_source].couleur != self.couleur_joueur_courant: msg = "Pas de piece à cette place de votre couleur" good_source = False #Est-il possible de faire un déplacement avec la piece choisie ?: elif self.damier.lister_deplacements_possibles_a_partir_de_position( position_source, False) == None: msg = "Vous devez fournir une position source qui permet de faire un déplacement" #La piece choisi permet-elle de faire une prise qui est obligatoire?: elif self.doit_prendre and self.damier.lister_deplacements_possibles_a_partir_de_position( position_source, True) == None: msg = "Vous devez prendre une piece adverse" else: good_source = True return (good_source, msg) def valider_position_cible(self, position_source, position_cible): """ Vérifie si oui ou non la position cible est valide, en fonction de la position source. ATTENTION: Vous avez déjà programmé la méthode nécessaire dans le damier! :return: Un couple où le premier élément représente la validité de la position (True ou False), et le deuxième élément est un éventuel message d'erreur. """ good_cible = False msg = "" if not self.damier.position_valide(position_cible): msg = "saisie de la cible en dehors du Damier" # vérifie que la saisie est dans les bornes du damier good_cible = False #Vérifie que la cible est une position valide et que le joueur doit prendre une piece: elif self.doit_prendre and position_cible not in self.damier.lister_deplacements_possibles_a_partir_de_position( position_source, True): msg = "Vous devez prendre la piece adverse" good_cible = False #Vérifie que la cible est une position valide : elif position_cible in self.damier.lister_deplacements_possibles_a_partir_de_position( position_source, False): good_cible = True else: msg = "Position cible impossible" return (good_cible, msg) def demander_positions_deplacement(self): """ Demande à l'utilisateur les positions sources et cible, et valide ces positions. ATTENTION: Validez les positions avec les méthodes appropriées! :return: Un couple de deux positions (source et cible). Chaque position est un couple (ligne, colonne). """ saisie = False good_source = ["", ""] """boucle sur la validation de la saisie position source""" while saisie == False: userInputSource = input( "Joueur avec Pions " + self.couleur_joueur_courant + " entrez les positions sources (une coordonnée ligne,colonne entre 0 et 7): " ) """Validation de la saisie de la source """ try: int(userInputSource.split(',')[0]) int(userInputSource.split(',')[1]) except: good_source[1] = "Vous devez suivre le modéle : ligne, colonne" saisie = False else: posSource = (int(userInputSource.split(',')[0]), int(userInputSource.split(',')[1]) ) # Génére le tuple de coordonnées good_source[0] = self.valider_position_source(posSource)[ 0] # Vérifie que la source est valide good_source[1] = self.valider_position_source( posSource )[1] # Récupére les messages suite à la vérification de la source if not good_source[0]: print("Saisie Incorrecte : ", good_source[1]) else: saisie = True saisie = False good_cible = ["", ""] """boucle sur la validation de la saisie position cible""" while saisie == False: userInputCible = input( "Joueur avec Pions " + self.couleur_joueur_courant + " entrez les positions cibles (une coordonnée ligne,colonne entre 0 et 7: )" ) """Validation de la cible""" try: int(userInputCible.split(',')[0]) int(userInputCible.split(',')[1]) except: good_cible[1] = "Vous devez suivre le modéle : ligne, colonne" saisie = False else: posCible = (int(userInputCible.split(',')[0]), int(userInputCible.split(',')[1]) ) # Génére le tuple de coordonnées good_cible[0] = self.valider_position_cible( posSource, posCible)[0] # Vérifie que la cible est valide good_cible[1] = self.valider_position_cible( posSource, posCible )[1] # Récupére les messages suite à la vérification de la cible if not good_cible[0]: print("Saisie Incorrecte : ", good_cible[1]) else: saisie = True return posSource, posCible def tour(self): """ Cette méthode simule le tour d'un joueur, et doit effectuer les actions suivantes: - Assigne self.doit_prendre à True si le joueur courant a la possibilité de prendre une pièce adverse. (utilisez une méthode que vous avez déjà programmée dans le damier!) - Demander les positions source et cible (utilisez self.demander_positions_deplacement!) - Effectuer le déplacement (à l'aide de la méthode du damier appropriée) - Si une pièce a été prise lors du déplacement, c'est encore au tour du même joueur si celui-ci peut encore prendre une pièce adverse en continuant son mouvement. Utilisez les membres self.doit_prendre et self.position_source_forcee pour forcer ce prochain tour! - Si aucune pièce n'a été prise ou qu'aucun coup supplémentaire peut être fait avec la même pièce, c'est le tour du joueur adverse. Mettez à jour les membres de la classe en conséquence. """ #Assigne self.doit_prendre à True si le joueur courant a la possibilité de prendre une pièce adverse : if self.damier.lister_deplacements_possibles_de_couleur( self.couleur_joueur_courant, True) != None: print("Le joueur avec Pion ", self.couleur_joueur_courant, " doit prendre") # Vérifie si le joueur doit prendre self.doit_prendre = True #Demande les positions source et cible pour un déplacement : position = self.demander_positions_deplacement() # Faire le déplacement de la piece : status = self.damier.deplacer(position[0], position[1]) print("Status deplacement ", status) print(self.damier) # Affichage du Damier aprés le déplacement if status == "ok": #Si le déplacement est un succés, changement de joueur if self.couleur_joueur_courant == "blanc": self.couleur_joueur_courant = "noir" else: self.couleur_joueur_courant = "blanc" #si il y a eu une prise, vérification que le mouvement doit continuer avec cette piece : if status == "prise" and self.damier.lister_deplacements_possibles_a_partir_de_position( position[1], True) != None: self.position_source_forcee = position[1] elif status == "prise": #Si déplacement avec prise, changement de joueur: self.doit_prendre = False if self.couleur_joueur_courant == "blanc": self.couleur_joueur_courant = "noir" else: self.couleur_joueur_courant = "blanc" def jouer(self): """ Démarre une partie. Tant que le joueur courant a des déplacements possibles (utilisez la méthode appriopriée!), un nouveau tour est joué. :return: La couleur ("noir", "blanc") du joueur gagnant. """ while self.damier.lister_deplacements_possibles_de_couleur( self.couleur_joueur_courant, False) != None: self.tour() if self.couleur_joueur_courant == "blanc": couleur = "noir" else: couleur = "blanc" return couleur def sauvegarder(self, nom_fichier): """ Sauvegarde une partie dans un fichier. Le fichier condiendra: - Une ligne indiquant la couleur du joueur courant. - Une ligne contenant True ou False, si le joueur courant doit absolument effectuer une prise à son tour. - Une ligne contenant None si self.position_source_forcee est à None, et la position ligne,colonne autrement. - Le reste des lignes correspondent au damier. Voir la méthode convertir_en_chaine du damier pour le format. :param nom_fichier: Le nom du fichier où sauvegarder. :type nom_fichier: string. """ ofich = open(nom_fichier, 'w') # Va créer un nouveau fichier ofich.write("{}\n".format( self.couleur_joueur_courant)) #Écris la couleur du joueur courant ofich.write("{}\n".format(str( self.doit_prendre))) # Écris si le joueur courant doit prendre ofich.write("{}\n".format(str(self.position_source_forcee)) ) # Écris la valeur de position_source_forcee chaine = self.damier.convertir_en_chaine( ) #appel la méthode pour convertir le Damier en chaine ofich.write("{}\n".format(chaine)) # Ecris dans le fichier le damier ofich.close() #Ferme le fichier def charger(self, nom_fichier): """ Charge une partie dans à partir d'un fichier. Le fichier a le même format que la méthode de sauvegarde. :param nom_fichier: Le nom du fichier à charger. :type nom_fichier: string. """ try: ofich = open(nom_fichier, 'r') except: print("fichier inexistant") else: self.damier.cases.clear() # on vide le damier self.couleur_joueur_courant = ofich.readline( ) # Lecture de la premiere ligne du fichier self.doit_prendre = ofich.readline( ) # Lecture de la deuxime ligne du fichier self.position_source_forcee = ofich.readline( ) # Lecture de la troisieme ligne du fichier while 1: # Lecture du reste du fichier jusqu'à sa fin ligne = ofich.readline() if ligne == "": # Si on arrive à la fin du fichier on arrête break self.damier.charger_dune_chaine( ligne) # chargement du Damier ligne par ligne ofich.close() # Fermeture du fichier ouvert
class Partie: def __init__(self): """ Méthode d'initialisation d'une partie. On initialise 4 membres: - damier: contient le damier de la partie, celui-ci contenant le dictionnaire de pièces. - couleur_joueur_courant: le joueur à qui c'est le tour de jouer. - doit_prendre: un booléen représentant si le joueur actif doit absoluement effectuer une prise de pièce. - position_source_forcee: Une position avec laquelle le joueur actif doit absoluement jouer. Le seul moment où cette position est utilisée est après une prise: si le joueur peut encore prendre d'autres pièces adverses, il doit absolument le faire. Ce membre contient None si aucune position n'est forcée. """ self.damier = Damier() self.couleur_joueur_courant = "blanc" self.doit_prendre = False self.position_source_forcee = None def valider_position_source(self, position_source): """ Vérifie la validité de la position source, notamment: - Est-ce que la position contient une pièce? - Est-ce que cette pièce est de la bonne couleur? - Si le joueur doit absolument faire une prise, est-ce que la pièce choisie en la la possibilité? - Si le joueur doit absoluement continuer son mouvement avec une prise supplémentaire, a-t-il choisi la bonne pièce? ATTENTION: Utilisez self.couleur_joueur_courant, self.doit_prendre et self.position_source_forcee pour connaître les informations nécessaires. ATTENTION: Bien que cette méthode valide plusieurs choses, les méthodes programmées dans le damier vous simplifieront la tâche! :param position_source: La position source à valider. :return: Un couple où le premier élément représente la validité de la position (True ou False), et le deuxième élément est un éventuel message d'erreur. """ good_source=False msg="" if not self.damier.position_valide(position_source): msg="saisie de la source en dehors du Damier" # vérifie que la saisie est dans les bornes du damier good_source=False #Contient une piece à la source de la bonne couleur? : elif self.damier.get_piece(position_source)==None or self.damier.cases[position_source].couleur!=self.couleur_joueur_courant: msg="Pas de piece à cette place de votre couleur" good_source=False #Est-il possible de faire un déplacement avec la piece choisie ?: elif self.damier.lister_deplacements_possibles_a_partir_de_position(position_source, False)==None: msg="Vous devez fournir une position source qui permet de faire un déplacement" #La piece choisi permet-elle de faire une prise qui est obligatoire?: elif self.doit_prendre and self.damier.lister_deplacements_possibles_a_partir_de_position(position_source,True)==None: msg="Vous devez prendre une piece adverse" else: good_source=True return (good_source, msg) def valider_position_cible(self, position_source, position_cible): """ Vérifie si oui ou non la position cible est valide, en fonction de la position source. ATTENTION: Vous avez déjà programmé la méthode nécessaire dans le damier! :return: Un couple où le premier élément représente la validité de la position (True ou False), et le deuxième élément est un éventuel message d'erreur. """ good_cible=False msg="" if not self.damier.position_valide(position_cible): msg="saisie de la cible en dehors du Damier" # vérifie que la saisie est dans les bornes du damier good_cible=False #Vérifie que la cible est une position valide et que le joueur doit prendre une piece: elif self.doit_prendre and position_cible not in self.damier.lister_deplacements_possibles_a_partir_de_position(position_source,True): msg="Vous devez prendre la piece adverse" good_cible=False #Vérifie que la cible est une position valide : elif position_cible in self.damier.lister_deplacements_possibles_a_partir_de_position(position_source,False): good_cible=True else: msg="Position cible impossible" return (good_cible, msg) def demander_positions_deplacement(self): """ Demande à l'utilisateur les positions sources et cible, et valide ces positions. ATTENTION: Validez les positions avec les méthodes appropriées! :return: Un couple de deux positions (source et cible). Chaque position est un couple (ligne, colonne). """ saisie=False good_source=["",""] """boucle sur la validation de la saisie position source""" while saisie==False: userInputSource=input("Joueur avec Pions " + self.couleur_joueur_courant + " entrez les positions sources (une coordonnée ligne,colonne entre 0 et 7): ") """Validation de la saisie de la source """ try: int(userInputSource.split(',')[0]) int(userInputSource.split(',')[1]) except: good_source[1]="Vous devez suivre le modéle : ligne, colonne" saisie=False else: posSource=(int(userInputSource.split(',')[0]),int(userInputSource.split(',')[1])) # Génére le tuple de coordonnées good_source[0]=self.valider_position_source(posSource)[0] # Vérifie que la source est valide good_source[1]=self.valider_position_source(posSource)[1] # Récupére les messages suite à la vérification de la source if not good_source[0]: print("Saisie Incorrecte : ",good_source[1]) else: saisie=True saisie=False good_cible=["",""] """boucle sur la validation de la saisie position cible""" while saisie==False: userInputCible=input("Joueur avec Pions " + self.couleur_joueur_courant + " entrez les positions cibles (une coordonnée ligne,colonne entre 0 et 7: )") """Validation de la cible""" try: int(userInputCible.split(',')[0]) int(userInputCible.split(',')[1]) except: good_cible[1]="Vous devez suivre le modéle : ligne, colonne" saisie=False else: posCible=(int(userInputCible.split(',')[0]),int(userInputCible.split(',')[1])) # Génére le tuple de coordonnées good_cible[0]=self.valider_position_cible(posSource,posCible)[0] # Vérifie que la cible est valide good_cible[1]=self.valider_position_cible(posSource,posCible)[1]# Récupére les messages suite à la vérification de la cible if not good_cible[0]: print("Saisie Incorrecte : ",good_cible[1]) else: saisie=True return posSource, posCible def tour(self): """ Cette méthode simule le tour d'un joueur, et doit effectuer les actions suivantes: - Assigne self.doit_prendre à True si le joueur courant a la possibilité de prendre une pièce adverse. (utilisez une méthode que vous avez déjà programmée dans le damier!) - Demander les positions source et cible (utilisez self.demander_positions_deplacement!) - Effectuer le déplacement (à l'aide de la méthode du damier appropriée) - Si une pièce a été prise lors du déplacement, c'est encore au tour du même joueur si celui-ci peut encore prendre une pièce adverse en continuant son mouvement. Utilisez les membres self.doit_prendre et self.position_source_forcee pour forcer ce prochain tour! - Si aucune pièce n'a été prise ou qu'aucun coup supplémentaire peut être fait avec la même pièce, c'est le tour du joueur adverse. Mettez à jour les membres de la classe en conséquence. """ #Assigne self.doit_prendre à True si le joueur courant a la possibilité de prendre une pièce adverse : if self.damier.lister_deplacements_possibles_de_couleur(self.couleur_joueur_courant, True)!=None: print("Le joueur avec Pion ",self.couleur_joueur_courant," doit prendre") # Vérifie si le joueur doit prendre self.doit_prendre=True #Demande les positions source et cible pour un déplacement : position=self.demander_positions_deplacement() # Faire le déplacement de la piece : status=self.damier.deplacer(position[0], position[1]) print("Status deplacement ",status) print(self.damier) # Affichage du Damier aprés le déplacement if status=="ok": #Si le déplacement est un succés, changement de joueur if self.couleur_joueur_courant=="blanc": self.couleur_joueur_courant="noir" else: self.couleur_joueur_courant="blanc" #si il y a eu une prise, vérification que le mouvement doit continuer avec cette piece : if status=="prise" and self.damier.lister_deplacements_possibles_a_partir_de_position(position[1],True)!=None: self.position_source_forcee=position[1] elif status=="prise": #Si déplacement avec prise, changement de joueur: self.doit_prendre=False if self.couleur_joueur_courant=="blanc": self.couleur_joueur_courant="noir" else: self.couleur_joueur_courant="blanc" def jouer(self): """ Démarre une partie. Tant que le joueur courant a des déplacements possibles (utilisez la méthode appriopriée!), un nouveau tour est joué. :return: La couleur ("noir", "blanc") du joueur gagnant. """ while self.damier.lister_deplacements_possibles_de_couleur(self.couleur_joueur_courant, False)!=None: self.tour() if self.couleur_joueur_courant=="blanc": couleur="noir" else: couleur="blanc" return couleur def sauvegarder(self, nom_fichier): """ Sauvegarde une partie dans un fichier. Le fichier condiendra: - Une ligne indiquant la couleur du joueur courant. - Une ligne contenant True ou False, si le joueur courant doit absolument effectuer une prise à son tour. - Une ligne contenant None si self.position_source_forcee est à None, et la position ligne,colonne autrement. - Le reste des lignes correspondent au damier. Voir la méthode convertir_en_chaine du damier pour le format. :param nom_fichier: Le nom du fichier où sauvegarder. :type nom_fichier: string. """ ofich=open(nom_fichier, 'w') # Va créer un nouveau fichier ofich.write("{}\n".format(self.couleur_joueur_courant)) #Écris la couleur du joueur courant ofich.write("{}\n".format(str(self.doit_prendre))) # Écris si le joueur courant doit prendre ofich.write("{}\n".format(str(self.position_source_forcee))) # Écris la valeur de position_source_forcee chaine=self.damier.convertir_en_chaine() #appel la méthode pour convertir le Damier en chaine ofich.write("{}\n".format(chaine))# Ecris dans le fichier le damier ofich.close() #Ferme le fichier def charger(self, nom_fichier): """ Charge une partie dans à partir d'un fichier. Le fichier a le même format que la méthode de sauvegarde. :param nom_fichier: Le nom du fichier à charger. :type nom_fichier: string. """ try: ofich=open(nom_fichier, 'r') except: print("fichier inexistant") else: self.damier.cases.clear() # on vide le damier self.couleur_joueur_courant=ofich.readline()# Lecture de la premiere ligne du fichier self.doit_prendre=ofich.readline()# Lecture de la deuxime ligne du fichier self.position_source_forcee=ofich.readline()# Lecture de la troisieme ligne du fichier while 1: # Lecture du reste du fichier jusqu'à sa fin ligne=ofich.readline() if ligne=="": # Si on arrive à la fin du fichier on arrête break self.damier.charger_dune_chaine(ligne) # chargement du Damier ligne par ligne ofich.close() # Fermeture du fichier ouvert
def run(self, n=-1, p=-1, x="", flag=1, g=-1, w=-1, y=-1): # Initialize pygame pygame.init() WINDOW_SIZE = [Damier.longueur(n), Damier.largeur(p)] screen = pygame.display.set_mode(WINDOW_SIZE) pygame.display.set_caption(Damier.nom(x)) # Loop until the user clicks the close button. done = False clock = pygame.time.Clock() # -------- Main Program Loop ----------- while not done: for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user clicked close done = True # Flag that we are done so we exit this loop elif event.type == pygame.MOUSEBUTTONDOWN: # User clicks the mouse. Get the position pos = pygame.mouse.get_pos() # Change the x/y screen coordinates to grid coordinates column = pos[0] // (self.width + self.margin) row = pos[1] // (self.height + self.margin) # Set that location to one self.grid[row][column] = 1 print("Click ", pos, "Grid coordinates: ", row, column) self.tableau.append(row) self.tableau1.append(column) # Set the screen background screen.fill(BLACK) # Draw the grid for row in range(20): for column in range(40): color = WHITE if self.grid[row][column] == 1: color = GREEN if self.grid[row][column] == 2: color = RED if self.grid[row][column] == 3: color = BLACK if self.grid[row][column] == 0: color = WHITE pygame.draw.rect( screen, color, [(self.margin + self.width) * column + self.margin, (self.margin + self.height) * row + self.margin, self.width, self.height]) Simulation.cellulemorte(self) Simulation.cellulenaissante(self) Simulation.cellrestante(self) time.sleep(1) # Limit to 60 frames per second clock.tick(1) test = 0 # Go ahead and update the screen with what we've drawn. pygame.display.flip() # Be IDLE friendly. If you forget this line, the program will 'hang' # on exit. pygame.quit()