You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
175 lines
7.0 KiB
175 lines
7.0 KiB
"""
|
|
Commentaires :
|
|
==============
|
|
Il n'y a pas de fichier README.
|
|
Message des commits peu explicites !
|
|
Partie classes:
|
|
---------------
|
|
Mélange entre commentaires et documentation.
|
|
Pourquoi avoir des valeurs entre 0 et 12 plutôt que 1 et 13 ????
|
|
Quel est l'intéret du get ??
|
|
Le constructeur de Jeu est censé prendre le nombre de cartes en paramètre, et
|
|
créer le jeu de carte.
|
|
Dans un jeu de 32, les cartes ne vont pas de 1 à 8 !!
|
|
Le nom des joueurs, et la partie elle-même n'ont pas à faire partie de la classe
|
|
Jeu, qui est juste censée gérer le jeu de cartes.
|
|
Des mélanges entre f-string et méthode format.
|
|
Erreur sur le cas d'égalité (vous avez mis 2 fois f1). De plus, le seul cas où
|
|
il pourrait y avoir égalité est le cas ou aucun joueur n'a de carte. Si il en
|
|
reste au moins une à l'autre, alors il a gagné!
|
|
Utilisation de while True avec des break maladroite et peu lisible ici.
|
|
La gestion des "batailles" ne fonctionne pas : vous réinitialisez le "pot" à
|
|
chaque fois au lieu d'ajouter des cartes.
|
|
Affichage de la partie peu compréhensible : il aurait été bien d'exliquer ce qui
|
|
est affiché...
|
|
|
|
Partie Tkinter :
|
|
----------------
|
|
Inutile d'utiliser des variables globales pour les noms : ils sont dans les
|
|
labels. Et on retrouve que les noms n'ont rien à faire comme attributs du Jeu.
|
|
On ne peut pas choisir le nombre de cartes.
|
|
Même remarques sur les cas d'égalité.
|
|
L'affichage n'est pas cohérent en cas de "bataille" multiple.
|
|
Il aurait été bien de prévoir un bouton pour aller jusqu'à la fin de la partie.
|
|
|
|
Note finale : 14
|
|
"""
|
|
|
|
from File import File_chaine as File # importation de la classe File_chaine pour représenter les paquets
|
|
from random import shuffle # importation de shuffle pour mélanger le paquet
|
|
|
|
class Carte:
|
|
def __init__(self, valeur, couleur):
|
|
# initialise une carte avec une valeur et une couleur
|
|
self.valeur = valeur
|
|
self.couleur = couleur
|
|
|
|
def compare(self, autre):
|
|
# compare la carte actuelle avec une autre carte
|
|
# retourne 1 si self > autre, -1 si self < autre et 0 si elles sont égal
|
|
if self.valeur > autre.valeur:
|
|
return 1
|
|
elif self.valeur < autre.valeur:
|
|
return -1
|
|
else:
|
|
return 0
|
|
|
|
def __str__(self):
|
|
# On définit la correspondance entre valeur (0-12) et nom
|
|
noms = {
|
|
0: "As", 1: "2", 2: "3", 3: "4", 4: "5",
|
|
5: "6", 6: "7", 7: "8", 8: "9",
|
|
9: "10", 10: "Valet", 11: "Dame", 12: "Roi"
|
|
}
|
|
# On récupère le nom correspondant à la valeur
|
|
nom_carte = noms.get(self.valeur, str(self.valeur))
|
|
return nom_carte + " de " + self.couleur
|
|
|
|
|
|
class Jeu:
|
|
def __init__(self, nom1="joueur1", nom2="joueur 2"):
|
|
# initialise un jeu
|
|
self.paquet = [] # liste contenant toutes les cartes
|
|
self.f1 = None # file du joueur 1
|
|
self.f2 = None # file du joueur 2
|
|
self.nom1 = nom1 # nom du joueur 1
|
|
self.nom2 = nom2 # nom du joueur 2
|
|
|
|
def distribue(self, nb_total_cartes):
|
|
# distribue les cartes entre les deux joueurs
|
|
self.paquet = [] # réinitialisation du paquet
|
|
self.f1 = File() # initialisation de la file du joueur 1
|
|
self.f2 = File() # initialisation de la file du joueur 2
|
|
|
|
couleurs = ["♠", "♦", "♥", "♣"] # Couleurs des cartes
|
|
|
|
nombre = nb_total_cartes // 4 # Nombre de cartes par couleur
|
|
|
|
# création du paquet complet
|
|
for valeur in range(nombre):
|
|
for couleur in couleurs:
|
|
self.paquet.append(Carte(valeur, couleur))
|
|
|
|
shuffle(self.paquet) # mélange du paquet
|
|
|
|
# distribue la moitié def cartes pour f1
|
|
for i in range(nombre * 2):
|
|
self.f1.enfiler(self.paquet[i])
|
|
|
|
# et l'autre moitié pour f2
|
|
for i in range(nombre * 2, nombre * 4):
|
|
self.f2.enfiler(self.paquet[i])
|
|
|
|
return self.f1, self.f2 # Retourne les deux files
|
|
|
|
def partie(self):
|
|
# lance la partie de bataille jusqu'à ce qu'un joueur gagne
|
|
while not self.f1.est_vide() and not self.f2.est_vide():
|
|
c1 = self.f1.defiler() # carte du joueur 1
|
|
c2 = self.f2.defiler() # carte du joueur 2
|
|
print(c1, c2, "\n")
|
|
|
|
if c1.compare(c2) == 1:
|
|
# joueur 1 gagne le tour et remet les cartes dans sa file
|
|
self.f1.enfiler(c1)
|
|
self.f1.enfiler(c2)
|
|
|
|
elif c1.compare(c2) == -1:
|
|
# joueur 2 gagne le tour et remet les cartes dans sa file
|
|
self.f2.enfiler(c1)
|
|
self.f2.enfiler(c2)
|
|
|
|
else:
|
|
# en cas d'égalité
|
|
while True:
|
|
pot = [c1, c2] # pot temporaire contenant les cartes en jeu
|
|
|
|
# vérifie si un joueur a assez de cartes pour continuer la bataille
|
|
if self.f1.taille() < 2 and self.f1.taille() < 2:
|
|
return "égalité"
|
|
elif self.f1.taille() < 2:
|
|
return "{} gagne ({} n'a pas assez de carte)".format(self.nom2, self.nom1)
|
|
elif self.f2.taille() < 2:
|
|
return "{} gagne ({} n'a pas assez de carte)".format(self.nom1, self.nom2)
|
|
|
|
# chaque joueur place une carte face cachée dans le pot
|
|
pot.append(self.f1.defiler())
|
|
pot.append(self.f2.defiler())
|
|
|
|
# chaque joueur place ensuite une carte face visible
|
|
c1 = self.f1.defiler()
|
|
c2 = self.f2.defiler()
|
|
print(c1, c2)
|
|
|
|
pot.extend([c1, c2]) # Ajoute ces cartes au pot
|
|
|
|
# vérifie qui gagne cette bataille
|
|
if c1.compare(c2) == 1:
|
|
for c in pot:
|
|
self.f1.enfiler(c)
|
|
break
|
|
|
|
elif c1.compare(c2) == -1:
|
|
for c in pot:
|
|
self.f2.enfiler(c)
|
|
break
|
|
|
|
# affiche l'état actuel des deux files
|
|
print(self.f1, "\n\n", self.f2, "\n")
|
|
|
|
# détermine le gagnant final
|
|
if self.f1.est_vide():
|
|
return "{} gagne".format(self.nom2)
|
|
else:
|
|
return "{} gagne".format(self.nom1)
|
|
|
|
if __name__ == "__main__":
|
|
nom1 = input("Nom du joueur 1 : ") # demande le nom du joueur 1
|
|
nom2 = input("Nom du joueur 2 : ") # demande le nom du joueur 2
|
|
nb_total_cartes = int(input("Nombre total de cartes dans le paquet : ")) # Nombre total de cartes
|
|
|
|
jeu = Jeu(nom1, nom2) # création du jeu avec les noms des joueurs
|
|
f1, f2 = jeu.distribue(nb_total_cartes) # distribution des cartes
|
|
print(f"{nom1} :", f1) # affiche la file du joueur 1
|
|
print(f"{nom2} :", f2) # affiche la file du joueur 2
|
|
print(jeu.partie()) # lance la partie et affiche le résultat final
|
|
|