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