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 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, 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 Phase_Achat(Liste_Joueurs):
liste_trig_achat = list()
#On va faire nos achats dans un premier temps, les rendre effectifs dans un second temps, la on crée des mémoires
for num, Jou in enumerate.Liste_Joueurs:
#On énumère nos joueurs
print("c'est au joueur ")
print(num + 1)
#Ne pas oublier de montrer les cartes
A = input("voulez vous acheter des ressources ? 1 pour oui 0 pour non")
while A:
#La phase d'achat
O = input("D pour acheter à droite, G pour acheter à gauche")
Ress_Achat = dict(A.Ressources)
for Re in Ress_Achat.keys:
I = input("combien voulez vous acheter de " + Re)
Ress_Achat[Re] = I
#A ce moment, on a constitué notre répertoire de ressources à acheter
if O == 'D':
orientation = 'droite'
o = 1
if O == 'G':
orientation = 'gauche'
o = -1
Vendeur = Liste_Joueurs[num + o % len.Liste_Joueurs]
#Ici on différencie les cas droite et gauche
if J.ressource_achetable(Vendeur['Attribut'], Ress_Achat):
m = J.montant_a_payer(Jou['Attributs'], Ress_Achat,
orientation)
if m <= Jou['Attributs']['Ressources_Simples']['Or']:
Achat = dict(cel_achat)
Achat['id_joueur'] = num
Achat['montant'] = m
Achat['Ressources'] = Ress_Achat
Achat['orientation'] = o
liste_trig_achat.append(Achat)
#On stocke en mémoire les infos nécesaires pour trigger les achats
else:
print("vous n'avez pas d'or pour faire ça ...")
else:
print("le joueur n'a pas ces ressources")
A = input(
"voulez-vous acheter autre chose ? 1 pour oui 0 pour non")
for c_achat in liste_trig_achat:
J.trigger_achat_ressources(
Liste_Joueurs[c_achat['id_joueur']]['Attributs'],
Liste_Joueurs[c_achat['id_joueur'] + c_achat['orientation'] %
len.Liste_Joueurs]['Attributs'], c_achat['montant'],
c_achat['Ressources'])
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 __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)
class Jeu:
def __init__(self):
self.joueur1 = Joueur('Joueur')
self.turn = True
self.joueur2 = Joueur('Adversaire')
self.grille = Grille()
def start(self, listebateaux1, listebateau2):
print('test')
for i in range(len(listebateaux1)):
self.joueur1.addbateau(listebateaux1[i])
for i in range(len(listebateau2)):
self.joueur2.addbateau(listebateau2[i])
for i in range(len(self.joueur1.listeBateau) - 1):
if (self.joueur1.listeBateau[i].getOrientation() == False):
for j in range(self.joueur1.listeBateau[i].getLongueur()):
self.grille.set(Grille.UNDAMAGED_BOAT, int(self.joueur1.listeBateau[i].getCoordonneex() + j),
int(self.joueur1.listeBateau[i].getCoordonneey()))
elif(self.joueur1.listeBateau[i].getOrientation() == True):
for k in range(self.joueur1.listeBateau[i].getLongueur()):
self.grille.set(Grille.UNDAMAGED_BOAT, int(self.joueur1.listeBateau[i].getCoordonneex()),
int(self.joueur1.listeBateau[i].getCoordonneey()) + k)
print('fin start')
self.play()
def play(self):
pass
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_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
class partieBataille:
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 distribuer(self):
while True:
self.__joueur1.ajouter(self.__jeuDeCarte.tirerCarte())
self.__joueur2.ajouter(self.__jeuDeCarte.tirerCarte())
tableauArchive = []
def bataille(self):
if len(self.__joueur1.paquet.cartes) > 1:
self.tableauArchive.append(self.__joueur1.tirer())
cJoueur1 = self.__joueur1.tirer()
else:
self.finPartie()
if len(self.__joueur2.paquet.cartes) > 1:
self.tableauArchive.append(self.__joueur2.tirer())
cJoueur2 = self.__joueur2.tirer()
else:
self.finPartie()
print(cJoueur1, 'CONTRE\r\n', cJoueur2)
if cJoueur1.valeur < cJoueur2.valeur:
self.tableauArchive.append(cJoueur1)
self.tableauArchive.append(cJoueur2)
self.__joueur2.victoires += 1
self.__joueur1.defaites += 1
print(self.__joueur2.prenom,
' gagne et récupère les cartes dans son paquet !')
for i in range(len(self.tableauArchive)):
self.__joueur2.ajouter(self.tableauArchive.pop(0))
self.main()
elif cJoueur1.valeur > cJoueur2.valeur:
self.tableauArchive.append(cJoueur1)
self.tableauArchive.append(cJoueur2)
self.__joueur1.victoires += 1
self.__joueur2.defaites += 1
print(self.__joueur1.prenom,
' gagne et récupère les cartes dans son paquet !')
for i in range(len(self.tableauArchive)):
self.__joueur1.ajouter(self.tableauArchive.pop(0))
self.main()
else:
print("BATAAAAAAAAAILLE !!!")
self.bataille()
def melanger(self):
jeuCarteClassique.melange(self.__jeuDeCarte)
def demarrerPartie(self):
try:
self.melanger()
self.distribuer()
except IndexError as err:
while True:
self.main()
def finPartie(self):
if self.__joueur1.defaites < self.__joueur2.defaites:
print(self.__joueur1.prenom, 'a gagné cette partie!')
elif self.__joueur2.defaites < self.__joueur1.defaites:
print(self.__joueur2.prenom, 'a gagné cette partie!')
else:
print("Egalité, chose rare dans la bataille.")
exit(1)
restart = input(
"Tape 1 pour rejouer ! Sinon tape n'importe quelle touche !")
if restart == 1:
self.demarrerPartie()
else:
exit(1)
def main(self):
while len(self.__joueur1.paquet.cartes) != 0 or len(
self.__joueur2.paquet.cartes) != 0:
if len(self.__joueur1.paquet.cartes) != 0:
cJoueur1 = self.__joueur1.tirer()
else:
self.finPartie()
if len(self.__joueur2.paquet.cartes) != 0:
cJoueur2 = self.__joueur2.tirer()
else:
self.finPartie()
print(cJoueur1, '\r CONTRE\n\r', cJoueur2, '\r ')
if cJoueur1.valeur < cJoueur2.valeur:
self.__joueur2.ajouter(cJoueur1)
self.__joueur2.ajouter(cJoueur2)
self.__joueur2.victoires += 1
self.__joueur1.defaites += 1
print(self.__joueur2.prenom,
'gagne et récupère les cartes dans son paquet !')
print(len(self.__joueur1.paquet.cartes))
print(len(self.__joueur2.paquet.cartes))
elif cJoueur1.valeur > cJoueur2.valeur:
self.__joueur1.ajouter(cJoueur1)
self.__joueur1.ajouter(cJoueur2)
self.__joueur1.victoires += 1
self.__joueur2.defaites += 1
print(self.__joueur1.prenom,
'gagne et récupère les cartes dans son paquet !')
print(len(self.__joueur1.paquet.cartes))
print(len(self.__joueur2.paquet.cartes))
else:
print("BATAAAAAAAAAILLE !!!")
self.bataille()
nextRound = input("")
if nextRound == "1":
self.finPartie()
else:
if self.__joueur1.paquet.cartes == 0 or self.__joueur2.paquet.cartes == 0:
exit(1)
print("gyjugjvfgh")
self.finPartie()
# GETSETTEUR SPACE ! Yoloooo
def __getJoueur1(self):
return self.__joueur1
def __setJoueur1(self, joueur1):
self.__joueur1 = joueur1
joueur1 = property(__getJoueur1, __setJoueur1)
def __getJoueur2(self):
return self.__joueur2
def __setJoueur2(self, joueur2):
self.__joueur2 = joueur2
joueur2 = property(__getJoueur2, __setJoueur2)
def __getJeuDeCarte(self):
return self.__jeuDeCarte
def __setJeuDeCarte(self, jeuDeCarte):
self.__jeuDeCarte = jeuDeCarte
jeuDeCarte = property(__getJeuDeCarte, __setJeuDeCarte)
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')
import sys
sys.path.insert(1, '/home/tek/Desktop/7wonders/7wonders')
import Joueur.Joueur as J
import attribut.attributs as A
import carte.carte as C
import Wonder.wonder as W
Joueur1 = dict(J.Joueur)
Joueur2 = dict(J.Joueur)
Joueur3 = dict(J.Joueur)
merveille = W.wonder
Joueur1 = J.Init_Joueur(merveille)
Joueur2 = J.Init_Joueur(merveille)
Joueur3 = J.Init_Joueur(merveille)
#Joueur1['attributs']['Ressources_s']['Bois'] = 1
#Joueur1['attributs']= attribut.attributs.init_attribut()
#Joueur2['attributs']= attribut.attributs.init_attribut()
#Joueur3['attributs']= attribut.attributs.init_attribut()
karte = dict(C.carte)
cout_k = "Pierre 1"
karte['nom'] = "Bains"
karte['couleur'] = 'b'
karte['id'] = 3
if karte['pre'](Joueur1['attributs'], cout_k, 3, Joueur1['attributs']['liste_id'], 0):
karte['post']("Nbr_PV 3", Joueur1['attributs'])
Joueur1['attributs']['liste_id'].append(karte['id'])
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:]
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()
class PartieUno:
Defausse = []
cartesValides = []
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()
def demarrerPartie(self):
self.__melanger()
self.__distribuer()
self.__premiereCarte()
poursuivre = True
Tour = 1
while poursuivre:
if Tour == 1:
poursuivre = self.__tour(self.__joueur, self.Defausse)
Tour += 1
elif Tour == 2:
poursuivre = self.__tour(self.__ordinateur1, self.Defausse)
Tour += 1
elif Tour == 3:
poursuivre = self.__tour(self.__ordinateur2, self.Defausse)
Tour += 1
elif Tour == 4:
poursuivre = self.__tour(self.__ordinateur3, self.Defausse)
Tour += 1
else:
Tour =1
def __melanger(self):
self.__jeu.melanger()
def __distribuer(self):
for i in range(7):
self.__joueur.ajouterCarte(self.__jeu.tirer())
self.__ordinateur1.ajouterCarte(self.__jeu.tirer())
self.__ordinateur2.ajouterCarte(self.__jeu.tirer())
self.__ordinateur3.ajouterCarte(self.__jeu.tirer())
def __premiereCarte(self):
Defausse = self.Defausse
Defausse.append(self.__jeu.cartes[0])
self.__jeu.cartes.pop(0)
while Defausse[0].value == 4:
Defausse.insert(0, self.__jeu.cartes[0])
self.__jeu.cartes.pop(0)
print('La première carte est :' + str(Defausse[0]))
self.Defausse = Defausse
def __main(self, joueur):
return True
def finPartie(self, perdant1, perdant2, perdant3, gagnant):
perdant1.defaites += 1
perdant2.defaites += 1
perdant3.defaites += 1
gagnant.victoires += 1
print('{} {} a gagné!'.format(gagnant.prenom, gagnant.nom))
def __validation(self, carteJouee, carteJoueur):
if carteJoueur.value != carteJouee.value:
if carteJoueur.color != carteJouee.color:
if carteJoueur.color != 4:
return False
carteJoueur
return True
def __tour(self, joueur, jeu):
print("La carte en jeu est :" + str(jeu[0]))
if jeu[0].value > 14:
return True
else:
mainJoueur = joueur.paquet.cartes
if len(mainJoueur) > 0:
for i in range(len(mainJoueur)):
if self.__validation(mainJoueur[i], jeu[0]):
self.cartesValides.insert(0, mainJoueur[i])
print("Au tour de : {} {}".format(joueur.prenom, joueur.nom))
print("Vos cartes sont : " + str(mainJoueur) + " ")
if len(self.cartesValides) > 0:
print("Les cartes que vous pouvez jouer sont :" + str(self.cartesValides))
self.Defausse.insert(0, self.cartesValides[0])
self.cartesValides.pop(0)
else:
print("Vous ne pouvez pas jouer, vous piochez une carte")
joueur.ajouterCarte(self.__jeu.tirer(True))
if len(mainJoueur) > 0:
return True
return False
def __carteEnMain(self):
global carteEnMain
carteEnMain = Joueur.paquet()
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()
from PartieBataille import PartieBataille
from Joueur import Joueur
if __name__ == '__main__':
joueur_1 = Joueur('Lagaffe', 'Gaston')
jeu = PartieBataille(joueur_1)
jeu.demarrerPartie()
# Placement barre
barreG = Barre(Coordonnees(ESPACE_BARRE, YBARRE), VBARRE, LONGUEUR_BARRE, LARGEUR_BARRE, Direction.HAUT)
barreD = Barre(
Coordonnees(LONGUEUR_ECRAN - ESPACE_BARRE - LARGEUR_BARRE, YBARRE),
VBARRE,
LONGUEUR_BARRE,
LARGEUR_BARRE,
Direction.HAUT,
)
# Placement balle
balle = Balle(Coordonnees(0, 0), coteBalle, 0, 0, VBALLE, COTE_BALLE)
lancementAleaBalle(balle)
# creation des joueurs
joueurG = Joueur(barreG, 0, Cote.GAUCHE)
joueurD = Joueur(barreD, 0, Cote.DROIT)
while continuerJeu:
afficherElements(Statut.JEU_EN_COURS, X_SCOREG, X_SCORED, Y_SCORE)
gererCollisionBarreBord()
gererEvenements()
# deplacement balle
if balle.estSortie(LONGUEUR_ECRAN) != 0: # balle non sortie
# gestion score
joueurD.marquerPoint(balle.estSortie(LONGUEUR_ECRAN))
joueurG.marquerPoint(balle.estSortie(LONGUEUR_ECRAN))
if joueurD.getScore() == MAX_POINT:
afficherVictoire(imageVictoireDroit, joueurG.getScore())
time.sleep(3)
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()
class PartieBataille:
def __init__(self, joueur):
self.__joueur = joueur
self.__ordinateur = Joueur('9000', 'HAL')
self.__jeu = JeuClassique()
def demarrerPartie(self):
self.__melanger()
self.__distribuer()
poursuivre = True
while poursuivre:
poursuivre = self.__main()
def __melanger(self):
self.__jeu.melanger()
def __distribuer(self):
for i in range(len(self.__jeu.cartes)):
carte = self.__jeu.tirer()
if i % 2 == 0:
self.__joueur.ajouterCarte(carte)
else:
self.__ordinateur.ajouterCarte(carte)
def __main(self, reste=[]):
carte_joueur = self.__joueur.tirerCarte(True)
carte_ordinateur = self.__ordinateur.tirerCarte()
if carte_joueur is None:
self.finPartie(self.__joueur, self.__ordinateur)
return False
elif carte_ordinateur is None:
self.finPartie(self.__ordinateur, self.__joueur)
return False
print("Main : ")
print(' -{} {} : {}'.format(self.__joueur.prenom, self.__joueur.nom,
str(carte_joueur)))
print(' -{} {} : {}'.format(self.__ordinateur.prenom,
self.__ordinateur.nom,
str(carte_ordinateur)))
if carte_joueur.value == carte_ordinateur.value:
reste.append(carte_joueur)
reste.append(carte_ordinateur)
return self.__bataille(reste)
elif carte_joueur.value > carte_ordinateur.value:
self.__joueur.ajouterCarte(carte_joueur)
self.__joueur.ajouterCarte(carte_ordinateur)
print(' -{} {} gagne la main'.format(self.__joueur.prenom,
self.__joueur.nom))
else:
self.__ordinateur.ajouterCarte(carte_ordinateur)
self.__ordinateur.ajouterCarte(carte_joueur)
print(' -{} {} gagne la main'.format(self.__ordinateur.prenom,
self.__ordinateur.nom))
return True
def __bataille(self, reste):
print('*** BATAILLE ***')
return self.__main(reste)
def finPartie(self, perdant, gagnant):
perdant.defaites += 1
gagnant.victoires += 1
print('{} {} a gagné!'.format(gagnant.prenom, gagnant.nom))
a afficher. exemple : la view doit afficher la grille d'un joueur, si la grille du joueur dans la model
est egal a -1, cela veux dire qu'il y avait un bateau a cette endroit mais qu'il a deja ete toucher.
aller voir dans grille pour les autres valeurs
"""
def __init__(self):
self.model = Model()
self.view = View(self.model)
self.controller = Controller(self.model, self.view)
if __name__ == "__main__":
"""
Les lignes qui suivent representent une boucle de jeu fonctionnel, il va falloir l'adapter pour que les inputs
soit sur l'interface graphique
"""
#initialisation des joueurs et de la liste de joueurs
j = Joueur('Jeff')
g = Joueur('Gab')
listJoueur = []
listJoueur.append(j)
listJoueur.append(g)
turn = 0
#la boucle qui dit: tant que les 2 joueurs de sont pas mort
while(not(j.isDead()) and not(g.isDead())):
#si c'est le premier tour, les joueurs place leur bateau
if turn == 0:
for j in listJoueur:
j.placerBateau
turn += 1
else:
#maintenent que les bateau sont placer, les joueurs doivent ecrire une posisiont en x et y a attaquer
for j in range(len(listJoueur)):
def __init__(self):
self.joueur1 = Joueur('Joueur')
self.turn = True
self.joueur2 = Joueur('Adversaire')
self.grille = Grille()
def __init__(self, joueur):
self.__joueur = joueur
self.__ordinateur = Joueur('9000', 'HAL')
self.__jeu = JeuClassique()
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
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()
class PartieBataille:
cJ1 = []
cJ2 = []
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 distribuer(self):
while True:
self.__J1.ajouter(self.__jeuDeCartes.tirer())
self.__J2.ajouter(self.__jeuDeCartes.tirer())
def melanger(self):
self.__jeuDeCartes.melanger()
def demarrerPartie(self):
try:
self.melanger()
self.distribuer()
except IndexError as err:
print(err)
while True:
self.main()
def bataille(self):
c2J1 = self.__J1.tirer()
c2J2 = self.__J2.tirer()
c3J1 = self.__J1.tirer()
c3J2 = self.__J2.tirer()
print(c3J1, "\r vs ", c3J2, "\r")
if c3J1.valeur < c3J2.valeur:
self.__J2.ajouter(c3J1)
self.__J2.ajouter(c3J2)
self.__J2.ajouter(c2J1)
self.__J2.ajouter(c2J2)
print(self.__J2.nom, self.__J2.prenom,
" gagne la bataille et récupère les cartes\n")
self.__J2.victoire += 1
self.__J1.defaite += 1
for i in range(len(self.cJ2)):
self.__J2.ajouter(self.cJ2.pop(0))
self.__J2.ajouter(self.cJ1.pop(0))
print("Nombres cartes Joueur 1 : ", len(self.__J1.paquet.cartes))
print("Nombres cartes Joueur 2 : ", len(self.__J2.paquet.cartes))
input("next\n")
self.main()
elif c3J1.valeur > c3J2.valeur:
self.__J1.ajouter(c3J1)
self.__J1.ajouter(c3J2)
self.__J1.ajouter(c2J1)
self.__J1.ajouter(c2J2)
print(self.__J1.nom, self.__J1.prenom,
" gagne la bataille et récupère les cartes\n")
self.__J1.victoire += 1
self.__J2.defaite += 1
for i in range(len(self.cJ2)):
self.__J1.ajouter(self.cJ2.pop(0))
self.__J1.ajouter(self.cJ1.pop(0))
print("Nombres cartes Joueur 1 : ", len(self.__J1.paquet.cartes))
print("Nombres cartes Joueur 2 : ", len(self.__J2.paquet.cartes))
input("next\n")
self.main()
else:
print("Bataille\n")
self.cJ1.append(c2J1)
self.cJ1.append(c3J1)
self.cJ2.append(c2J2)
self.cJ1.append(c3J2)
self.bataille()
def finPartie(self):
ScoreVJ1 = self.__J1.victoire
ScoreVJ2 = self.__J2.victoire
ScoreDJ1 = self.__J1.defaite
ScoreDJ2 = self.__J2.defaite
print("Le score de la partie est : ", ScoreVJ1, ScoreDJ1,
" pour le joueur 1\n", ScoreVJ2, ScoreDJ2, " pour le joueur 2\n")
exit(1)
def main(self):
while len(self.__J1.paquet.cartes) != 0 or len(
self.__J2.paquet.cartes) != 0:
if len(self.__J1.paquet.cartes) != 0:
cJ1 = self.__J1.tirer()
else:
print(self.__J1.nom, "a perdu")
self.finPartie()
if len(self.__J2.paquet.cartes) != 0:
cJ2 = self.__J2.tirer()
else:
print(self.__J2.nom, "a perdu")
self.finPartie()
print(cJ1, "\r vs ", cJ2, "\r ")
if cJ1.valeur < cJ2.valeur:
self.__J2.ajouter(cJ1)
self.__J2.ajouter(cJ2)
print(self.__J2.nom, self.__J2.prenom,
" gagne et récupère les cartes\n")
self.__J2.victoire += 1
self.__J1.defaite += 1
print("Nombres cartes Joueur 1 : ",
len(self.__J1.paquet.cartes))
print("Nombres cartes Joueur 2 : ",
len(self.__J2.paquet.cartes))
elif cJ1.valeur > cJ2.valeur:
self.__J1.ajouter(cJ1)
self.__J1.ajouter(cJ2)
print(self.__J1.nom, self.__J1.prenom,
" gagne et récupère les cartes\n")
self.__J1.victoire += 1
self.__J2.defaite += 1
print("Nombres cartes Joueur 1 : ",
len(self.__J1.paquet.cartes))
print("Nombres cartes Joueur 2 : ",
len(self.__J2.paquet.cartes))
else:
print("Bataille\n")
self.bataille()
input("next\n")
self.finPartie()
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(object):
"""
Classe décrivant les éléments necessaire pour que le jeu puisse se réaliser.
"""
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 clone(self):
clo = Jeu(self.joueur1.clone(), self.joueur2.clone())
clo.tour = self.tour
clo.plateau = Plateau(self.plateau)
return clo
def notation(self, j):
if j == 0:
rep = self.joueur1.nombreCapture - self.joueur2.nombreCapture
else:
rep = self.joueur2.nombreCapture - self.joueur1.nombreCapture
return self.plateau.notation(j) + rep * 20
def jouerAuto(self):
j = self.tour % 2
if j == 0:
if self.joueur1.isIA:
self.joueur1.play(self)
else:
rep = input("Jouer entre 0 et 6 ")
self.jouer(int(rep))
else:
if self.joueur2.isIA:
self.joueur2.play(self)
else:
rep = input("Jouer entre 0 et 6 ")
self.jouer(int(rep) + 6)
def jouer(self, i):
"""
cette méthode permet de vérifier si le tour est possible ou pas
car on est obligé de nourir l'adversaire quand toute ces cases sont vides, au
contraire on joue de façon qui nous sera favorable
j joueur
i est la case où le jouer commence le jeu et i allant de (0,5)
nou_i designe la case de l'adversaire, la case où les graines doivent être distribuées
"""
j = (self.tour) % 2
if j == 0:
joueur = self.joueur1
nou_i = i
j2 = 1
if self.plateau.cases[nou_i].graines == 0:
print("ce coup n'est pas valide" + str(nou_i) + " " +
str(self.tour) + " " + str(j))
return 0
if self.plateau.verifie(j2) == False:
if i + self.plateau.cases[i].graines > 5:
#print("le tour est valide")
self.plateau.jouer(nou_i, joueur)
self.tour = self.tour + 1
#self.plateau.printC()
# print(self.tour)
else:
print("ce coup n'est pas valide faite jouer l'adversaire")
else:
nou_i = i
self.plateau.jouer(nou_i, joueur)
self.tour = self.tour + 1
#self.plateau.printC()
else:
joueur = self.joueur2
j2 = 0
nou_i = i
if self.plateau.cases[nou_i].graines == 0:
print("ce coup n'est pas valide 2")
return 0
if self.plateau.verifie(j2) == False:
if i + self.plateau.cases[nou_i].graines > 5:
#print("le tour est valide")
self.plateau.jouer(nou_i, joueur)
self.tour = self.tour + 1
#self.plateau.printC()
# print(self.tour)
else:
print("ce coup n'est pas valide fait jouer l'adversaire")
#self.plateau.printC()
# print(self.tour)
else:
self.plateau.jouer(nou_i, joueur)
self.tour = self.tour + 1
#self.plateau.printC()
#print(self.tour)
self.verify()
def printC(self):
print(self.tour)
print(self.joueur1.nom + " : " + str(self.joueur1.nombreCapture) +
" | " + self.joueur2.nom + " : " +
str(self.joueur2.nombreCapture))
self.plateau.printC()
def verifiewin(self, j):
"""
cette méthode affiche le nom du joueur qui a gagné en donnant la
totalité de ces points.
"""
if j == 0:
j2 = 1
if self.joueur1.nombreCapture >= 25:
print("le joueur" + joueur1.nom + "a gagne la partie avec" +
self.joueur1.nombreCapture + "points")
return True
if self.plateau.verifie(j2) == False:
for i in range(0, 6):
nbAux = self.plateau.cases[i].graines
k = i + 1
while nbAux > 0:
if self.plateau.cases[k].graines != 12:
nbAux = nbAux - 1
k = k + 1
if k >= 12:
k = 0
if k == 0:
arrive = 11
else:
arrive = k - 1
if arrive > 5:
print("le joueur" + joueur1.nom + "a gagne")
return False
return self.joueur1.nombreCapture >= self.joueur2.nombreCapture
else:
#print("continuer la partie")
return False
if j == 1:
j2 = 0
if self.joueur2.nombreCapture > 25:
print("le joueur" + joueur2.nom + "a gagne la partie avec" +
self.joueur2.nombreCapture + "points")
return True
if self.plateau.verifie(j2) == False:
for i in range(6, 12):
nbAux = self.plateau.cases[i].graines
k = i + 1
while nbAux > 0:
if self.plateau.cases[k].graines != 12:
nbAux = nbAux - 1
k = k + 1
if k >= 12:
k = 0
if k == 0:
arrive = 11
else:
arrive = k - 1
if arrive >= 0:
print("le joueur" + joueur2.nom + "a gagne")
return False
return self.joueur2.nombreCapture >= self.joueur1.nombreCapture
else:
#print("continuer la partie")
return False
return False
def verify(self):
"""
cette méthode permet de vérifier si le jeu est toujours possible
"""
if self.verifiewin(0):
return True
if self.verifiewin(1):
return True
return False
def printG(self, myfont, screen):
self.plateau.printCases(myfont, screen)
label = myfont.render(
str(self.joueur1.nom) + " a " + str(self.joueur1.nombreCapture) +
" points", 6, (255, 255, 255))
screen.blit(label, ((177, 64)))
label = myfont.render(
str(self.joueur2.nom) + " a " + str(self.joueur2.nombreCapture) +
" points", 6, (255, 255, 255))
screen.blit(label, ((177, 630)))
def mouseChech(self, i, j):
print(str(i) + " " + str(j))
if self.tour % 2 == 0:
for k in range(6):
if self.isInCarre(i, j, 110 + 150 + 130 * k, 87 + 150):
self.jouer(k)
else:
for k in range(6):
if self.isInCarre(i, j, 110 + 150 + 130 * k, 87 + 150 + 170):
self.jouer(11 - k)
def isInCarre(self, i, j, x, y):
h = 93
l = 93
return i >= x and j >= y and i <= x + l and j <= h + y