def menu():
print ("Bienvenue au jeu des petits chevaux espagnols!!!\n")
#Creation des objets joueurs
global jeu
jeu.j1 = Joueur("Jaune")
jeu.j2 = Joueur("Rouge")
jeu.j3 = Joueur("Vert")
jeu.j4 = Joueur("Bleu")
combienDeJoueur = obtenirInt("Combien de personnes êtes vous? (entre 1 et 4)\n")
while (combienDeJoueur >= 5 or combienDeJoueur <= 0):
combienDeJoueur = obtenirInt("NON! Le nombre de joueur possible est compris entre 1 et 4\n")
if (combienDeJoueur==1):
print ("il y aura 3 autres participants virtuels.")
jeu.j1.Nom = input("Comment vous appellez-vous?\n")
jeu.j1.Humain = True
print ("bonjour",jeu.j1.Nom,"!\nVous etes le joueur Jaune\n")
elif (combienDeJoueur==2):
print ("Il y aura deux autres jouers virtuels.")
jeu.j1.Nom=input("J1 Comment vous appellez-vous?\n")
print ("bonjour",jeu.j1.Nom,"!")
jeu.j1.Humain = True
jeu.j2.Nom=input("J2 Comment vous appellez-vous?\n")
print ("bonjour",jeu.j2.Nom,"!")
jeu.j2.Humain = True
elif (combienDeJoueur==3):
print ("Il y aura un autres joueurs virtuels.")
jeu.j1.Nom=input("J1 Comment vous appellez-vous?\n")
print ("bonjour",jeu.j1.Nom,"!")
jeu.j1.Humain = True
jeu.j2.Nom=input("J2 Comment vous appellez-vous?\n")
print ("bonjour",jeu.j2.Nom,"!")
jeu.j2.Humain = True
jeu.j3.Nom= input("J3 Comment vous appellez-vous?\n")
print ("bonjour",jeu.j3.Nom,"!")
jeu.j3.Humain=True
elif (combienDeJoueur==4):
print ("Il n'y aura pas de joueurs virtuel")
jeu.j1.Nom=input("J1 Comment vous appellez-vous?\n")
print ("bonjour",jeu.j1.Nom,"!")
jeu.j1.Humain = True
jeu.j2.Nom=input("J2 Comment vous appellez-vous?\n")
print ("bonjour",jeu.j2.Nom,"!")
jeu.j2.Humain = True
jeu.j3.Nom=input("J3 Comment vous appellez-vous?\n")
print ("bonjour",jeu.j3.Nom,"!")
jeu.j3.Humain = True
jeu.j4.Nom=input("J4 Comment vous appellez-vous?\n")
print ("bonjour",jeu.j4.Nom,"!")
jeu.j4.Humain = True
jeu.maxide = obtenirInt("Combien de faces le de a-t-il? La valeur possible est compris entre 6 et 12\n")
print ("Le dé ira jusqu'a",jeu.maxide)
while (jeu.maxide > 12 or jeu.maxide < 6):
jeu.maxide = obtenirInt("NON! La valeur possible est compris entre 6 et 12\n")
print ("Le dé ira jusqu'a",jeu.maxide)
def __init__(self, nom1, prenom1, nom2, prenom2):
self.__nom1 = nom1
self.__prenom1 = prenom1
self.__nom2 = nom2
self.__prenom2 = prenom2
self.__jeuDeCartes = JeuCartesClassique()
self.__J1 = Joueur(nom1, prenom1)
self.__J2 = Joueur(nom2, prenom2)
def __init__(self, nom1, prenom1, nom2, prenom2):
self.nom1 = nom1
self.prenom1 = prenom1
self.nom2 = nom2
self.prenom2 = prenom2
self.__joueur1 = Joueur(nom1, prenom1)
self.__joueur2 = Joueur(nom2, prenom2)
self.__jeuDeCarte = jeuCarteClassique()
def __init__(self, joueur1, joueur2, contreIa=False, niveauIa=7):
"""
creation de deux joueurs et d'un plateau de jeu
"""
self.tour = 0
self.joueur2 = Joueur(joueur2, 1)
if contreIa:
self.joueur1 = IA(joueur1, 0, niveauIa)
else:
self.joueur1 = Joueur(joueur1, 0)
self.plateau = Plateau()
def main():
casino = Casino(100000)
jeu1 = Roulette.Roulette("my wheel", casino)
jeu2 = MachineASous("bandit manchot", casino)
joueur = Joueur("Clement", 1000)
joueur.entrer_casino(casino)
joueur.jouer()
def __init__(self, nb_joueurs, nb_cases=9, largeur_muret=2):
###########################
### Initialiser plateau
###########################
self.nb_cases = nb_cases
self.case_max = (nb_cases - 1) * 2
self.largeur_muret = largeur_muret
self.plateau = Plateau(nb_cases, largeur_muret)
if nb_joueurs not in (2, 4):
raise (TypeError, "nb joueurs : 2 ou 4")
milieuj1 = self.case_max // 4 * 2
milieuj2 = self.case_max - milieuj1 # En cas de cases paires, évite de mettre les pions en face
coord_joueurs = [(milieuj1, 0), (milieuj2, self.case_max)]
if nb_joueurs == 4:
coord_joueurs.insert(1, (0, milieuj1))
coord_joueurs.append((self.case_max, milieuj2))
print(coord_joueurs)
nb_murets = ((nb_cases + 1) * 2) // nb_joueurs
self.joueurs = [
Joueur(i, coord, nb_murets, self.plateau)
for i, coord in enumerate(coord_joueurs)
]
self.nb_tours = -1
self.joueur_en_cours = self.joueurs[0]
self.joueurs[0].mon_tour = True
self.interface = InterfaceCorridor(self)
self.tour_suivant()
self.interface.fenetre.mainloop()
def __init__(self, situationsConnues, mini, console = True, apprentissage = True, IA1 = True, IA2 = True, apprentissageVolee = False):
self.console = True
self.apprentissage = apprentissage
self.gagnant = None
infosPieces = mini2pieces(mini)
self.idJoueur, piecesJoueurs = infosPieces
from Joueur import Joueur
self.joueurs = [None, None]
self.joueurs[0] = Joueur(situationsConnues, 0, piecesJoueurs[0], IA1, apprentissageVolee)
self.joueurs[1] = Joueur(situationsConnues, 1, piecesJoueurs[1], IA2, apprentissageVolee)
from Plateau import Plateau
self.gameBoard = Plateau(self.joueurs)
if not console:
self.fenetre = None
def testJoueur(self, clo=None, clo1=None):
if clo == None:
clo = Joueur(" Hollande", 0)
if clo1 == None:
clo1 = clo.clone()
assert clo1.nombreCapture == clo.nombreCapture
clo1.nombreCapture = 2
assert clo1.nombreCapture != clo.nombreCapture
def __init__(self, nb_ia, nb_hn=1):
"""
Permet de créer la partie, à partir du nombre de joueurs (humains et IA)
mis en entrée.
Paramètres
----------
nb_ia: int
Le nombre de joueurs IA.
nb_hn : int
Le nombre de joueurs humains.
"""
self.L_joueur = [Joueur('DH')]
self.nb_hn = nb_hn - 1
Posdisp = [str(k) for k in range(self.nb_hn + nb_ia)]
while self.nb_hn > 0:
self.L_joueur.append(Joueur('AH' + Posdisp[0]))
Posdisp = Posdisp[1:]
self.nb_hn -= 1
nb_ia_0, nb_ia_1, nb_ia_2 = self.choix_niveau(nb_ia)
while nb_ia_0 > 0:
self.L_joueur.append(Joueur('AI_0_' + Posdisp[0]))
Posdisp = Posdisp[1:]
nb_ia_0 -= 1
while nb_ia_1 > 0:
self.L_joueur.append(Joueur('AI_1_' + Posdisp[0]))
Posdisp = Posdisp[1:]
nb_ia_1 -= 1
while nb_ia_2 > 0:
self.L_joueur.append(Joueur('AI_2_' + Posdisp[0]))
Posdisp = Posdisp[1:]
nb_ia_2 -= 1
self.mise_en_place()
self.carte = Map.Map(self.L_joueur)
def __init__(self, nb_ia_0, nb_ia_1=0, nb_hn=0, IHM=0):
"""
Permet de créer la partie, à partir du nombre de joueurs (humains et IA)
mis en entrée.
Paramètres
----------
nb_ia_0: int
Le nombre de joueurs IA de niveau 0.
nb_ia_1 : int
Le nombre de joueurs IA de niveau 1.
nb_hn : int
Le nombre de joueurs humains.
"""
self.IHM = IHM
self.L_joueur = [Joueur('DH')]
self.nb_hn = nb_hn
Posdisp = [str(k) for k in range(self.nb_hn + nb_ia_0 + nb_ia_1)]
while self.nb_hn > 0:
self.L_joueur.append(Joueur('AH' + Posdisp[0]))
Posdisp = Posdisp[1:]
self.nb_hn -= 1
while nb_ia_0 > 0:
self.L_joueur.append(Joueur('AI_0_' + Posdisp[0]))
Posdisp = Posdisp[1:]
nb_ia_0 -= 1
while nb_ia_1 > 0:
self.L_joueur.append(Joueur('AI_1_' + Posdisp[0]))
Posdisp = Posdisp[1:]
nb_ia_1 -= 1
self.mise_en_place()
self.carte = Map.Map(self.L_joueur, 0, self.IHM)
def validerUsager(self, usager, password,ordre): table_name = "joueur" # vérifier s'il y a un résultat (impossible qu'il y en ait plus qu'un) sql = "SELECT * FROM %s WHERE NOM = '%s' AND MOT_DE_PASSE = '%s'" %(table_name, usager, password) self.__execute_query(self.oracle_cursor, sql) query_result = self.oracle_cursor.fetchall() connecte = False for row in query_result: connecte = True nouveauJoueur = Joueur(1,1,ordre,row[1],(row[9],row[10],row[11]), row[7], row[8], row[2], row[3],row[4],row[5],row[0], row[6]) sanitizer = Sanitizer() if ordre == 0: DTO.joueur1 = nouveauJoueur DTO.joueur1,DTO.messagesErreurs1 = sanitizer.checkDTO(DTO.joueur1) elif ordre == 1: DTO.joueur2 = nouveauJoueur DTO.joueur2,DTO.messagesErreurs2 = sanitizer.checkDTO(DTO.joueur2) if DTO.joueur1 and DTO.joueur2: DTO.joueurs.append(DTO.joueur1) DTO.joueurs.append(DTO.joueur2) return connecte
def testjouerPlateau(self):
j = Joueur("Hollande", 0)
for i in range(12):
p = Plateau()
p.jouer(i, j)
assert p.cases[i].graines == 0
p = Plateau()
p.cases[5].graines = 2
p.jouer(2, j)
print(p.cases[5].graines)
assert p.cases[5].graines == 3
p = Plateau()
p.cases[7].graines = 2
p.jouer(3, j)
print(p.cases[7].graines)
assert p.cases[7].graines == 0
assert j.nombreCapture == 3
from Casino import Casino
from Joueur import Joueur
from MachineASous import MachineASous
from Roulette import Roulette
casino = Casino(100000)
jeu1 = Roulette("my wheel", casino)
jeu2 = MachineASous("bandit manchot", casino)
joueur = Joueur("Clement", 1000)
joueur.entrer_casino(casino)
joueur.jouer()
from Joueur import Joueur
from Trou import Trou
t = Trou(4)
Plateau = [[], []]
J1 = Joueur(1, "yre")
for i in range(2):
for j in range(6):
t = Trou(4)
Plateau[i].append(t)
for i in range(2):
for j in range(6):
print(Plateau[i][j], end="\t")
print()
print("\n\n")
J1.choix_trou(4, Plateau)
for i in range(2):
for j in range(6):
print(Plateau[i][j], end="\t")
print()
def __init__(self, joueur):
self.__joueur = joueur
self.__ordinateur = Joueur('9000', 'HAL')
self.__jeu = JeuClassique()
def __init__(self, joueur):
self.__joueur = joueur
self.__ordinateur1 = Joueur('C3PO', 'Droid')
self.__ordinateur2 = Joueur('D2', 'R2')
self.__ordinateur3 = Joueur('9000', 'HAL')
self.__jeu = JeuUno()
from Joueur import Joueur
from PartieUno import PartieUno
if __name__ == "__main__":
j1 = Joueur("Duck", "Donald")
j2 = Joueur("Duck", "Daisy")
j3 = Joueur("Duck", "Picsou")
p = PartieUno(j1, j2, j3)
p.demarrerPartie()
from PartieBataille import PartieBataille
from Joueur import Joueur
if __name__ == '__main__':
joueur_1 = Joueur('Lagaffe', 'Gaston')
jeu = PartieBataille(joueur_1)
jeu.demarrerPartie()
def process(self, L):
"""
Effectue le processus de chargement de la partie, en testant les différentes chaînes de caractères de
la liste L.
Paramètres:
------------
L : list
Liste contenant toutes les chaînes de caractères de la sauvegarde; chaque élément de
la liste correspond à une ligne de la sauvegarde.
Renvoie :
----------
Rien.
"""
Tst = ['S', 'R']
if type(self.IHM) != str:
self.IHM.tr_en_crs = 1
self.IHM.tr_Hn_en_crs = 1
while len(L) != 0:
if L[0] == 'Carte':
# Processus de recréation de la carte sauvegardée.
Dims = L[2]
Nbta = L[4]
Nbt = L[6]
U_disp = L[7]
Jr_en_crs = L[8]
L = L[9:]
Dims = Dims[1:-1]
k = Dims.find(',')
X = int(Dims[0:k])
Y = int(Dims[k + 1:])
Constante.xL = X
Constante.yL = Y
if int(X / 2) % 2 == 0:
LL = int(X / 2) + 1
else:
LL = int(X / 2)
if int(Y / 2) % 2 == 0:
LH = int(Y / 2) + 1
else:
LH = int(Y / 2)
LEp = int(max(X, Y) / 20)
Constante.LL_Z_Constructible = LL
Constante.LH_Z_Constructible = LH
Constante.LEp_app = LEp
Constante.Lnbta = int(Nbta)
Constante.Lnbt = int(Nbt)
U_disp = float(U_disp)
self.Lcarte = Map.Map([], 1, self.IHM)
self.Lcarte.TrIA.unite_disp_par_tour = U_disp
self.Lcarte.TrHn.unite_disp_par_tour = U_disp
self.Lcarte.TrHn.Jr_en_crs = int(Jr_en_crs)
print("Carte OK")
while L[0] == 'Ressource':
#Processus de chargement des ressources sauvegardées sur la carte.
Val = L[1]
Pos = L[2]
L = L[4:]
Pos = Pos[1:-1]
k = Pos.find(',')
X = int(Pos[0:k])
Y = int(Pos[k + 1:])
Val = int(Val)
metal(X, Y, self.Lcarte, Val)
print("Ressource OK")
while L[0] == 'Joueur':
# Processus de chargement des joueurs de la partie, et de leurs caractéristiques principales.
Role = L[1]
Metal_tot = int(L[2])
Energie_tot = int(L[3])
Ur = float(L[4])
self.Jr = Joueur(Role)
self.Lcarte.L_joueur.append(self.Jr)
self.Jr.metal_tot = Metal_tot
self.Jr.energie_tot = Energie_tot
self.Jr.nbe_unite_restantes = Ur
L = L[6:]
while L[0] == 'Bat':
# Processus de chargement des batiments du joueur actuel.
Typ = L[1]
Sante = L[2]
Pos = L[3]
L = L[4:]
Sante = int(Sante)
Typ = Typ[-2:]
Pos = Pos[1:-1]
k = Pos.find(',')
X = int(Pos[0:k])
Y = int(Pos[k + 1:])
if Typ == "QG":
B = QG(X, Y, self.Lcarte)
B.sante = Sante
self.Jr._liste_bat[0].append(B)
elif Typ[0] == "P":
Id = int(Typ[1])
B = Panneau_solaire(X, Y, self.Lcarte)
B.sante = Sante
B.id = Id
self.Jr._liste_bat[1].append(B)
elif Typ[0] == "F":
Id = int(Typ[1])
B = Foreuse(X, Y, self.Lcarte)
B.sante = Sante
B.id = Id
self.Jr._liste_bat[2].append(B)
if L[0] == "Fin bat":
print("Fin bat")
L = L[2:]
while L[0] == "Unite":
# Processus de chargement des unités du joueur actuel.
k = -2
Typ = L[1]
Num_joueur = L[2]
Sante = L[3]
Pos = L[4]
if Role[1] == 'H':
Capmvt = int(L[5])
L = L[6:]
else:
L = L[5:]
tTyp = Typ[k:]
while tTyp[0] not in Tst:
k = k - 1
tTyp = Typ[k:]
Typ = tTyp
Num_joueur = int(Num_joueur)
Sante = int(Sante)
Pos = Pos[1:-1]
k = Pos.find(',')
X = int(Pos[0:k])
Y = int(Pos[k + 1:])
if Typ[0:2] == "RC":
Id = int(Typ[2:])
U = Robot_combat(Role, self.Lcarte, X, Y)
U.sante = Sante
U.capmvt = Capmvt
self.Jr._liste_unite.append(U)
elif Typ[0:2] == "RO":
Id = int(Typ[2:])
U = Robot_Ouvrier(Role, self.Lcarte, X, Y)
U.sante = Sante
U.capmvt = Capmvt
self.Jr._liste_unite.append(U)
elif Typ[0] == "S":
if len(Role) > 3 and Role[3] == "0":
Id = int(Typ[3:])
U = Scorpion0(Role, self.Lcarte, X, Y, Num_joueur)
U.sante = Sante
U.id = Id
self.Jr._liste_unite.append(U)
elif len(Role) > 3 and Role[3] == "1":
Id = int(Typ[3:])
U = Scorpion1(Role, self.Lcarte, X, Y, Num_joueur)
U.sante = Sante
U.id = Id
self.Jr._liste_unite.append(U)
elif Role[1] == "H":
Id = int(Typ[1:])
U = Scorpion(Role, self.Lcarte, X, Y, Num_joueur)
U.sante = Sante
U.id = Id
U.capmvt = Capmvt
self.Jr._liste_unite.append(U)
if L[0] == "Fin unite":
print("Fin unite")
L = L[1:]
if L[0] == "Fin sauvegarde":
L = []
else:
L = L[1:]
class Jeu:
michel = Joueur()
croupier1 = Croupier()
jeu1 = JeuDeCarte()
def main(self, Joueur, Croupier, JeuDeCarte):
k = self.jeu1.getJdc()
i = 0
joueur = {}
croupier = {}
while i < 2:
e = random.choice(list(k.items()))
k.pop(e[0])
joueur[e[0]] = e[1]
e = random.choice(list(k.items()))
k.pop(e[0])
croupier[e[0]] = e[1]
i = i + 1
self.michel.setMain(joueur)
self.croupier1.setMain(croupier)
return joueur, croupier, k
def total_main(self, main):
total = 0
for key, val in main.items():
total += val
return total
def tirer_nouvelle_carte(self, main, reste_carte):
e = random.choice(list(reste_carte.items()))
reste_carte.pop(e[0])
main[e[0]] = e[1]
return main
def affiche_mains_points(self, main_j, main_c):
print("\n")
print('main joueur: ', main_j)
print('main croupier: ', main_c)
print('total joueur : ', self.total_main(main_j))
print('total croupier : ', self.total_main(main_c))
print('\n')
def ass(self, main, total):
for i, j in main.items():
if j == 11 and total > 21:
main[i] = 1
return main
def blackjack(self, main, total):
if len(main) == 2 and total == 21:
return True
def jeu(self):
replay = 'o'
while replay == 'o':
mn = self.main(self.michel, self.croupier1, self.jeu1)
reste_carte = mn[2]
print('main joueur : ', mn[0])
total_joueur = self.total_main(mn[0])
total_croupier = self.total_main(mn[1])
nouvellecarte = 'o'
main_j = mn[0]
main_c = mn[1]
a = self.blackjack(main_j, total_joueur)
b = self.blackjack(main_c, total_croupier)
if a:
print('Bravo BlackJack !!!!!!!')
self.affiche_mains_points(main_j, main_c)
elif b:
print('Courtier : BlackJack !!!!!!!')
self.affiche_mains_points(main_j, main_c)
else:
while total_croupier < 17 or total_joueur < 21 or nouvellecarte == 'o':
if total_joueur < 21 or nouvellecarte == 'o':
nouvellecarte = input("voulez vous une carte (o/n) ?")
if nouvellecarte == 'o':
main_j = self.tirer_nouvelle_carte(
mn[0], reste_carte)
total_joueur = self.total_main(main_j)
main_j = self.ass(main_j, total_joueur)
total_joueur = self.total_main(main_j)
if total_joueur >= 21:
nouvellecarte = 'n'
print(
'main joueur : ',
main_j,
)
print('\n')
else:
main_j = mn[0]
if total_croupier < 17:
main_c = self.tirer_nouvelle_carte(
mn[1], reste_carte)
total_croupier = self.total_main(main_c)
main_c = self.ass(main_c, total_croupier)
else:
main_c = mn[1]
if total_croupier >= 17 and nouvellecarte != 'o':
break
else:
break
self.affiche_mains_points(main_j, main_c)
replay = input('voulez vous rejouer ? o/n')
class View:
michel = Joueur()
croupier1 = Croupier()
jeu1 = JeuDeCarte()
jeu2 = JeuDeCarte()
def __init__(self, root):
replay = True
while replay == True:
mn = self.main(self.michel, self.croupier1, self.jeu1)
reste_carte = mn[2]
label0 = Tk.Label(root, text="Tirage : ")
label0.pack()
label1 = Tk.Label(root, text=str(mn[0]))
label1.pack()
total_joueur = self.total_main(mn[0])
total_croupier = self.total_main(mn[1])
nouvellecarte = True
main_j = mn[0]
main_c = mn[1]
a = self.blackjack(main_j, total_joueur)
b = self.blackjack(main_c, total_croupier)
if a:
self.blackjackJ()
replay = self.rejouer()
if replay == False:
root.destroy()
else:
root.destroy()
c = ct.Controller()
c.run()
elif b:
self.blackjackC()
replay = self.rejouer()
if replay == False:
root.destroy()
else:
root.destroy()
c = ct.Controller()
c.run()
else:
while total_croupier < 17 or total_joueur < 21 or nouvellecarte == True:
if total_joueur < 21 or nouvellecarte == True:
nouvellecarte = self.nouvelle_carte()
if nouvellecarte == True:
main_j = self.tirer_nouvelle_carte(
mn[0], reste_carte)
total_joueur = self.total_main(main_j)
main_j = self.ass(main_j, total_joueur)
total_joueur = self.total_main(main_j)
if total_joueur >= 21:
nouvellecarte = 'n'
label2 = Tk.Label(root, text="Main Joueur : ")
label2.pack()
label3 = Tk.Label(root, text=str(main_j))
label3.pack()
else:
main_j = mn[0]
if total_croupier < 17:
main_c = self.tirer_nouvelle_carte(
mn[1], reste_carte)
total_croupier = self.total_main(main_c)
main_c = self.ass(main_c, total_croupier)
else:
main_c = mn[1]
if total_croupier >= 17 and nouvellecarte != True:
break
else:
break
self.affiche_mains_points(main_j, main_c, root)
replay = self.rejouer()
if replay == False:
root.destroy()
else:
root.destroy()
c = ct.Controller()
c.run()
def main(self, Joueur, Croupier, JeuDeCarte):
k = self.jeu1.getJdc()
i = 0
joueur = {}
croupier = {}
while i < 2:
e = random.choice(list(k.items()))
k.pop(e[0])
joueur[e[0]] = e[1]
e = random.choice(list(k.items()))
k.pop(e[0])
croupier[e[0]] = e[1]
i = i + 1
self.michel.setMain(joueur)
self.croupier1.setMain(croupier)
return joueur, croupier, k
def total_main(self, main):
total = 0
for key, val in main.items():
total += val
return total
def tirer_nouvelle_carte(self, main, reste_carte):
e = random.choice(list(reste_carte.items()))
reste_carte.pop(e[0])
main[e[0]] = e[1]
return main
def affiche_mains_points(self, main_j, main_c, root):
label3 = Tk.Label(root, text="Main Joueur : ")
label4 = Tk.Label(root, text=str(main_j))
label5 = Tk.Label(root, text="Main Croupier : ")
label6 = Tk.Label(root, text=str(main_c))
label7 = Tk.Label(root, text="Total Joueur : ")
label8 = Tk.Label(root, text=str(self.total_main(main_j)))
label9 = Tk.Label(root, text="Total Croupier : ")
label10 = Tk.Label(root, text=str(self.total_main(main_c)))
label3.pack()
label4.pack()
label5.pack()
label6.pack()
label7.pack()
label8.pack()
label9.pack()
label10.pack()
def nouvelle_carte(self):
a = messagebox.askyesno("Nouvelle Carte", "Voulez vous une carte ?")
return a
def rejouer(self):
a = messagebox.askyesno("Continuer", "Voulez vous rejouer ?")
return a
def blackjackJ(self):
a = messagebox.showinfo("Joueur", "BlackJack !!!!!")
def blackjackC(self):
a = messagebox.showinfo("Croupier", "BlackJack !!!!!")
def ass(self, main, total):
for i, j in main.items():
if j == 11 and total > 21:
main[i] = 1
return main
def blackjack(self, main, total):
if len(main) == 2 and total == 21:
return True
def afficher(self, niveau): #Affichage et mise en place d'un niveau
self.delete("all")
self.niveau = niveau
#Chargement du niveau
if niveau == -1:
self.niveauActuel = deepcopy(self.custom)
if niveau == 0:
self.niveauActuel = deepcopy(self.tuto)
if niveau == 1:
self.niveauActuel = deepcopy(self.niveau1)
if niveau == 2:
self.niveauActuel = deepcopy(self.niveau2)
if niveau == 3:
self.niveauActuel = deepcopy(self.niveau3)
if niveau == 4:
self.niveauActuel = deepcopy(self.niveau4)
if niveau == 5:
self.niveauActuel = deepcopy(self.niveau5)
if niveau == 6:
self.niveauActuel = deepcopy(self.fin)
#Initialisation des manches
self.deplacement = 0
#Création des joueurs
self.joueur1 = Joueur(2, 2, 1, self)
self.joueur2 = Joueur(4, 2, 2, self)
#Création des listes (remplies lors de la lecture de la matrice)
self.zombies = []
self.portes = []
self.portesX = []
self.portesY = []
#Affichage de la grille (21x21 blocs)
for y in range(0, 21):
for x in range(0, 21):
if (self.niveauActuel[y][x] == 0): #Sol
self.create_image(16 + x * 32,
16 + y * 32,
image=self.solTexture)
if (self.niveauActuel[y][x] == 1): #Mur
self.create_image(16 + x * 32,
16 + y * 32,
image=self.murTexture)
if (self.niveauActuel[y][x] == 2): #Zombie
self.zombies.append(Zombie(x, y, len(self.zombies), self))
self.create_image(16 + x * 32,
16 + y * 32,
image=self.solTexture)
if (self.niveauActuel[y][x] == 3): #Bouton
self.create_image(16 + x * 32,
16 + y * 32,
image=self.solTexture)
self.create_image(16 + x * 32,
16 + y * 32,
image=self.boutonTexture)
if (self.niveauActuel[y][x] == 4): #Porte
self.portes.append(
self.create_image(16 + x * 32,
16 + y * 32,
image=self.porteTexture))
self.portesX.append(x)
self.portesY.append(y)
if (self.niveauActuel[y][x] == 5): #Drapeau
self.create_image(16 + x * 32,
16 + y * 32,
image=self.solTexture)
self.create_image(16 + x * 32,
16 + y * 32,
image=self.drapeauTexture)
#Affichage des joueurs
self.J1 = self.create_image(16 + self.joueur1.getPositionX() * 32,
16 + self.joueur1.getPositionY() * 32,
image=self.J1Texture)
self.J2 = self.create_image(16 + self.joueur2.getPositionX() * 32,
16 + self.joueur2.getPositionY() * 32,
image=self.J2Texture)
self.Z = [] #Affichage de tout les zombies
for i in range(0, len(self.zombies)):
self.Z.append(
self.create_image(16 + self.zombies[i].getPositionX() * 32,
16 + self.zombies[i].getPositionY() * 32,
image=self.zombieTexture))
#Tutoriel
if (niveau == 0):
self.create_image(336, 336, image=self.tutorielTexture)
#Editeur
if (niveau == -1):
self.activeEditeur(
True
) #Active l'éditeur si le niveau actuel est -1 (terrain a éditer)
self.create_image(26, 26,
image=self.editeurTexture) #Interface editeur
self.blocEditeur = self.create_image(
26, 26, image=self.murTexture) #Interface editeur
else:
self.activeEditeur(
False
) #Active l'éditeur si le niveau actuel est -1 (terrain a éditer)
#Change le titre de la fenêtre en fonction du niveau
if (niveau == -1):
self.fenetre.title("Zombies ! - Editeur")
elif (niveau == 0):
self.fenetre.title("Zombies ! - Tutoriel")
else:
self.fenetre.title("Zombies ! - Niveau " + str(niveau))
self.pack()
class TicTacToe:
joueur1=Joueur()
joueur2 =Joueur()
compteurCoupJoue=0
gagnant=None
joueurgagnant=None
def __init__(self,):
self.grille = [['?','?','?'],['?','?','?'],['?','?','?']]
self.joueur1.nom="Joueur 1"
self.joueur1.nom = "Joueur 2"
self.joueur1.jeton='X'
self.joueur2.jeton="O"
self.joueur1.tour=True
self.joueur2.tour = False
self.gagnant=False
def AfficherEtatJeu(self,):
"Méthode permettant de pouvoir afficher le jeu "
for i in range (3):
print (self.grille[i])
def JouerJeton(self,):
print ("Veuillez choisir quelle ligne joué ")
ligneX = int(input())
print("Veuillez choisir quelle colonne ")
colonneY = int(input())
if self.grille[colonneY-1][ligneX-1]==self.joueur1.jeton or self.grille[colonneY-1][ligneX-1]==self.joueur2.jeton :
while self.grille[colonneY-1][ligneX-1]== self.grille[colonneY-1][ligneX-1]==self.joueur1.jeton or self.grille[colonneY-1][ligneX-1]==self.joueur2.jeton:
print ("Vous avez joué dans une case déjà prise ... Vous devez rejouer.")
self.AfficherEtatJeu()
print("Veuillez choisir quelle ligne joué ")
ligneX = int(input())
print("Veuillez choisir quelle colonne ")
colonneY = int(input())
if self.compteurCoupJoue %2 == 0:
self.grille[colonneY-1][ligneX-1] = self.joueur1.jeton
else:
self.grille[colonneY - 1][ligneX - 1] = self.joueur2.jeton
return self.grille
def VerifierGagnant(self,):
if self.grille[0][0]=='O' and self.grille[0][1] == 'O' and self.grille[0][2] == 'O':
finpartie = True
self.joueurgagnant = "Le joueur 2 à gagné horizontalement"
elif self.grille[1][0]=='O' and self.grille[1][1] == 'O' and self.grille[1][2] == 'O':
finpartie=True
self.joueurgagnant = "Le joueur 2 à gagné horizontalement"
elif self.grille[2][0] == 'O' and self.grille[2][1] == 'O' and self.grille[2][2] == 'O':
finpartie=True
self.joueurgagnant = "Le joueur 2 à gagné horizontalement"
elif self.grille[0][0]=='O' and self.grille[1][0] =='O' and self.grille[2][0] == 'O':
finpartie=True
self.joueurgagnant = "Le joueur 2 à gagné verticalement"
elif self.grille[0][2] == 'O' and self.grille[1][2] =='O' and self.grille[2][2] == 'O':
finpartie=True
self.joueurgagnant = "Le joueur 2 à gagné verticalement"
elif self.grille[0][1] == 'O' and self.grille[1][1] =='O' and self.grille[2][1] == 'O':
finpartie=True
self.joueurgagnant = "Le joueur 2 à gagné verticalement"
elif self.grille[0][0] == 'O' and self.grille[1][1] =='O' and self.grille[2][2] == 'O':
finpartie=True
self.joueurgagnant = "Le joueur 2 à gagné en diagonale"
elif self.grille[0][2] == 'O' and self.grille[2][2] == 'O' and self.grille[2][0] == 'O':
finpartie=True
self.joueurgagnant = "Le joueur 2 à gagné en diagonale"
elif self.grille[0][0] == 'X' and self.grille[0][1] == 'X' and self.grille[0][2] == 'X':
finpartie=True
self.joueurgagnant = "Le joueur 1 horizontalement"
elif self.grille[1][0] == 'X' and self.grille[1][1]=='X' and self.grille[1][2] == 'X':
finpartie=True
self.joueurgagnant = "Le joueur 1 horizontalement"
elif self.grille[2][0] == 'X' and self.grille[2][1] == 'X' and self.grille[2][2] == 'X':
finpartie=True
self.joueurgagnant = "Le joueur 1 horizontalement"
elif self.grille[0][0] == 'X' and self.grille[1][0] == 'X' and self.grille[2][0] == 'X':
finpartie=True
self.joueurgagnant = "Le joueur 1 à la verticale"
elif self.grille[0][2] == 'X' and self.grille[1][2] == 'X' and self.grille[2][2] == 'X':
finpartie=True
self.joueurgagnant = "Le joueur 1 à la verticale"
elif self.grille[0][1] == 'X' and self.grille[1][1] == 'X' and self.grille[2][1]=='X':
finpartie=True
self.joueurgagnant = "Le joueur 1 à la verticale"
elif self.grille[0][0] == 'X' and self.grille[1][1] == 'X' and self.grille[2][2] == 'X':
finpartie=True
self.joueurgagnant = "Le joueur 1 à gagné en diagonale"
elif self.grille[0][2] == 'X' and self.grille[2][2] == 'X' and self.grille[2][0] == 'X':
finpartie=True
self.joueurgagnant = "Le joueur 1 à gagné en diagonale"
else:
finpartie=False
return finpartie
def VérifierFinPartie(self):
if self.compteurCoupJoue == 9: # Vérifie si tous les coups ont été joué
self.gagnant = True
else:
self.gagnant = self.gagnant
if self.gagnant == True:
return self.joueurgagnant
class Jeu:
michel = Joueur()
croupier1 = Croupier()
jeu1 = JeuDeCarte()
jeu2 = JeuDeCarte()
# fenetre = Tk()
# fenetre.title("BlackJack")
# fenetre.minsize(640,480)
# fenetre.geometry("640x480+300+150")
# for i in jeu1 :
# print(i)
# print(len(jeu1.instances))
# for i in jeu2:
# print(i)
# print(len(jeu2.instances))
#verification singleton
# print(jeu1)
# print(jeu2)
def main(self, Joueur, Croupier, JeuDeCarte):
k = self.jeu1.getJdc()
i = 0
joueur = {}
croupier = {}
while i < 2:
e = random.choice(list(k.items()))
k.pop(e[0])
joueur[e[0]] = e[1]
e = random.choice(list(k.items()))
k.pop(e[0])
croupier[e[0]] = e[1]
i = i + 1
self.michel.setMain(joueur)
self.croupier1.setMain(croupier)
return joueur, croupier, k
def total_main(self, main):
total = 0
for key, val in main.items():
total += val
return total
def tirer_nouvelle_carte(self, main, reste_carte):
e = random.choice(list(reste_carte.items()))
reste_carte.pop(e[0])
main[e[0]] = e[1]
return main
def affiche_mains_points(self, main_j, main_c):
print("\n")
print('main joueur: ', main_j)
print('main croupier: ', main_c)
print('total joueur : ', self.total_main(main_j))
print('total croupier : ', self.total_main(main_c))
print('\n')
# label3 = Label(self.fenetre,text=str(main_j))
# label4 = Label(self.fenetre,text=str(main_c))
# label5 = Label(self.fenetre,text=str(self.total_main(main_j)))
# label6 = Label(self.fenetre,text=str(self.total_main(main_c)))
# label3.pack()
# label4.pack()
# label5.pack()
# label6.pack()
def ass(self, main, total):
for i, j in main.items():
if j == 11 and total > 21:
main[i] = 1
return main
def blackjack(self, main, total):
if len(main) == 2 and total == 21:
return True
def jeu(self):
replay = 'o'
while replay == 'o':
mn = self.main(self.michel, self.croupier1, self.jeu1)
reste_carte = mn[2]
# label0 = Label(self.fenetre, text="Tirage : ")
# label0.pack()
# label1 = Label(self.fenetre,text=str(mn[0]))
# label1.pack()
print('main joueur : ', mn[0])
total_joueur = self.total_main(mn[0])
total_croupier = self.total_main(mn[1])
nouvellecarte = 'o'
main_j = mn[0]
main_c = mn[1]
a = self.blackjack(main_j, total_joueur)
b = self.blackjack(main_c, total_croupier)
if a:
print('Bravo BlackJack !!!!!!!')
self.affiche_mains_points(main_j, main_c)
elif b:
print('Courtier : BlackJack !!!!!!!')
self.affiche_mains_points(main_j, main_c)
else:
while total_croupier < 17 or total_joueur < 21 or nouvellecarte == 'o':
if total_joueur < 21 or nouvellecarte == 'o':
# messagebox = messagebox.askyesno("voulez vous une carte (o/n) ?")
nouvellecarte = input("voulez vous une carte (o/n) ?")
# label2 = Label(fenetre,text = "voulez vous une carte (o/n) ?")
# label2.pack()
if nouvellecarte == 'o':
main_j = self.tirer_nouvelle_carte(
mn[0], reste_carte)
total_joueur = self.total_main(main_j)
main_j = self.ass(main_j, total_joueur)
total_joueur = self.total_main(main_j)
if total_joueur >= 21:
nouvellecarte = 'n'
print(
'main joueur : ',
main_j,
)
print('\n')
else:
main_j = mn[0]
if total_croupier < 17:
main_c = self.tirer_nouvelle_carte(
mn[1], reste_carte)
total_croupier = self.total_main(main_c)
main_c = self.ass(main_c, total_croupier)
else:
main_c = mn[1]
if total_croupier >= 17 and nouvellecarte != 'o':
break
else:
break
self.affiche_mains_points(main_j, main_c)
#messagebox = messagebox.askyesno('Voulez vous rejouer ?')
#entrer2 = Entry(fenetre,text = 'voulez vous rejouer ? o/n',with = 1)
#entrer2.pack()
replay = input('voulez vous rejouer ? o/n')
