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