You are not logged in.
The forum to cure all your computer anxieties
Pages: 1
Coucou les camarades, j'ai continué mon projet de poker en python. J'ai décidé de créer un module avec toutes les fonctions de base du jeu. Je n'ai pas encore fini, mais pour l'instant ça donne ça:
'''
Module poker
fonctions de base du jeu
'''
import random as r
def chaine(chiffre:int) -> str:
'''
convertit un nombre en JQKA et en str.
'''
INT_TO_STR:dict = {11:'J' , 12:'Q' , 13:'K' , 14:'A'}
if chiffre > 10:
lettre:str = INT_TO_STR[chiffre]
else:
lettre:str = str(chiffre)
return lettre
def entier(lettre:str) -> int:
'''
convertit un nombre en str vers un entier. Permet d'obtenir 11 12 13 14 à partir de JQKA
'''
STR_TO_INT:dict = {'J':11 , 'Q':12 , 'K':13 , 'A':14}
if lettre.isnumeric():
chiffre:int = int(lettre)
else:
chiffre:int = STR_TO_INT[lettre]
return chiffre
def jeuCartes() -> list:
'''
Cree un jeu de 52 cartes
'''
SYMBOLES:list = ["♠","♥","♣","♦"]
jeu:list = []
for s in SYMBOLES:
for c in range (2 , 15):
c = chaine(c)
jeu.append([s , c])
return jeu
def pioche(jeu:list , tirs:int):
'''
Met un nombre donne de carte d'un jeu donné dans une liste et retire les cartes du jeu
'''
carte_piochees:list = []
for t in range (tirs):
numero_carte:int = r.randint(1,len(jeu)-1)
carte:list = jeu[numero_carte]
carte_piochees.append(carte)
del(jeu[numero_carte])
return jeu , carte_piochees
def mainChiffre(main:list) ->list:
'''
renvoie uniquement les chiffres d'une main
'''
liste:list = []
for i in main:
c = entier(i[1])
liste.append(c)
return liste
def hauteur(main:list) -> int:
main_chiffre = mainChiffre(main)
return max(main_chiffre)
def triMain(main:list) ->list:
'''
Trie les mains de façon à donner les cartes plus faibles d'abord
'''
chiffres:list = mainChiffre(main)
chiffres.sort()
main_triee:list = []
for c in chiffres:
for carte in main:
index:int = main.index(carte)
if entier(carte[1]) == c:
main_triee.append(carte)
del main[index]
return main_triee
def estFlush(main:list) -> bool:
"""
Renvoie True si on a une couleur
"""
flush:bool = True
compteur:int = 0
while flush and (compteur < len(main) - 1):
flush = main[compteur][0] == main[compteur + 1][0]
compteur += 1
return flush
def estQuinte(main:list) -> bool:
"""
Retourne True si la main est une suite
"""
main = triMain(main)
compteur:int = 0
quinte:bool = True
while quinte and (compteur < len(main) - 1):
quinte = (entier(main[compteur][1]) + 1) == (entier(main[compteur + 1][1]))
compteur += 1
return quinte
def estQuinteFlush(main:list) -> bool:
"""
"""
return estQuinte(main) and estFlush(main)
def estQuinteFlushRoyale(main):
main2 = main.copy()
print(main2)
return estQuinteFlush(main) and (hauteur(main2) == 14)
def listePaires(main:list) -> list:
liste = [0,0,0,0,0]
l = len(main)
for k in range(l):
carte = main[k][1]
for i in range(l):
c = main[i][1]
if carte == c:
liste[i] += 1
return liste
def estCarre(main):
liste_paires = listePaires(main)
est_carre = 4 in liste_paires
if est_carre:
carre = entier(main[liste_paires.index(4)][1])
else:
carre = 0
return carre
def estBrelan(main):
liste_paires = listePaires(main)
est_brelan = 3 in liste_paires
if est_brelan:
brelan = entier(main[liste_paires.index(3)][1])
else:
brelan = 0
return brelan
def estPaire(main):
liste_paires = listePaires(main)
nb_paires = liste_paires.count(2)
les_paires = []
if nb_paires >= 2:
les_paires.append(entier(main[liste_paires.index(2)][1]))
if nb_paires == 4:
for c in liste_paires:
n = entier(main[liste_paires][1])
if n not in les_paires and c == 2:
les_paires.append(n)
les_paires.sort()
return les_paires
def estFull(main):
return (len(estPaires(main)) == 1) and (estBrelan(main) > 0)
Je n'ai pas encore terminé ni beaucoup testé, mais j'ai un problème avec la fonction hauteur() et la fonction estQuinteFlushRoyale(). J'ai créé une main quinte flush royale pour faire un test. hauteur(main) donne bien 14, comme l'As, estQuinteFlush(main) renvoie True. cependant la fonction hauteur me donne une ValueError: max() arg is an empty sequence quand je l'appelle via la fonction estQuinteFlushRoyale(main). j'ai rajouté print(main) au début de la fonction hauteur, et la liste est bel et bien vide... La fonction mainChiffre() utilisée dans la fonction hauteur marche bien. J'ai essayé de faire main.copy() mais ce n'est pas mieux... Quelqu'un peut m'aider s'il vous plaît? Le fichier du module est sur mon gitlab si vous en avez besoin.
Offline
J'envisage également de créer une classe Joueur pour rendre le jeu jouable
Offline
J'ai corrigé mes quelques bugs, notamment celui de la hauteur. Il suffisait de travailler sur une copie de la liste en faisant
J'ai rajouté des fonctions pour évaluer les mains et les comparer entre elles. Je pense qu'une grosse partie du travail est faite, mais il me reste encore du travail, notamment rajouter une fonction pour donner le nom des combinaisons possédées et rendre le code plus lisible. Le code source est ici.
'''
Module poker
fonctions de base du jeu
'''
def chaine(chiffre:int) -> str:
'''
convertit un nombre en JQKA et en str.
chaine(13)
>>>'K'
'''
INT_TO_STR:dict = {11:'J' , 12:'Q' , 13:'K' , 14:'A'} #Dictionnaire contenant les corres entre les int et les str
if chiffre > 10: #S'il faut mettre une lettre à la place du chiffre
lettre:str = INT_TO_STR[chiffre] #On utilise le dictionnaire
else: #Sinon
lettre:str = str(chiffre) #On convertit simplement en chaîne de caractère
return lettre #On retourne la lettre
def entier(lettre:str) -> int:
'''
convertit un nombre en str vers un entier. Permet d'obtenir 11 12 13 14 à partir de JQKA
entier("J")
>>>11
'''
STR_TO_INT:dict = {'J':11 , 'Q':12 , 'K':13 , 'A':14} #Dictionnaire str vers int pour les lettres
if lettre.isnumeric(): #Si la lettre est un nombre
chiffre:int = int(lettre) #On convertit en entier
else: #Sinon -> Si c'est une lettre
chiffre:int = STR_TO_INT[lettre] #On prend l'équivalent dans le dictionnaire
return chiffre #On retourne le chiffre obtenu
def jeuCartes() -> list:
'''
Cree un jeu de 52 cartes
chaque carte est une liste [[symbole:str , nombre:str] , [symbole:str , nombre:str] ...]
Aucun paramètre
j = jeuCartes()
print(j[0])
>>>["♠","2"]
'''
symboles:list = ["♠","♥","♣","♦"] #Une liste des 4 symboles dans un jeu de cartes
jeu:list = [] #Pour l'instant le jeu est une liste vide
for s in symboles: #s prend les valeurs de chaque symbole
for c in range (2 , 15): #c prend les valeurs de 2 à 14 -> les chiffres d'un jeu
c:str = chaine(c) #on transforme le chiffre en chaîne de caractère avec la fonction
jeu.append([s , c]) #On ajoute dans le jeu une liste avec un symbole et un chiffre
return jeu #On retourne le jeu
def pioche(jeu:list , tirs:int):
'''
Met un nombre donne de carte d'un jeu donné dans une liste et retire les cartes du jeu
Les cartes tirées sont aléatoires
jeu , carte = pioche(jeuCartes() , 1)
print(carte)
>>>["♣" , "K"]
'''
from random import randint #On importe la fonction randint du module random
carte_piochees:list = [] #Une liste qui contiendra les cartes qui seront piochées
for t in range (tirs): #Répéter tirs fois
numero_carte:int = randint(1,len(jeu)-1) #Donner un nombre aléatoire qui correspondra à un index de cartes
carte:list = jeu[numero_carte] #Prendre la carte correspondante au numéro
carte_piochees.append(carte) #Ajouter la carte aux cartes piochées
del(jeu[numero_carte]) #Supprimer la carte du paquet
return (jeu , carte_piochees) #Renvoyer le jeu et les cartes
def mainChiffre(main:list) ->list:
'''
renvoie uniquement les chiffres d'une main
'''
liste:list = []
for i in list(main):
c = entier(i[1])
liste.append(c)
return liste
def listePaires(main:list) -> list:
liste = [0,0,0,0,0]
l = len(main)
main2 = list(main)
for k in range(l):
carte = main2[k][1]
for i in range(l):
c = main2[i][1]
if carte == c:
liste[i] += 1
return liste
def hauteur(main:list) -> int:
main2 = list(main)
liste_paires:list = listePaires(main2)
liste_1:list = []
for k in range(len(main2)):
if liste_paires[k] == 1:
liste_1.append(entier(main2[k][1]))
try:
return max(liste_1)
except ValueError:
return 0
def triMain(main:list) ->list:
'''
Trie les mains de façon à donner les cartes plus faibles d'abord
'''
main2 = list(main)
chiffres:list = mainChiffre(main2)
chiffres.sort()
main_triee:list = []
for c in chiffres:
for carte in main2:
index:int = main2.index(carte)
if entier(carte[1]) == c:
main_triee.append(carte)
del main2[index]
return main_triee
def estFlush(main:list) -> bool:
"""
Renvoie True si on a une couleur
"""
main2 = list(main)
flush:bool = True
compteur:int = 0
while flush and (compteur < len(main2) - 1):
flush = main2[compteur][0] == main2[compteur + 1][0]
compteur += 1
return flush
def estQuinte(main:list) -> bool:
"""
Retourne True si la main est une suite
"""
main2 = list(main)
main2 = triMain(main2)
compteur:int = 0
quinte:bool = True
while quinte and (compteur < len(main2) - 1):
quinte = (entier(main2[compteur][1]) + 1) == (entier(main2[compteur + 1][1]))
compteur += 1
return quinte
def estQuinteFlush(main:list) -> bool:
"""
"""
main2 = list(main)
return estQuinte(main2) and estFlush(main2)
def estQuinteFlushRoyale(main):
main2 = list(main)
return estQuinteFlush(main2) and (hauteur(main2) == 14)
def estCarre(main):
main2 = list(main)
liste_paires = listePaires(main2)
est_carre = 4 in liste_paires
if est_carre:
carre = entier(main2[liste_paires.index(4)][1])
else:
carre = 0
return carre
def estBrelan(main):
main2 = list(main)
liste_paires = listePaires(main2)
est_brelan = 3 in liste_paires
if est_brelan:
brelan = entier(main2[liste_paires.index(3)][1])
else:
brelan = 0
return brelan
def estPaire(main:list):
main2 = list(main)
main_chiffre = mainChiffre(main2)
l = len(main2)
liste_paires = listePaires(main2)
les_paires = []
for k in range(l):
if liste_paires[k] == 2:
numero = main_chiffre[k]
if numero not in les_paires:
les_paires.append(numero)
les_paires.sort()
les_paires.reverse()
return les_paires
def estFull(main):
main2 = list(main)
paires = estPaire(main2)
brelan = estBrelan(main2)
p = len(paires) == 1
b = brelan > 0
return p and b
def evalMain(main:list):
main2 = list(main)
h = hauteur(main2)
liste_combi = [0,0,0]
liste_combi.append(h)
carre = estCarre(main2)
brelan = estBrelan(main2)
paires = estPaire(main2)
if estQuinteFlushRoyale(main2):
liste_combi[0] = 9
elif estQuinteFlush(main2):
liste_combi[0] = 8
elif carre > 0:
liste_combi[0] = 7
liste_combi[1] = carre
elif estFull(main2):
liste_combi[0] = 6
liste_combi[1] = estBrelan(main2)
liste_combi[2] = estPaire(main2)[0]
elif estFlush(main2):
liste_combi[0] = 5
elif estQuinte(main2):
liste_combi[0] = 4
elif brelan > 0:
liste_combi[0] = 3
liste_combi[1] = brelan
elif len(paires) == 2:
liste_combi[0] = 2
liste_combi[1] = paires[0]
liste_combi[2] = paires[1]
elif len(paires) == 1:
liste_combi[0] = 1
liste_combi[1] = paires[0]
return liste_combi
def comparMain(main1 , main2):
score_1 = evalMain(list(main1))
score_2 = evalMain(list(main2))
compteur_main = 0
gagnant = 0
while gagnant == 0 and compteur_main < 4:
if score_1[compteur_main] > score_2[compteur_main]:
gagnant = 1
elif score_1[compteur_main] < score_2[compteur_main]:
gagnant = 2
compteur_main += 1
return gagnant
Ensuite il me restera une classe Joueur à faire pour rendre le jeu jouable, avec la possibilité de faire les actions de base du jeu comme checker , se coucher... , puis à ajouter une interface graphique au tout
Offline
Ah, la passion fait pousser des ailes...
Pour copier une liste, comme évoqué en cours, il faut faire attention : Python copie des références, pas leurs liens. Nous en avions parlé en classe. Nous avions évoqué aussi :
Les fonctions jusqu'à pioche me semblent trop compliquées. Pourquoi ne pas faire simplement :
Ensuite, il faut essayer d'être plus générique dans les fonctions qui testent les combinaisons. Par exemple, une fonction hauteurs qui renvoie combien il y a de cartes par hauteur.
Par exemple, un carré renverra {1, 4} : 4 cartes de la même hauteur, 1 carte d'une autre hauteur.
Un full : {2, 3}. Il y a bien d'autres moyens.
Offline
J'ai corrigé de nombreux bugs, dont celui de la hauteur. Il suffisait de travailler sur une copie de la main avec copie = list(original). Ça empêche la liste originale d'être modifiée. J' ai également ajouté des fonctions pour évaluer les mains et les comparer entre elles. Il me reste à faire une fonction pour donner le nom de la main, à rendre le code plus compréhensible et agréable à lire et à analyser , et à créer le jeu, notamment avec une classe joueur et les actions de base du jeu, comme miser, checker ou se coucher. Code source ici, retrouvez-le aussi sur mon gitlab pour le télécharger par exemple
'''
Module poker
fonctions de base du jeu
'''def chaine(chiffre:int) -> str:
'''
convertit un nombre en JQKA et en str.
chaine(13)
>>>'K'
'''
INT_TO_STR:dict = {11:'J' , 12:'Q' , 13:'K' , 14:'A'} #Dictionnaire contenant les corres entre les int et les str
if chiffre > 10: #S'il faut mettre une lettre à la place du chiffre
lettre:str = INT_TO_STR[chiffre] #On utilise le dictionnaire
else: #Sinon
lettre:str = str(chiffre) #On convertit simplement en chaîne de caractère
return lettre #On retourne la lettredef entier(lettre:str) -> int:
'''
convertit un nombre en str vers un entier. Permet d'obtenir 11 12 13 14 à partir de JQKA
entier("J")
>>>11
'''
STR_TO_INT:dict = {'J':11 , 'Q':12 , 'K':13 , 'A':14} #Dictionnaire str vers int pour les lettres
if lettre.isnumeric(): #Si la lettre est un nombre
chiffre:int = int(lettre) #On convertit en entier
else: #Sinon -> Si c'est une lettre
chiffre:int = STR_TO_INT[lettre] #On prend l'équivalent dans le dictionnaire
return chiffre #On retourne le chiffre obtenudef jeuCartes() -> list:
'''
Cree un jeu de 52 cartes
chaque carte est une liste [[symbole:str , nombre:str] , [symbole:str , nombre:str] ...]
Aucun paramètre
j = jeuCartes()
print(j[0])
>>>["♠","2"]
'''
symboles:list = ["♠","♥","♣","♦"] #Une liste des 4 symboles dans un jeu de cartes
jeu:list = [] #Pour l'instant le jeu est une liste vide
for s in symboles: #s prend les valeurs de chaque symbole
for c in range (2 , 15): #c prend les valeurs de 2 à 14 -> les chiffres d'un jeu
c:str = chaine(c) #on transforme le chiffre en chaîne de caractère avec la fonction
jeu.append([s , c]) #On ajoute dans le jeu une liste avec un symbole et un chiffre
return jeu #On retourne le jeudef pioche(jeu:list , tirs:int):
'''
Met un nombre donne de carte d'un jeu donné dans une liste et retire les cartes du jeu
Les cartes tirées sont aléatoires
jeu , carte = pioche(jeuCartes() , 1)
print(carte)
>>>["♣" , "K"]
'''from random import randint #On importe la fonction randint du module random
carte_piochees:list = [] #Une liste qui contiendra les cartes qui seront piochées
for t in range (tirs): #Répéter tirs fois
numero_carte:int = randint(1,len(jeu)-1) #Donner un nombre aléatoire qui correspondra à un index de cartes
carte:list = jeu[numero_carte] #Prendre la carte correspondante au numéro
carte_piochees.append(carte) #Ajouter la carte aux cartes piochées
del(jeu[numero_carte]) #Supprimer la carte du paquet
return (jeu , carte_piochees) #Renvoyer le jeu et les cartesdef mainChiffre(main:list) ->list:
'''
renvoie uniquement les chiffres d'une main
'''
liste:list = []
for i in list(main):
c = entier(i[1])
liste.append(c)
return listedef listePaires(main:list) -> list:
liste = [0,0,0,0,0]
l = len(main)
main2 = list(main)
for k in range(l):
carte = main2[k][1]
for i in range(l):
c = main2[i][1]
if carte == c:
liste[i] += 1
return listedef hauteur(main:list) -> int:
main2 = list(main)
liste_paires:list = listePaires(main2)
liste_1:list = []
for k in range(len(main2)):
if liste_paires[k] == 1:
liste_1.append(entier(main2[k][1]))
try:
return max(liste_1)
except ValueError:
return 0def triMain(main:list) ->list:
'''
Trie les mains de façon à donner les cartes plus faibles d'abord
'''
main2 = list(main)
chiffres:list = mainChiffre(main2)
chiffres.sort()
main_triee:list = []
for c in chiffres:
for carte in main2:
index:int = main2.index(carte)
if entier(carte[1]) == c:
main_triee.append(carte)
del main2[index]
return main_trieedef estFlush(main:list) -> bool:
"""
Renvoie True si on a une couleur
"""
main2 = list(main)
flush:bool = True
compteur:int = 0
while flush and (compteur < len(main2) - 1):
flush = main2[compteur][0] == main2[compteur + 1][0]
compteur += 1
return flushdef estQuinte(main:list) -> bool:
"""
Retourne True si la main est une suite
"""
main2 = list(main)
main2 = triMain(main2)
compteur:int = 0
quinte:bool = True
while quinte and (compteur < len(main2) - 1):
quinte = (entier(main2[compteur][1]) + 1) == (entier(main2[compteur + 1][1]))
compteur += 1
return quintedef estQuinteFlush(main:list) -> bool:
"""
"""
main2 = list(main)
return estQuinte(main2) and estFlush(main2)def estQuinteFlushRoyale(main):
main2 = list(main)
return estQuinteFlush(main2) and (hauteur(main2) == 14)def estCarre(main):
main2 = list(main)
liste_paires = listePaires(main2)
est_carre = 4 in liste_paires
if est_carre:
carre = entier(main2[liste_paires.index(4)][1])
else:
carre = 0
return carredef estBrelan(main):
main2 = list(main)
liste_paires = listePaires(main2)
est_brelan = 3 in liste_paires
if est_brelan:
brelan = entier(main2[liste_paires.index(3)][1])
else:
brelan = 0
return brelandef estPaire(main:list):
main2 = list(main)
main_chiffre = mainChiffre(main2)
l = len(main2)
liste_paires = listePaires(main2)
les_paires = []
for k in range(l):
if liste_paires[k] == 2:
numero = main_chiffre[k]
if numero not in les_paires:
les_paires.append(numero)
les_paires.sort()
les_paires.reverse()
return les_pairesdef estFull(main):
main2 = list(main)
paires = estPaire(main2)
brelan = estBrelan(main2)
p = len(paires) == 1
b = brelan > 0
return p and bdef evalMain(main:list):
main2 = list(main)
h = hauteur(main2)
liste_combi = [0,0,0]
liste_combi.append(h)
carre = estCarre(main2)
brelan = estBrelan(main2)
paires = estPaire(main2)
if estQuinteFlushRoyale(main2):
liste_combi[0] = 9
elif estQuinteFlush(main2):
liste_combi[0] = 8
elif carre > 0:
liste_combi[0] = 7
liste_combi[1] = carre
elif estFull(main2):
liste_combi[0] = 6
liste_combi[1] = estBrelan(main2)
liste_combi[2] = estPaire(main2)[0]
elif estFlush(main2):
liste_combi[0] = 5
elif estQuinte(main2):
liste_combi[0] = 4
elif brelan > 0:
liste_combi[0] = 3
liste_combi[1] = brelan
elif len(paires) == 2:
liste_combi[0] = 2
liste_combi[1] = paires[0]
liste_combi[2] = paires[1]
elif len(paires) == 1:
liste_combi[0] = 1
liste_combi[1] = paires[0]
return liste_combidef comparMain(main1 , main2):
score_1 = evalMain(list(main1))
score_2 = evalMain(list(main2))
compteur_main = 0
gagnant = 0
while gagnant == 0 and compteur_main < 4:
if score_1[compteur_main] > score_2[compteur_main]:
gagnant = 1
elif score_1[compteur_main] < score_2[compteur_main]:
gagnant = 2
compteur_main += 1
return gagnant
Last edited by Pacôme Giraudeau (08-Jan-2020 21:55:02)
Offline
Bonjour tout le monde,
Ça y est j'ai fini mon projet. J'ai enfin un Texas Hold'em jouable en python
Il existe deux versions, une avec easygui et une textuelle.
Le projet est sur mon gitlab https://gitlab.com/LBruneteau/texas-hold-em-python/
Le code source dégoûtant, et utilise mal certaines notions, mais l'essentiel est qu'il fonctionne
Je vais essayer de rajouter du son, j'ai déjà une fonction pour ça
À bientôt, et restez ubuntu !
Offline
je n'arrive pas à mettre mes images en ligne sur gitlab. Quand je clique sur click to upload je ne suis pas invité à entrer le chemin vers mon fichier et le glisser déposer ne marche pas. Ça n'a pas une grosse influence sur le projet, seulement le guide de l'application dans la version graphique n'affiche pas les images. Je réessaierai demain
Offline
Il y a un petit onglet à cliquer avec un gros + et ensuite il y a "téléverser un fichier"
Offline
c'est ce que j'ai essayé justement
Offline
Pages: 1