def test_paiement_ticket_sans_ticket(self): caisse = Caisse() carte = Carte() carte.crediter(6) caisse.insererCarte(carte) caisse.paiementTicket(5) self.assertTrue(carte.solde() == 1)
def test_debiter_tickets_quand_plus_de_monnaie(self): carte = Carte() carte.crediter(10) carte.crediterTicket(2) carte.setValueOfTicket(10) with self.assertRaises(Exception): carte.debiterTicket(21)
def testCalculForce3(self): c1 = Carte(1, 'A') c2 = Carte(5, 'A') c3 = Carte(7, 'A') g = GroupeCartes(c1, c2, c3) g.calculForce() self.assertEqual(g.force, 3)
def check_belotte(hands, trumps): if len(trumps) != 1: return False trump = trumps[0] for hand in hands: if (Carte(Value.Dame, trump) in hand and Carte(Value.Roi, trump) in hand): return True return False
def test_initCarte(self): """Test unitaire permettant de vérifier la creation d'une carte à partir d'une chaine de caractères """ maCarte = Carte('test', self.carte) #1. on vérifie si carte à les bonnes dimensions self.assertEqual(maCarte.dim(), "(10x7)") #2.On vérifie qu'aucun robot n'est encore positionné self.assertEqual(maCarte.posRobot(), (0, 0)) #3.On vérifie que cela fait bien la représentation attendue self.assertEqual(maCarte.labyrinthe, self.grille)
def __setstate__(self, lab): """ methode pour gerer la création de donnees de Pickle non utilisée actuellement car conflict avec les namedtuple """ nom_carte, tuple_robot, self.obstacle = lab self.carte = Carte(nom_carte) Coordonnees = namedtuple('Coordonnees', ['abscisse', 'ordonnee']) self.robot = Coordonnees(tuple_robot[0], tuple_robot[1]) self.carte.deplacer_robot(" ", self.robot) print(self)
def __init__(self): """Définit un jeu.""" super().__init__() self.carte_perso = Carte(False) self.carte_adversaire = Carte(True) self.nom_joueur = "Capichef" self.partie_perdue = False self.partie_gagnee = False self.compteur_bateau_coule = 0 self.nom_adversaire = "" self.droit_de_tir = False
def test_voisins(self): """ Teste la détection de voisins """ carte = Carte(4, 4) for lig in range(4): for col in range(4): carte.cases[lig][col] = '.' voisins = list(carte.voisins(0, 0)) self.assertEqual(len(voisins), 2) voisins = list(carte.voisins(1, 1)) self.assertEqual(len(voisins), 4)
def setUp(self): self.O = 8 self.S = 4 self.E = 2 self.N = 1 self.liste_cartes = [] self.liste_cartes_droite = [] for i in range(16): self.liste_cartes.append( Carte(i & self.N == self.N, i & self.E == self.E, i & self.S == self.S, i & self.O == self.O)) self.liste_cartes_droite.append( Carte(i & self.O == self.O, i & self.N == self.N, i & self.E == self.E, i & self.S == self.S))
def test_paiement_ticket_avec_ticket(self): caisse = Caisse() carte = Carte() carte.crediterTicket(2) carte.setValueOfTicket(5) carte.crediter(6) caisse.insererCarte(carte) caisse.paiementTicket(5) self.assertTrue(carte.solde() == 6)
def choisir_une_carte(cartes): c = "n" if "partie_sauvegardee.txt" in os.listdir("cartes"): c = partie_sauvegardee_ou_nouvelle() if c.lower() == "o": print("Partie Sauvegardée") # ouvrir la partie_sauvegardee chaine = ouvrir_partie("partie_sauvegardee.txt") carte = Carte("partie_sauvegardee.", chaine) else: # supprimer s'il exite un partie sauvegardée supprimer_partie_sauvegardee() # ouvrir une nouvelle partie test = False while test == False: try: c = int( input( "Entrez un numéro de labyrinthe pour commencer à jouer : " )) carte = cartes[c - 1] test = True except ValueError: print("La valeur donnée doit un entier") test = False except IndexError: print( "le numéro doit être correspondant à l'une des cartes affichées au dessus" ) test = False return carte
def selectMap(): """Ask user to select a map and return it""" # Load all map from "cartes" folder cartes = [] for filename in os.listdir("cartes"): if filename.endswith(".txt"): path = os.path.join("cartes", filename) mapName = filename[:-3].lower() with open(path, "r") as mapFile: mapContent = mapFile.read() cartes.append(Carte(mapName, mapContent)) # Display all existing maps print("Labyrinthes existants :") for i, carte in enumerate(cartes): print(" {} - {}".format(i + 1, carte.nom)) # Ask user to select a map while True: try: map = input("Entrez un numéro de labyrinthe pour commencer à jouer : ") map = int(map) - 1 if map < 0 or map >= len(cartes): raise ValueError break except ValueError: print("Numéro de labyrinthe incorrect ! Merci de resaisir !") return cartes[map]
def __init__(self): self.cartes = [] for valeur in Carte.valeurs_valides: for couleur in Carte.couleurs_valides: c = Carte(valeur, couleur) self.cartes.append(c)
def __init__(self, C1=Carte(0, 'X'), C2=Carte(0, 'X'), C3=Carte(0, 'X')): # On définit Carte(0,'X') comme un emplacement vide ''' Crée un groupe avec les cartes C1 C2 et C3 Paramètres ---------- Les 3 cartes qui composent le groupe ''' self.C1 = C1 self.C2 = C2 self.C3 = C3 self.carteCourante = 0 self.totalPoints = C1.valeur + C2.valeur + C3.valeur self.force = 0
def setUp(self): """Crée un jeu vide avec deux joueurs.""" carte = Carte("test", GRILLE) self.jeu = Jeu(carte) self.grille = dict(self.jeu.labyrinthe.grille) self.joueur_1 = self.jeu.ajouter_joueur(None) self.joueur_2 = self.jeu.ajouter_joueur(None)
def chercheSuites(self, no_IA): ### on commence par trier la main par couleur puis valeur mainClassee = sorted(self, key=lambda card: [card.couleur, card.valeur]) for i in range(len(self)): self[i] = mainClassee[i] ### on cherche les embryons de suite déjà sur le tapis suitesTap = [] for borne in self.jeu.ensembleBorne: if no_IA == 1: difVal = abs(borne.g1.C1.valeur - borne.g1.C2.valeur) if not borne.g1.estComplet() and ( (difVal > 0 and difVal < 2) or difVal == borne.g1.C1.valeur ): # on a une ou deux cartes sur la borne, qui rendent possibles une suite suitesTap.append(borne) if no_IA == 2: difVal = abs(borne.g1.C1.valeur - borne.g1.C2.valeur) if not borne.g1.estComplet() and ( (difVal > 0 and difVal < 2) or difVal == borne.g1.C1.valeur ): # on a une ou deux cartes sur la borne, qui rendent possibles une suite suitesTap.append(borne) ### on cherche les suites complètes ou possibles à compléter dans la main suitesCompletesMain = [] suitesACompleterMain = [] dicoCouleur = {'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5} for i in range(1, len(self)): carte_prev = self[i - 1] carte = self[i] try: carte_next = self[i + 1] except: carte_next = Carte(0, 'X') if carte_next.couleur == carte_prev.couleur and carte_next.valeur - carte_prev.valeur == 2: #suite complète suitesCompletesMain.append([i - 1, i, i + 1]) elif carte.couleur == carte_prev.couleur and carte.valeur - carte_prev.valeur == 1: #on va chercher la première ou la dernière de la suite probaTot = self.jeu.proba[dicoCouleur[carte.couleur]][ carte.valeur] + self.jeu.proba[dicoCouleur[carte.couleur]][ carte_prev.valeur - 2] #Probabilité d'obtenir la première ou dernière de la suite if probaTot > 0.3: suitesACompleterMain.append = ([i - 1, i]) elif carte.couleur == carte_prev.couleur and carte.valeur - carte_prev.valeur == 2: #on va chercher la carte du milieu probaTot = self.jeu.proba[dicoCouleur[carte.couleur]][ carte_prev.valeur] #Probabilité d'obtenir la première ou dernière de la suite if probaTot > 0.3: suitesACompleterMain.append = ([i - 1, i]) return [suitesCompletesMain, suitesACompleterMain, suitesTap]
def __init__(self, taille, no, partie): super().__init__(taille, no, partie) self.niveau = 3 self.no_carte = -1 self.no_carte_next = -1 self.no_carte_next2 = -1 self.noBorne = -1 self.carteJouee = Carte(0, 'X') self.emplacementVise = 0
def chargementCarte(nom_fichier): """ Chargement de la carte associée au nom du fichier et initialise le labyrinthe associé à cette carte""" for nom_fichier_carte in os.listdir("cartes"): if nom_fichier_carte.endswith( ".txt") and nom_fichier_carte == nom_fichier: chemin = os.path.join("cartes", nom_fichier_carte) nom_carte = nom_fichier_carte[:-3].lower() with open(chemin, "r") as fichier: contenu = fichier.read() return Carte(nom_carte, contenu)
def test_getTresor_mettreTresor(self): c1 = Carte(True, False, True, False) c2 = Carte(True, False, True, False, 10) self.assertEqual(c1.mettreTresor(5), 0, "la carte " + str(c1) + " ne possèdait aucun trésor => valeur attendue 0\n" + "Le problème vient sans doute de la fonction Carte ou de la fonction mettreTresor") self.assertEqual(c1.getTresor(), 5, "la carte " + str(c1) + " doit posséder le trésor 5\n" + "Le problème vient sans doute de la fonction mettreTresor ou de la fonction getTresor") self.assertEqual(c2.mettreTresor(7), 10, "la carte " + str(c2) + " possédait le trésor 10 => valeur attendue 10\n" + "Le problème vient sans doute de la fonction Carte ou de la fonction mettreTresor") self.assertEqual(c2.getTresor(), 7, "la carte " + str(c2) + " doit posséder le trésor 7\n" + "Le problème vient sans doute de la fonction mettreTresor ou de la fonction getTresor")
def piocher(self): ''' Pioche la première carte de la pioche et l'ajoute à la main du joueur Paramètres ---------- Aucun ''' if self.jeu.pioche != []: nouvelleCarte = self.jeu.pioche.pop() self.append(Carte(int(nouvelleCarte[1]), nouvelleCarte[0]))
def __init__(self, channel, vocal_channel, hand_channels, players, index): self.lock = Lock() self.index = index self.channel = channel self.vocal = vocal_channel self.hand_channels = hand_channels # Create the players self.players = {} for (id, user) in enumerate(players): p = Player(user, id, index, hand_channels[user]) self.players[user] = p self.players[id] = p self.all_players = [self.players[i] for i in range(4)] for i, p in enumerate(self.all_players): p.next = self.players[(i + 1) % 4] # Register the spectators self.spectators = set() # Generate the deck self.deck = Carte.full_deck() shuffle(self.deck) # Variables for announces self.anounce = None self.phase = BET_PHASE self.pass_counter = 0 self.annonce_msg = None # Score (number of games won) self.global_score_msg = None self.global_score = [0, 0] # Tricks (number of tricks won) self.trick_msg = None self.tricks = [0, 0] # Team points during a game self.points = [0, 0] # Past trick and active trick self.last_trick_msg = None self.active_trick_msg = None self.active_trick = [] # Indexes p0 = self.players[0] self.active_player = p0 self.leader = p0 self.dealer = p0 self.taker = p0
def test_getTresor_prendreTresor(self): c1 = Carte(True, False, True, False) c2 = Carte(True, False, True, False, 10) self.assertEqual(c1.prendreTresor(), 0, "la carte " + str(c1) + " ne possèdait aucun trésor => valeur attendue 0\n" + "Le problème vient sans doute de la fonction Carte ou de la fonction prendreTresor") self.assertEqual(c1.getTresor(), 0, "la carte " + str(c1) + " ne devrait plus posséder de trésor \n" + "Le problème vient sans doute de la fonction prendreTresor ou de la fonction getTresor") self.assertEqual(c2.prendreTresor(), 10, "la carte " + str(c2) + " possédait le trésor 10 => valeur attendue 10\n" + "Le problème vient sans doute de la fonction Carte ou de la fonction prendreTresor") self.assertEqual(c2.getTresor(), 0, "la carte " + str(c2) + " ne devrait plus posséder de trésor \n" + "Le problème vient sans doute de la fonction prendreTresor ou de la fonction getTresor")
def chercheSuitesMain(self, no_IA): ### on cherche les suites complètes ou possibles à compléter dans la main suitesCompletesMain = [] suitesACompleterMain = [] dicoCouleur = {'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5} for i in range(1, len(self)): carte_prev = self[i - 1] carte = self[i] try: carte_next = self[i + 1] except: carte_next = Carte(0, 'X') if carte_next.couleur == carte_prev.couleur and carte_next.valeur - carte_prev.valeur == 2: #suite complète suitesCompletesMain.append([i - 1, i, i + 1]) elif carte.couleur == carte_prev.couleur and carte.valeur - carte_prev.valeur == 1: try: #on va chercher la première ou la dernière de la suite probaTot = self.jeu.proba(no_IA)[dicoCouleur[ carte.couleur]][carte.valeur] +self.jeu.proba(no_IA)[dicoCouleur[carte.couleur]][ carte_prev.valeur - 2] -sp.binom(len(self.jeu.pioche) + 6, 2) / sp.binom( len(self.jeu.pioche) + 6, int(1 + len(self.jeu.pioche) / 2)) except IndexError: #il est impossible d'obtenir certaines cartes if carte.valeur == 1: probaTot = self.jeu.proba(no_IA)[dicoCouleur[ carte.couleur]][carte.valeur] if carte.valeur == 9: probaTot = self.jeu.proba(no_IA)[dicoCouleur[ carte.couleur]][carte_prev.valeur - 2] # elif carte.couleur == carte_prev.couleur and carte.valeur-carte_prev.valeur == 1: #on va chercher la première ou la dernière de la suite # probaTot = self.jeu.proba[dicoCouleur[carte.couleur]][carte.valeur] + self.jeu.proba[dicoCouleur[carte.couleur]][carte_prev.valeur -2] # # #Probabilité d'obtenir la première ou dernière de la suite # if probaTot > 0.3: # suitesACompleterMain.append([i-1, i]) elif carte.couleur == carte_prev.couleur and carte.valeur - carte_prev.valeur == 2: #on va chercher la carte du milieu probaTot = self.jeu.proba(no_IA)[dicoCouleur[carte.couleur]][ carte_prev.valeur] #Probabilité d'obtenir la carte du milieu de la suite if probaTot > 0.3: suitesACompleterMain.append([i - 1, i]) return [suitesCompletesMain, suitesACompleterMain]
def rafraichir(self): ''' Rafraîchit le contenu de la borne à l'aide des éléments du tableau Paramètres ---------- Aucun ''' sauvegardeCarteCourante1 = self.g1.carteCourante sauvegardeCarteCourante2 = self.g2.carteCourante self.g1 = GroupeCartes( Carte(self.plateau.tapis[0][self.position].valeur, self.plateau.tapis[0][self.position].couleur), Carte(self.plateau.tapis[1][self.position].valeur, self.plateau.tapis[1][self.position].couleur), Carte(self.plateau.tapis[2][self.position].valeur, self.plateau.tapis[2][self.position].couleur)) self.g2 = GroupeCartes( Carte(self.plateau.tapis[4][self.position].valeur, self.plateau.tapis[4][self.position].couleur), Carte(self.plateau.tapis[5][self.position].valeur, self.plateau.tapis[5][self.position].couleur), Carte(self.plateau.tapis[6][self.position].valeur, self.plateau.tapis[6][self.position].couleur)) self.g1.carteCourante = sauvegardeCarteCourante1 self.g2.carteCourante = sauvegardeCarteCourante2
def __init__(self, pos, plateau): ''' Crée une borne séparant les groupes de cartes g1 et g2. Paramètres ---------- Position sur le plateau Plateau ''' self.position = pos # la position de la borne sur le plateau self.premierComplete = 0 # conserve 1 ou 2 correspondant au côté du joueur ayant fini en premier self.plateau = plateau self.g1 = GroupeCartes( Carte(self.plateau.tapis[0][self.position].valeur, self.plateau.tapis[0][self.position].couleur), Carte(self.plateau.tapis[1][self.position].valeur, self.plateau.tapis[1][self.position].couleur), Carte(self.plateau.tapis[2][self.position].valeur, self.plateau.tapis[2][self.position].couleur)) # le groupe de cartes du côté du joueur 1 self.g2 = GroupeCartes( Carte(self.plateau.tapis[4][self.position].valeur, self.plateau.tapis[4][self.position].couleur), Carte(self.plateau.tapis[5][self.position].valeur, self.plateau.tapis[5][self.position].couleur), Carte(self.plateau.tapis[6][self.position].valeur, self.plateau.tapis[6][self.position].couleur)) # le groupe de cartes du côté du joueur 2 self.g1.carteCourante = 2 self.g2.carteCourante = 4
def main(): # On efface l'écran, on affiche le logo du jeu logo() usage() # On affiche les cartes existantes print("Labyrinthes existants :") liste_cartes = lister_cartes() for i, element_carte in enumerate(liste_cartes): # affiche nom de carte : exemple --> 1 - facile. print(" {} - {}".format(i + 1, element_carte[0])) # Vérification partie sauvegardée sauvegarde = '' if "_sauvegarde.txt" in os.listdir("cartes"): sauvegarde = input( "Il existe une partie sauvegardée, voulez-vous la continuer (oui/non) ? " ) sauvegarde = sauvegarde.lower() if sauvegarde == "oui" or sauvegarde == "o": try: carte = Carte("sauvegarde", "_sauvegarde.txt") robot = Robot(carte.position_robot) except: print("Problème de restauration !") sys.exit(-1) # Choix de labyrinthe/carte else: choix = input("Choisissez votre labyrinthe : ") try: choix = int(choix) except: print("Mauvaise saisie") try: carte = Carte(liste_cartes[choix - 1][0], liste_cartes[choix - 1][1]) robot = Robot(carte.position_robot) except: print("Carte non trouvée ou incorrecte !") sys.exit(-1) # Let's play!!! carte.afficher_liste_contenu() while True: reponse = input( "\nSaisissez le mouvement souhaité ('quit' pour quitter) : ") reponse = reponse.lower() if reponse == "quit" or reponse == 'q': print("Au revoir !") break if re.match(r"^[nseo][1-9]|^[nseo]", reponse): if len(reponse) == 1: robot.bouger(carte, reponse[0]) elif len(reponse) == 2: robot.bouger(carte, reponse[0], int(reponse[1])) else: print("Mauvaise saisie") usage() continue
def chargementCartes(): """ Charge les carte et initialise les labyrinthe """ cartes = [] listcarte = os.listdir("resources/cartes/") for nom_fichier in listcarte: if nom_fichier.endswith(".txt"): chemin = os.path.join("resources/cartes", nom_fichier) nom_carte = nom_fichier[:-3].lower() with open(chemin, "r") as fichier: contenu = fichier.read() cartes.append(Carte(nom_carte, contenu)) return cartes
def test_decoderMurs(self): c = Carte(True, True, True, True) for i in range(16): c.decoderMurs(i) self.assertEqual(c.murNord(), self.liste_cartes[i].murNord(), "le resultat de decoderMur avec le code " + str(i) + " aurait du donner " + str(self.liste_cartes[i]) + " mais on a obtenu " + str(c)) self.assertEqual(c.murEst(), self.liste_cartes[i].murEst(), "le resultat de decoderMur avec le code " + str(i) + " aurait du donner " + str(self.liste_cartes[i]) + " mais on a obtenu " + str(c)) self.assertEqual(c.murSud(), self.liste_cartes[i].murSud(), "le resultat de decoderMur avec le code " + str(i) + " aurait du donner " + str(self.liste_cartes[i]) + " mais on a obtenu " + str(c)) self.assertEqual(c.murOuest(), self.liste_cartes[i].murOuest(), "le resultat de decoderMur avec le code " + str(i) + " aurait du donner " + str(self.liste_cartes[i]) + " mais on a obtenu " + str(c))
def check_if_game_session_open(): if os.path.exists(name_file_histo): # If the file exist we collect it file_histo = open(name_file_histo, "rb") # mon_depickler = pickle.Unpickler(file_histo) if os.stat(name_file_histo).st_size == 0: print("No game running.") choose_map_game() else: valide_selection = True while valide_selection: try: print(" ") print("A party is saved, do you want to continue? " "(Y/N)") selection = input() if selection.lower() == 'y': print("we'll continue the party") map_game = Carte.load_game(file_histo) map_game = str('\n'.join(''.join( str(cell) for cell in row) for row in map_game)) print(map_game) line_tab.extend(map_game[:].split('\n')) valide_selection = False elif selection.lower() == 'n': print("New game") Carte.delete_game() print("Old party deleted.") choose_map_game() valide_selection = False else: print("You wrote a wrong command. Please retry.") except ValueError: print("problem") else: # The file doesn't exist histo = {}
def charger_les_cartes_existantes(): # liste des cartes ( les élèments sont de type : Carte ) cartes = [] for nom_fichier in os.listdir("cartes"): if nom_fichier.endswith( ".txt") and nom_fichier != "partie_sauvegardee.txt": chemin = os.path.join("cartes", nom_fichier) nom_carte = nom_fichier[:-3].lower() with open(chemin, "r") as fichier: contenu = fichier.read() # création d'une carte cartes.append(Carte(nom_carte, contenu)) return cartes
import sys import random import os import time from PyQt4 import QtGui, QtCore from carte import Carte from ms import MS from bts import BTS import log LOG_DIR = "log" app = QtGui.QApplication(sys.argv) args = QtCore.QCoreApplication.arguments() carte = Carte(800, 600) if (len(args) >= 2): carte.load_file(args[1]) if (len(args) >= 3): carte.set_speed(int(args[2])) if not os.path.exists(LOG_DIR): os.makedirs(LOG_DIR) log.LogFile.outFile = file(LOG_DIR + time.strftime("/%F_%T.log"), "w") carte.start_moving_ms()