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 __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 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()