def test_Base(self):
nbCase = 10
jeu = Grille(
nbCase
) # j'ai mis 30 secondes à comprendre comment votre code pouvait s'éxecuter alors que la classe "Jeu" ne comporte pas de méthode "get_Grille" : attention aux noms !
self.assertEqual(False, jeu.get_Grille(1, 1))
self.assertEqual("Error Out Of Bound", jeu.get_Grille(1, nbCase + 1))
def __init__(self, N, nbPions):
"""
params :
N (int) : dimension de la grille
nbPions (int) : nombre de pions
"""
self.__dim = N
self.__nbPions = nbPions
# Initialisation de la grille
self.__Grille = Grille(N, nbPions)
# Initialisation de l'Historique (FIFO)
self.__Historique = []
# Console ou UI ?
self.__isConsoleActive = self.activateConsole()
print("INFO : Vous avez choisi de jouer %s" %
("dans l'UI", "dans la console")[self.__isConsoleActive])
# Premier joueur
self.__colorInit = random.randint(BLANC, NOIR)
# Tableau des fonctions placer pion. On y accède avec self.__ModeJeu
self.__TAB_PLACER_PION = [
self.placer_pion_machine, self.placer_pion_humain,
self.placer_pion, self.placer_pion, self.placer_pion,
self.placer_pion, self.placer_pion_2machines
]
# Tableau des constructeurs de tour. On y accède avec self.__ModeJeu
self.__TAB_TOUR = [
TourRandom, None, TourRandom, TourBestFirst, TourMinMax,
TourAlphaBeta, (TourRandom, TourMinMax)
]
self.__ModeJeu = 2 # par défaut ordirandom/humain
self.__forceStop = False
if not self.__isConsoleActive:
# Initialisation de la fenêtre d'affichage
self.__root = tk.Tk()
# tk.CallWrapper = TkErrorCatcher
self.__Application = Application.Application(self,
master=self.__root)
# Selectionnons le mode de Jeu
self.selectionnerModeJeu()
# Lançons le tout
self.jouer()
self.__Application.mainloop()
else:
# Selectionnons le mode de Jeu
self.selectionnerModeJeu()
# Lançons le tout
self.jouer()
def click_menu(x,y):
global oscMenu
if -130<x<20 and 200<y<250 and oscMenu == 1:
oscMenu = 0
tt_m.clear()
Grille.grille()
if oscMenu == 0:
onscreenclick(Test_click.position)
if -130<x<20 and -100<y<-50 and oscMenu == 1:
oscMenu = 0
tt_m.clear()
page_succes()
class Controleur:
_grille_ = None
def __init__(self):
self._grille_ = Grille()
self.tour = 1
def obtenir_case(self, ligne, colonne):
"""
ligne: indice de la ligne de la case
colonne: indice de la colonne de la case
retourne le code contenu dans la case (0: case vide, 1: rond, 2: croix)
retourne -1 si les coordonnées de la case sont hors du tableau
"""
return self._grille_.obtenir_case(ligne, colonne)
def marquer_case(self, ligne, colonne):
"""
ligne: indice de la ligne de la case
colonne: indice de la colonne de la case
retourne True si la case a été marquée
retourne False si la case n'est pas disponible
"""
return self._grille_.marquer_case(ligne, colonne, self.tour)
def changer_tour(self):
"""
Donne la main au deuxième joueur
"""
if self.tour == 1:
self.tour = 2
elif self.tour == 2:
self.tour = 1
def gagnant(self):
"""
retourne le gagnant et les coordonnées des cases gagnantes
retourne 0, [] s'il n'y a pas de gagnant
retourne 1, [...] si le joueur 1 a gagné
retourne 2, [...] si le joueur 2 a gagné
"""
return self._grille_.gagnant()
def est_rempli(self):
"""
retourne True si la grille est remplie
sinon, retourne False
"""
return self._grille_.est_rempli()
def debut(self):
mode = int(
input(
"Entrez votre mode de jeu, Tapez 1 pour Humain Vs Humain, 2 pour Humain VS Ordi et 3 pour Ordi Vs Ordi : "
))
if mode <= 2:
self.mode = mode
hauteur = int(input("Entrez hauteur : "))
while hauteur < 4 or type(hauteur) != int:
hauteur = int(
input(
"Mauvaise valeure, choisir une hauteur supérieure à 4 : "
))
largeur = int(input("Entrez largeur : "))
while largeur < 4 or type(largeur) != int:
largeur = int(
input(
"Mauvaise valeure, choisir une largeur supérieure à 4 : "
))
else:
self.mode = mode
largeur = hauteur = 6
self.grille = grl.Grille(hauteur, largeur)
self.partie()
def plateauxSuccesseursDeja_nbPions(self, grille, Color):
""" Génère tous les plateaux possibles où on enlève un pion playingColor et on le place dans une case vide (autre que celle qu’on vient de vider) """
# On récupère le vecteur correspondant à la couleur
VC = grille.getVector(Color)
VV = grille.getVector(VIDE)
liste = []
N, nbPions = grille.getDim(), grille.getNbPions()
for case in VC :
newGrille = Grille(N, nbPions) # on __init__ une nouvelle grille
newGrille.resetGrille(grille) # on y copie la grille actuelle
newGrille.echangerCase(case, Color, placer="LIBERER") # on enlève ce pion
for caseVide in VV :
if caseVide != case:
def plateauxSuccesseursMoinsDe_NbPions(self, grille, Color):
""" Génère tous les successeur du plateau où on n’a pas encore joué nbPions pions """
# On récupère le vecteur correspondant à la couleur
VC = grille.getVector(Color)
VV = grille.getVector(VIDE)
liste = []
N, nbPions = grille.getDim(), grille.getNbPions()
for case in VV :
newGrille = Grille(N, nbPions) # on __init__ une nouvelle grille
newGrille.resetGrille(grille) # on y copie la grille actuelle
newGrille.echangerCase(case, Color, placer="PLACER") # on effectue le mvt
liste.append(newGrille) # on l'ajoute à la liste des mvts possibles
return liste
def click_menu(x,y):
global oscMenu
if -130<x<20 and 200<y<250 and oscMenu == 1: #click sur jouer
oscMenu = 0
tt_m.clear()
Grille.grille()
Timer.temps()
if oscMenu == 0:
onscreenclick(Test_click.position,1) #click gauche pour réveler
onscreenclick(Revelation_case.place_drapeau,3) #click droit pour poser un drapeau
if -130<x<20 and -100<y<-50 and oscMenu == 1:
oscMenu = 0
tt_m.clear()
page_succes()
def initNewGame(self):
""" Reset everything to play another game """
print("INFO : NEW GAME STARTING")
self.__forceStop = True # pour arrêter la boucle de jeu
# Nouvelle Grille
del self.__Grille
self.__Grille = Grille(self.__dim, self.__nbPions)
# Nouvel historique
del self.__Historique
self.__Historique = []
# Nouveau premier joueur
del self.__colorInit
self.__colorInit = random.randint(BLANC, NOIR)
print("INFO : RESET COMPLETED")
def test_Ajout_Bateau(self):
nbCase = 10
jeu = Grille(nbCase) # /repeat "attention aux noms" !
bateau = Bateau(1, 2)
jeu.ajout_Bateau(1, 1, bateau)
self.assertEqual(True, jeu.get_Grille(1, 1))
self.assertEqual(False, jeu.get_Grille(3, 2))
def __init__(self, nom, bateaux, id, tailleGrille):
self._score = 0
self._nom = nom
self._id = id # "id" -> mot-clef à éviter, il est semi-réserver par Python (et par pas mal d'autres langages, donc à éviter en général (_id est tout à fait acceptable par contre))
self._bateaux = bateaux
self._grille = Grille(tailleGrille)
def __init__(self):
self.taille = None
self.joueurs = {
} #Stocke la configuration (IA ou joueur) de chacun des joueurs
self.menu()
self.coups = 0
#matrice de sommets utilisée dans les graphes et taille n*n
self.matriceSommets = []
for i in range(self.taille):
self.matriceSommets.append([])
#on ajoute nos sommets
for i in range(self.taille):
for j in range(self.taille):
self.matriceSommets[i].append(Sommet(i, j))
#ici on ajoute pour tous les sommets qui touchent un bord dans un graphe avec son bord
Graphe(LIBRE, B_HAUT_BLEU | B_GAUCHE_ROUGE).ajoutSommet(
self.matriceSommets[0][0])
Graphe(LIBRE, B_HAUT_BLEU | B_DROIT_ROUGE).ajoutSommet(
self.matriceSommets[0][self.taille - 1])
Graphe(LIBRE, B_BAS_BLEU | B_GAUCHE_ROUGE).ajoutSommet(
self.matriceSommets[self.taille - 1][0])
Graphe(LIBRE, B_BAS_BLEU | B_DROIT_ROUGE).ajoutSommet(
self.matriceSommets[self.taille - 1][self.taille - 1])
for i in range(self.taille):
if i == 0:
for j in range(1, self.taille - 1):
Graphe(LIBRE,
B_HAUT_BLEU).ajoutSommet(self.matriceSommets[i][j])
elif i == self.taille - 1:
for j in range(1, self.taille - 1):
Graphe(LIBRE,
B_BAS_BLEU).ajoutSommet(self.matriceSommets[i][j])
else:
Graphe(LIBRE,
B_GAUCHE_ROUGE).ajoutSommet(self.matriceSommets[i][0])
Graphe(LIBRE, B_DROIT_ROUGE).ajoutSommet(
self.matriceSommets[i][self.taille - 1])
#on va ajouter tous les voisins de tous les sommets
for x in range(self.taille):
for y in range(self.taille):
if x != 0:
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x - 1][y])
if y != 0:
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x][y - 1])
if x != self.taille - 1:
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x + 1][y - 1])
if x != self.taille - 1:
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x + 1][y])
if y != self.taille - 1:
if x != 0:
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x - 1][y + 1])
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x][y + 1])
self.grille = Grille(Point(10, 30), self.taille, 40,
self.matriceSommets)
self.tourActuel = ROUGE
self.plateaux = {}
if (self.taille <= 4):
self.genererPlateaux()
self.canvas = 0
self.fenetre = 0
self.commencer()
class Jeu:
def __init__(self):
self.taille = None
self.joueurs = {
} #Stocke la configuration (IA ou joueur) de chacun des joueurs
self.menu()
self.coups = 0
#matrice de sommets utilisée dans les graphes et taille n*n
self.matriceSommets = []
for i in range(self.taille):
self.matriceSommets.append([])
#on ajoute nos sommets
for i in range(self.taille):
for j in range(self.taille):
self.matriceSommets[i].append(Sommet(i, j))
#ici on ajoute pour tous les sommets qui touchent un bord dans un graphe avec son bord
Graphe(LIBRE, B_HAUT_BLEU | B_GAUCHE_ROUGE).ajoutSommet(
self.matriceSommets[0][0])
Graphe(LIBRE, B_HAUT_BLEU | B_DROIT_ROUGE).ajoutSommet(
self.matriceSommets[0][self.taille - 1])
Graphe(LIBRE, B_BAS_BLEU | B_GAUCHE_ROUGE).ajoutSommet(
self.matriceSommets[self.taille - 1][0])
Graphe(LIBRE, B_BAS_BLEU | B_DROIT_ROUGE).ajoutSommet(
self.matriceSommets[self.taille - 1][self.taille - 1])
for i in range(self.taille):
if i == 0:
for j in range(1, self.taille - 1):
Graphe(LIBRE,
B_HAUT_BLEU).ajoutSommet(self.matriceSommets[i][j])
elif i == self.taille - 1:
for j in range(1, self.taille - 1):
Graphe(LIBRE,
B_BAS_BLEU).ajoutSommet(self.matriceSommets[i][j])
else:
Graphe(LIBRE,
B_GAUCHE_ROUGE).ajoutSommet(self.matriceSommets[i][0])
Graphe(LIBRE, B_DROIT_ROUGE).ajoutSommet(
self.matriceSommets[i][self.taille - 1])
#on va ajouter tous les voisins de tous les sommets
for x in range(self.taille):
for y in range(self.taille):
if x != 0:
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x - 1][y])
if y != 0:
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x][y - 1])
if x != self.taille - 1:
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x + 1][y - 1])
if x != self.taille - 1:
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x + 1][y])
if y != self.taille - 1:
if x != 0:
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x - 1][y + 1])
self.matriceSommets[x][y].ajoutVoisin(
self.matriceSommets[x][y + 1])
self.grille = Grille(Point(10, 30), self.taille, 40,
self.matriceSommets)
self.tourActuel = ROUGE
self.plateaux = {}
if (self.taille <= 4):
self.genererPlateaux()
self.canvas = 0
self.fenetre = 0
self.commencer()
# afficher le menu de configuration de la partie
def menu(self):
fenetreMenu = Tk(className='configuration')
fenetreMenu.resizable(width=False, height=False)
fenetreMenu.geometry('320x200+700+300')
FrameTaille = Frame(fenetreMenu, pady=10, padx=10)
texteTaille = Label(FrameTaille, text="Taille : ", font="Arial 15")
texteTaille.pack(side='left')
taille = Spinbox(FrameTaille,
from_=2,
to=11,
font="Arial 15",
width=15)
taille.pack(side='right')
FrameTaille.pack()
FrameJoueur = Frame(fenetreMenu, pady=10)
Frame1 = Frame(FrameJoueur)
choix1 = [("Joueur", "Joueur"), ("IA", "IA")]
texteJoueur1 = Label(Frame1,
text="Joueur 1 : ",
fg=COULEUR_ROUGE,
font="Arial 15")
texteJoueur1.pack(side='left')
choix1 = [("Joueur", 0), ("IA", 1)]
var1 = StringVar()
for text, val in choix1:
rb = Radiobutton(Frame1,
text=text,
variable=var1,
value=val,
font="Arial 15")
rb.pack(side='right')
Frame1.pack()
Frame2 = Frame(FrameJoueur, pady=10)
texteJoueur2 = Label(Frame2,
text="Joueur 2 : ",
fg=COULEUR_BLEU,
font="Arial 15")
texteJoueur2.pack(side='left')
choix2 = [("Joueur", 0), ("IA", 1)]
var2 = StringVar()
for text, val in choix2:
rb2 = Radiobutton(Frame2,
text=text,
variable=var2,
value=val,
font="Arial 15")
rb2.pack(side='right')
Frame2.pack()
FrameJoueur.pack()
b = Button(fenetreMenu,
text="Jouer",
command=lambda: self.verifier(fenetreMenu, taille.get(),
var1.get(), var2.get()))
b.pack()
fenetreMenu.mainloop()
# verifier que les parametres saisis via le menu sont corrects
def verifier(self, fenetre, taille, J1, J2):
# verifier que la taille saisie est un entier
if (taille.isdigit()):
if (not (int(taille) >= 2 and int(taille) <= 11)):
showerror(
'Taille de grille incorrecte',
'Veuillez selectionner une taille de grille comprise entre 2 et 11.'
)
return False
else:
showerror(
'Taille de grille incorrecte',
'Veuillez selectionner une taille de grille comprise entre 2 et 11.'
)
return False
if (J1 != '0' and J1 != '1'):
showerror('Joueur 1 non selectionné',
'Veuillez selectionner entre IA et Joueur.')
return False
if (J2 != '0' and J2 != '1'):
showerror('Joueur 2 non selectionné',
'Veuillez selectionner entre IA et Joueur.')
return False
self.taille = int(taille)
self.joueurs[ROUGE] = int(J1)
self.joueurs[BLEU] = int(J2)
fenetre.destroy()
# commencer une partie
def commencer(self):
global canvasTour
global oval
self.fenetre = Tk(className="Jeu de Hex")
self.fenetre.resizable(width=False, height=False)
FrameGrille = Frame(self.fenetre, relief=GROOVE)
self.canvas = Canvas(FrameGrille,
width=self.grille.taille * 100,
height=self.grille.taille * 67 + 30,
background='#ddd')
self.grille.tracer(self.canvas)
self.canvas.bind("<Button-1>", self.jouer)
self.canvas.pack()
self.fenetre.after(1000, self.jouerIA)
FrameOptions = Frame(self.fenetre, relief=GROOVE)
nouvPartieButton = Button(FrameOptions,
text="Nouv. partie",
command=lambda: self.nouvPartie())
nouvPartieButton.grid(row=0, column=0, padx=10, pady=10)
quitterButton = Button(FrameOptions,
text="Quitter",
fg='red',
command=self.fenetre.destroy)
quitterButton.grid(row=0, column=2, padx=10, pady=10)
canvasTour = Canvas(FrameOptions, width=40, height=40)
oval = canvasTour.create_oval(10,
10,
30,
30,
width=2,
fill=COULEUR_ROUGE,
outline='')
canvasTour.grid(row=0, column=1, pady=10)
FrameGrille.pack(side=TOP)
FrameOptions.pack(side=BOTTOM)
self.fenetre.mainloop()
#Créer une nouvelle partie (réglages différents)
def nouvPartie(self):
self.fenetre.destroy()
Graphe.gagnant = ""
#os.remove("./save/save.txt")
Jeu()
def estGagnant(self):
if (Graphe.gagnant == "ROUGE"):
canvasTour.delete(oval)
showinfo('Victoire', 'Le joueur rouge a gagné.')
self.canvas.unbind("<Button-1>")
Graphe.gagnant = ""
self.tourActuel = -1
return ROUGE
elif (Graphe.gagnant == "BLEU"):
canvasTour.delete(oval)
showinfo('Victoire', 'Le joueur bleu a gagné.')
self.canvas.unbind("<Button-1>")
Graphe.gagnant = ""
self.tourActuel = -1
return BLEU
return False
# Recuperer le fichier et, s'il n'existe pas, le creer
def genFile(self):
path = "./save"
filename = "save.txt"
if not os.path.exists(path):
os.makedirs(path)
fd = open(os.path.join(path, filename), "w")
return fd
def ecrireFichier(self, fd, presets):
fd.write(json.dumps(presets))
def tourSuivant(self):
global canvasTour
global oval
canvasTour.delete(oval)
if (self.tourActuel == ROUGE):
self.tourActuel = BLEU
oval = canvasTour.create_oval(10,
10,
30,
30,
width=2,
fill=COULEUR_BLEU,
outline='')
else:
self.tourActuel = ROUGE
oval = canvasTour.create_oval(10,
10,
30,
30,
width=2,
fill=COULEUR_ROUGE,
outline='')
def genererPlateaux(self):
if (not (os.path.isfile("./plateaux/" + str(self.taille) + "/" +
self.code() + ".txt"))):
voisin(self.taille)
self.plateaux = Plateau(self.codeBase10(), self.tourActuel).json()
ecrireFichier(genFile(self.taille, self.code()), self.plateaux)
with open("./plateaux/" + str(self.taille) + "/" + self.code() +
".txt") as json_file:
self.plateaux = json.load(json_file)
# retourner le code correspondant au plateau actuel
def code(self):
code = 0
for x in range(len(self.matriceSommets)):
for y in range(len(self.matriceSommets[x])):
code = code + self.matriceSommets[x][y].couleur * pow(
3, x * self.taille + y)
return str(int(code))
def codeBase10(self):
code = list()
for x in range(len(self.matriceSommets)):
for y in range(len(self.matriceSommets[x])):
code.append(self.matriceSommets[x][y].couleur)
code = ''.join(map(str, code))
return code
def jouer(self, event):
global canvasTour
global oval
if (self.joueurs[self.tourActuel] == 0):
p = Point(event.x, event.y)
hexagone = self.grille.trouver(p)
if ((hexagone is not None) and (hexagone.choixHex == False)):
hexagone.sommet.jouer(self.tourActuel)
self.grille.placer(self.tourActuel, hexagone, self.canvas)
hexagone.choixHex = True
self.coups = self.coups + 1
self.tourSuivant()
gagnant = self.estGagnant()
if (not gagnant):
if (self.joueurs[self.tourActuel] == 1
): #Si le prochain tour est un IA, le lancer
self.fenetre.after(1000, self.jouerIA)
def jouerIA(self):
global canvasTour
global oval
if (self.joueurs[self.tourActuel] == 1):
if (self.taille <= 4 or self.coups >=
(self.taille * self.taille - 12)):
if ((not (self.code() in self.plateaux))
or (self.plateaux[self.code()] is None)):
self.genererPlateaux()
s = self.plateaux[self.code()]
if (s is None):
return False
else:
s = int(s)
hexagone = self.grille.matriceHexagones[s // self.taille][
s % self.taille]
else:
s = randint(0, (self.taille * self.taille) - 1)
hexagone = self.grille.matriceHexagones[s // self.taille][
s % self.taille]
while (hexagone.choixHex == True):
s = randint(0, (self.taille * self.taille) - 1)
hexagone = self.grille.matriceHexagones[s // self.taille][
s % self.taille]
hexagone.sommet.jouer(self.tourActuel)
self.grille.placer(self.tourActuel, hexagone, self.canvas)
hexagone.choixHex = True
self.coups = self.coups + 1
self.tourSuivant()
gagnant = self.estGagnant()
if (not gagnant):
if (self.joueurs[self.tourActuel] == 1
): #Si le prochain tour est un IA, le lancer
self.fenetre.after(1000, self.jouerIA)
"""
bateaux = []
for i in range(nombre):
bateaux.append(
classe()) # classe() appelle le constructeur de la classe
return bateaux
def creer_bateaux():
"""
Crée une liste contenant le nombre désiré de chaque type de bateau.
:return: pas de retour
"""
bateaux = []
bateaux.extend(creer_bateau(bateau.Torpilleur, NOMBRE_TORPILLEURS))
bateaux.extend(creer_bateau(bateau.SousMarin, NOMBRE_SOUS_MARINS))
bateaux.extend(
creer_bateau(bateau.ContreTorpilleur, NOMBRE_CONTRE_TORPILLEURS))
bateaux.extend(creer_bateau(bateau.Croiseur, NOMBRE_CROISEURS))
bateaux.extend(creer_bateau(bateau.PorteAvions, NOMBRE_PORTES_AVIONS))
return bateaux
if __name__ == "__main__":
bateaux = creer_bateaux()
grille = Grille(bateaux)
interface = Afficheur(grille)
interface.afficher_menu()
interface.boucle_des_evenements()
class JeuMorpion:
# =============================================================================
# __init__
# =============================================================================
def __init__(self, N, nbPions):
"""
params :
N (int) : dimension de la grille
nbPions (int) : nombre de pions
"""
self.__dim = N
self.__nbPions = nbPions
# Initialisation de la grille
self.__Grille = Grille(N, nbPions)
# Initialisation de l'Historique (FIFO)
self.__Historique = []
# Console ou UI ?
self.__isConsoleActive = self.activateConsole()
print("INFO : Vous avez choisi de jouer %s" %
("dans l'UI", "dans la console")[self.__isConsoleActive])
# Premier joueur
self.__colorInit = random.randint(BLANC, NOIR)
# Tableau des fonctions placer pion. On y accède avec self.__ModeJeu
self.__TAB_PLACER_PION = [
self.placer_pion_machine, self.placer_pion_humain,
self.placer_pion, self.placer_pion, self.placer_pion,
self.placer_pion, self.placer_pion_2machines
]
# Tableau des constructeurs de tour. On y accède avec self.__ModeJeu
self.__TAB_TOUR = [
TourRandom, None, TourRandom, TourBestFirst, TourMinMax,
TourAlphaBeta, (TourRandom, TourMinMax)
]
self.__ModeJeu = 2 # par défaut ordirandom/humain
self.__forceStop = False
if not self.__isConsoleActive:
# Initialisation de la fenêtre d'affichage
self.__root = tk.Tk()
# tk.CallWrapper = TkErrorCatcher
self.__Application = Application.Application(self,
master=self.__root)
# Selectionnons le mode de Jeu
self.selectionnerModeJeu()
# Lançons le tout
self.jouer()
self.__Application.mainloop()
else:
# Selectionnons le mode de Jeu
self.selectionnerModeJeu()
# Lançons le tout
self.jouer()
# =============================================================================
# Fonctions utiles à l'UI
# =============================================================================
def activateConsole(self):
while True:
try:
ans = input("Q : Voulez-vous jouer dans la console (Y, n) ? ")
if ans in TAB_YES: return True
elif ans in TAB_NO: return False
else: raise ValueError
except ValueError as e:
self.handleError(e)
continue
break
def updateButtonText(self, Color):
""" Mise à jour des textes des boutons """
# On récupère le vecteur correspondant à la couleur
VC = self.__Grille.getVector(Color)
VV = self.__Grille.getVector(VIDE)
def fromTuple2Number(i, j):
return i * self.__dim + j
# Effacer
if len(VC) >= 3:
self.__Application.getButtonList()[fromTuple2Number(
VV[-1][0], VV[-1][1])]["text"] = ''
# puisque l'on .append(), la case en question est la dernière ajoutée, d'où -1
# Imprimer
# print("DEBUG: imprimer dans le bouton {}, n°{}".format(VC[-1], fromTuple2Number(VC[-1][0], VC[-1][1])))
self.__Application.getButtonList()[fromTuple2Number(
VC[-1][0], VC[-1][1])]["text"] = UI[Color] # idem
# =============================================================================
# Fonctions utiles au jeu
# =============================================================================
def ajoutHistorique(self):
""" Sauvegarde les grilles dans un historique (fifo) de taille fixe """
tailleMax = 5
# Si l'historique dépasse la taille autorisée
if len(self.__Historique) > tailleMax:
self.__Historique.pop(
0) # on retire le premier élt (grille la plus ancienne)
self.__Historique.append(self.__Grille)
else:
self.__Historique.append(self.__Grille)
def checkRepetition(self):
""" Vérifie que la grille n'est pas une répétition """
if len(self.__Historique
) > FIN_REPETITION and self.__Grille == self.__Historique[
-FIN_REPETITION]:
raise FinDuJeuParRepetitionError()
return
def initNewGame(self):
""" Reset everything to play another game """
print("INFO : NEW GAME STARTING")
self.__forceStop = True # pour arrêter la boucle de jeu
# Nouvelle Grille
del self.__Grille
self.__Grille = Grille(self.__dim, self.__nbPions)
# Nouvel historique
del self.__Historique
self.__Historique = []
# Nouveau premier joueur
del self.__colorInit
self.__colorInit = random.randint(BLANC, NOIR)
print("INFO : RESET COMPLETED")
def forceStop(self):
""" Stop le jeu brutalement """
print("INFO : FORCED STOP")
self.__forceStop = True
def lireCaseConsole(self, Color=HUMAIN, placer="PLACER"):
""" Lecture d'une case (x, y) dans la console """
# On récupère le vecteur correspondant à la couleur
VC = self.__Grille.getVector(Color)
VV = self.__Grille.getVector(VIDE)
while True:
try:
print("*" * 3 + placer + "*" * 3, end='')
X, Y = input("X, Y ? ").split()
X, Y = int(X), int(Y)
if X >= self.__dim or Y >= self.__dim:
raise IndexError # vérifions que les coordonées sont dans les bornes
elif placer == "PLACER" and (X, Y) not in VV:
raise IllegalMoveError(
"in - JeuMorpion.lireCaseConsole"
) # Vérifions que la case à placer est bien disponible
elif placer == "LIBERER" and (X, Y) not in VC:
raise IllegalMoveError(
"in - JeuMorpion.lireCaseConsole"
) # Vérifions que la case à libérer est bien libérable
except (ValueError, IndexError, IllegalMoveError) as e:
self.handleError(e)
continue
break
return (X, Y)
def lireCaseUI(self, Color=HUMAIN, placer="PLACER"):
""" Lecture d'une case (x, y) dans la console """
# On récupère le vecteur correspondant à la couleur
VC = self.__Grille.getVector(Color)
VV = self.__Grille.getVector(VIDE)
while True:
try:
print("*" * 3 + placer + "*" * 3, end='\t')
print("Waiting for human player ...", end='\t\n')
self.__Application.wait_variable(
self.__Application.getCaseJoueeVariable())
def stringToTuple(s): # s est de la forme d'un tuple
try:
sTuple = s[1:-1].split(
', ') # [1:-1] pour enlever les parenthèses
except (AttributeError, IndexError):
print("ERROR : Oops! An internal error occurred...")
print(
"\tDEBUG : error while trying to convert string to tuple"
)
return sTuple
(X, Y) = stringToTuple(
self.__Application.getCaseJoueeVariable().get())
# DEBUG: print("X=%s, Y=%s"%(X,Y))
# Transformons en tuple d'int
(X, Y) = (int(X), int(Y))
if placer == "PLACER" and (X, Y) not in VV:
raise IllegalMoveError(
"in - JeuMorpion.lireCaseUI"
) # Vérifions que la case à placer est bien disponible
elif placer == "LIBERER" and (X, Y) not in VC:
raise IllegalMoveError(
"in - JeuMorpion.lireCaseUI"
) # Vérifions que la case à libérer est bien libérable
except (ValueError, TypeError, IndexError, IllegalMoveError) as e:
self.handleError(e)
continue
break
return (X, Y)
def selectionnerModeJeu(self):
while True:
print("Q : Which mode do you wanna play ? ", end='\t\n')
if not self.__isConsoleActive:
# Attendons d'avoir choisi un mode de jeu
self.__Application.wait_variable(
self.__Application.getModeJeuVariable())
# ... et notons-le
self.__ModeJeu = self.__Application.getModeJeuVariable().get()
else:
try:
# On affiche les modes existants
for (mode, text) in MODES:
print("\t%d : %s" % (mode, text))
# quel mode ?
self.__ModeJeu = int(input("? "))
# Confirmation
print("INFO : Vous avez selectionné le mode " +
str(self.__ModeJeu))
except (ValueError, TypeError, IndexError) as e:
self.handleError(e)
continue
break
def handleError(self, error):
""" Error handling function """
type_err = type(error)
if type_err == ValueError:
print("ERROR : Oops! That was no valid number. Try again...")
elif type_err == TypeError:
print("ERROR : Oops! Cannot convert to int. Try again...")
elif type_err == IndexError:
print(
"ERROR : Oops! That number was out of bounds. Try again...")
elif type_err == IllegalMoveError:
print("ERROR : Oops! That was an illegal move. Try again...")
else:
print("ERROR : Oops! An error occurred but idk why. Try again...")
print("\t[error_type] %s, \n\t[error] %s" % (type_err, error))
print("DEBUG : Handling error in handleError function...")
# DEBUG: traceback.print_exc()
# =============================================================================
# Fonctions pour jouer un coup
# =============================================================================
# def placer_pion_random(self, Color):
# """ Place un pion au hasard dans la grille après l'avoir enlevé """
# # TODO: effacer cette fonction qui est passée dans Tour
# # On récupère le vecteur correspondant à la couleur
# VC = self.__Grille.getVector(Color)
# VV = self.__Grille.getVector(VIDE)
#
# # S'il y a plus de __nbPions pions Color, on libère un pion de la grille...
# if len(VC) >= self.__nbPions :
# VV.append(VC.pop(random.randint(0, len(VC)-1)))
#
# # ... et on positionne un nouveau pion
# VC.append(VV.pop(random.randint(0, len(VV)-1)))
def placer_pion(self, Color):
""" Place un pion """
if Color == HUMAIN:
self.placer_pion_humain(Color)
else:
self.placer_pion_machine(Color)
# Changeons et effaçons les textes des boutons
if not self.__isConsoleActive: self.updateButtonText(Color)
def placer_pion_humain(self, Color):
""" Permet au joueur humain de placer un pion """
# On récupère le vecteur correspondant à la couleur
VC = self.__Grille.getVector(Color)
VV = self.__Grille.getVector(VIDE)
# Tuple des 2 fonctions à utiliser en fonction de __isConsoleActive
lire = (self.lireCaseUI, self.lireCaseConsole)
# S'il y a plus de __nbPions pions Color, on libère un pion de la grille...
if len(VC) >= self.__nbPions:
# On récupère les coordonnées d'une case au clavier (dans la console)
# lireCaseConsole contrôle aussi la possibilité de jouer ce coup
VV.append(
VC.pop(
VC.index(lire[self.__isConsoleActive](Color=Color,
placer="LIBERER"))))
# ... et on positionne un nouveau pion
VC.append(
VV.pop(
VV.index(lire[self.__isConsoleActive](Color=Color,
placer="PLACER"))))
def placer_pion_machine(self, Color):
""" Joue le tour de la machine """
tour = self.__TAB_TOUR[self.__ModeJeu](
self.__Grille, Color
) # on crée une instance de Tour (le mode indique quel constructeur appeler)
tour.jouerUnTour() # jouons un tour
del tour # on n'a plus besoin de l'instance de Tour
def placer_pion_2machines(self, Color):
""" Joue le tour de la machine contre elle même """
tour = self.__TAB_TOUR[self.__ModeJeu][Color](
self.__Grille, Color
) # le changement avec précédemment est que __TAB_TOUR contient pour ce type de partie des tuples de 2 tours
tour.jouerUnTour()
del tour
# =============================================================================
# Fontions pour lancer le jeu
# =============================================================================
def jouer(self):
""" Procédure de jouer (boucle principale) """
# TODO: màj avec Tour
print("INFO : Let's play !")
# Choisissons une couleur
color = self.__colorInit
# Init des conditions de fin de boucle
self.__forceStop = False
self.__inGame = True
while self.__inGame:
try:
# FORCE STOP (ou pas...)
if self.__forceStop:
return
# Fonction Jouer
self.__TAB_PLACER_PION[self.__ModeJeu](color)
self.__inGame = not (self.__Grille.gagnant(color))
self.checkRepetition()
self.__Grille.afficherGrilleConsole()
if self.__inGame:
color = not (color) # changeColor
# print("DEBUG: i am switching colors")
except FinDuJeuParRepetitionError:
print("ERROR : Oops! Feels something like Déjà Vu...")
break
except Exception:
print("ERROR : Unknown error, shutting down...")
traceback.print_exc()
self.__Application.quit()
break
print("-------- %s a gagné ! ---------" % UI[color])
# =============================================================================
# get...()
# =============================================================================
def getDim(self):
return self.__dim
def __init__(self):
self._grille_ = Grille()
self.tour = 1