Partage
  • Partager sur Facebook
  • Partager sur Twitter

Jeu de belote

    21 novembre 2021 à 19:56:24

    import random
    
    HEIGTH= ( "7", "8", "9","Valet", "Dame", "Roi", "10","As")
    COLOR= ("Coeur", "Carreau", "Trèfle", "Pique")
    HEIGTHA= ( "7", "8", "Dame", "Roi", "10", "As", "9", "Valet")
    
    
    def create_deck():
        """
        retourne un jeu de 32 cartes pour la belote 
        une carte est un tuple ("7", "Carreau") hauteur couleur.
        """
        hauteur=HEIGTH
        couleur=COLOR
        for ihauteur in (hauteur):
            for icolor in(couleur):
                carte=ihauteur,icolor
                jeu_32_cartes.append(carte)
            
        return jeu_32_cartes
    jeu_32_cartes=[]
    
    def strength(card, atout):
        """
        Retourne l'Ordre de la carte 'card' pour l'atout 'atout':
        à la couleur indice dans l'ordre des cartes dans la couleur
        à l'atout 100 + indice dans l'ordre des atouts
        """
        carte_couleur=card[1]
        carte_hauteur=card[0]
        
        if carte_couleur==atout:
            for indices_atout,H in enumerate (HEIGTHA):
                    if carte_hauteur==H:
                        return 100+indices_atout
        else:
            for indice,HG in enumerate (HEIGTH):
                if carte_hauteur==HG and carte_couleur!=atout:
                    return indice 
    
    def melange(deck, seed=None):
        """
        mélange le deck
        """
        if (not seed is None):
            random.seed(seed)
            random.shuffle(deck)
            return deck
        
        
    def choixecarte(plis, jeudujoeur,atout, pliss):
        """
        Choisi la carte dans le deck qui est la plus forte parmis les cartes légales.
        Rappel des règles:
        1) il faut d'abord fournir à la couleur de la première carte du plis.
        2) sinon on n'a pas de carte la couleur  il faut couper sauf si le partenaire est maitre.
        3) sinon il faut fournir une carte (la plus petite possible pour les tests)
        On peut compliquer sans fin cette fonction en faisant des choix plus complexes.
        """
        valeur_jeudujoeur=[]
        valeur_plis=[]
        valeur_min=[]
        valeur=[]
        valeur2=[]
        
       
       
       
        for p,items2 in enumerate(plis):
            valeur_3=strength(items2,atout)
            valeur2.append(valeur_3)
            valeur_plis=max(valeur2)
        
        if valeur_plis<100:
            for i in plis:
                couleur=i[1]
            for i,items in enumerate(jeudujoeur):
                if  items[1]==atout and couleur==items[1] or items[1] !=atout :
                    for y,items in enumerate (jeudujoeur):
                        valeur_2=strength(items,atout)
                        valeur.append(valeur_2)
                        valeur_max=max(valeur)
                        if i==y:
                            return jeudujoeur.pop(y)
                        
        else:
            for i in plis:
                couleur=i[1]
            for i,items in enumerate(jeudujoeur):
                if  items[1]==atout and couleur==items[1] or items[1] !=atout :
                    for y,items in enumerate (jeudujoeur):
                        valeur_2=strength(items,atout)
                        valeur.append(valeur_2)
                        valeur_max=max(valeur)
                    if i==y:
                        return jeudujoeur.pop(y)
                    
            for y,items in enumerate (jeudujoeur):
                if items[1]!=atout and  items[1] !=atout:
                    for i,items in enumerate (jeudujoeur):
                        valeur_2=strength(items,atout)
                        valeur.append(valeur_2)
                        valeur_min=min(valeur)
                        i=i+1
                        if i==y:
                            return jeudujoeur.pop(y)
                        
    def gagnant(plis,atout):
        """
        le plis liste de quatres cartes jouées dans l'ordre 
        retourne le gagnant du plis (indice dans plis)
        on suppose que la première carte est celle jouée en premier (elle définie la couleur à fournir)
        """
        indice_gagnant = (10 , 0)
        for indice_card_du_plis, card_du_plis in enumerate(plis):
            indice_strength = strength(card_du_plis, atout)
            igagnant,istrength = indice_gagnant
            if indice_strength > istrength:
                indice_gagnant = (indice_card_du_plis , indice_strength)
        return indice_gagnant[0]
    
        
    def belote_rebelote(deck,atout="Pique"):
        """
        Retourne si les deux cartes dame et roi d'atout sont dans le jeu 'deck'.
        """
        le_grand=0
        la_grande=0
        for i in deck:
            if i[0]=='Roi' and i[1]==atout:
                le_grand=i
        for i in deck:
            if i[0]=='Dame' and i[1]==atout:
                la_grande=i
                return le_grand,la_grande
            
    def deal(deck, nb_cartes=5, nb_joueurs=4):
    
        """
        Distribue nb_cartes cartes du deck a nbjoueurs 
        retourne une liste de nbjoueurs listes de nb_cartes 
        """
        if deck ==[]:
            return None
            
        liste_joueur=[]
        for ijoueur in range(nb_joueurs):
            liste_joueur.append([])
            
        for icarte in range (nb_cartes):
            for ijoueur in range(nb_joueurs):
                liste_joueur[ijoueur].append(deck.pop(0))
        return liste_joueur
        
    if __name__ == "__main__" :
           
    #----------------------------------------------------------#
    #distribution des cartes 
        prime=0
        deck = create_deck()
    #print("jeu de carte :",deck)
        compteur=0
        aleatoire_deck = melange(deck,seed=42)
        carte_joueur=[]
        carte_joueur.append(deal(aleatoire_deck, nb_cartes=5, nb_joueurs=4))
        print(carte_joueur)
        print(len(aleatoire_deck))
    
            
            
            
    #--------------------------------------------------------#        
    #affiche la retourne
        retourne=[]
        retourne.append(deck[0])
        aleatoire_deck.pop(0)
        print('retourne',retourne)
            
            
    #-------------------------------------------------------#
    #inverse le joueur         
        nbtours=0
        joueur=0
        players = ["nord", "est", "sud", "ouest"]
        play=[]
    
        play=players.pop(0)
        players.append(play)
        print(players)
        ditribution=[]
            
            
    #------------------------------------------------------#    
    introduction:
    
    #1e choix
    
    # 2 possibilité dans le 1er choix:
    
    
    #-1er possiblilité,fin du tours lorsque :
    #- un joueur choisit une carte 
    #-tout le monde recoit 3 cartes 
    #Au 2e tours personne ayant la carte centre 
    #2 possibilités:
    #-soit il sort la carte 
    #-soit il en choisit une autre 
    
    
    
    
    #2e possibilité ,fin du tours lorsque :
    #- un joueur choisit une carte 
    #-tout le monde recoit 3 cartes 
    #Au 2e tours la personne ayant la carte centre :
    #le joueur rejette la carte 
    # 2 conditions:
    #-la carte retourne au centre 
    #-il decide de changer de couleur
    # demander au joueur de prendre ou pass
    # prend la carte si la personne est la plus avantager 
            while  reponse!="prend" :
                    reponse=input("prend ou prend pas ")
                    joueur=joueur+1
                    for i in range (len(players)):
    
                        if i == joueur:
                            print(players[i])
    
                            if i == joueur and reponse=="prend":
                                for i,items in enumerate(carte_joueur):
                                    if players[i]=="nord":
                                        items[0].extend(deal(aleatoire_deck, nb_cartes=2, nb_joueurs=1))
                                        carte_nord.append(items[0])
                                        items[1].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_est.append(items[1])
                                        items[2].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_sud.append(items[2])
                                        items[3].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_ouest.append(items[3])
                                        print(carte_nord)
                                        print(carte_est)
                                        print(carte_sud)
                                        print(carte_ouest)
    
                                    if players[i]=="est":
                                        items[1].extend(deal(aleatoire_deck, nb_cartes=2, nb_joueurs=1))
                                        carte_est.append(items[1])
                                        items[0].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_nord.append(items[0])
                                        items[2].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_est.append(items[2])
                                        items[3].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_ouest.append(items[3])
                                        print(carte_nord)
                                        print(carte_est)
                                        print(carte_sud)
                                        print(carte_ouest)
    
                                    if players[i]=="sud":
                                        items[2].extend(deal(aleatoire_deck, nb_cartes=2, nb_joueurs=1))
                                        carte_sud.append(items[2])
                                        items[0].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_nord.append(items[0])
                                        items[1].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_est.append(items[1])
                                        items[3].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_ouest.append(items[3])
                                        rint(carte_nord)
                                        print(carte_est)
                                        print(carte_sud)
                                        print(carte_ouest)
    
    
                                    if players[i]=="ouest":
                                        items[3].extend(deal(aleatoire_deck, nb_cartes=2, nb_joueurs=1))
                                        carte_ouest.append(items[3])
                                        items[0].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_nord.append(items[0])
                                        items[1].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_est.append(items[1])
                                        items[2].extend(deal(aleatoire_deck, nb_cartes=3, nb_joueurs=1))
                                        carte_sud.append(items[2])
                                        print(carte_ouest)
                                        rint(carte_nord)
                                        print(carte_est)
                                        print(carte_sud)

    Bonjour, j'ai besoin d'aide pour vérifier mon programme qui doit simuler le jeu de belote .

    j'attend votre retour :lol:

    -
    Edité par LaureDeze 21 novembre 2021 à 19:56:57

    • Partager sur Facebook
    • Partager sur Twitter
      21 novembre 2021 à 20:38:35

      LaureDeze a écrit:

      Bonjour, j'ai besoin d'aide pour vérifier mon programme qui doit simuler le jeu de belote .


      Ce qu'on fait dans ces cas là, c'est un plan de tests et un/des programmes de tests... ce qui parfois demande de revoir son code pour qu'il soit "testable" automatiquement.

      -
      Edité par mps 21 novembre 2021 à 20:41:23

      • Partager sur Facebook
      • Partager sur Twitter
        22 novembre 2021 à 2:26:02

        La première chose à faire est de tester soi-même. Est-ce qu'à première vue, ça semble fonctionner?

        Dans la fonction:
        def create_deck():
        Tu pourrais faire directement:
            return [(h, c) for h in heigth for c in color]
        Je doute que tu aies testé cette fonction.

        -
        Edité par PierrotLeFou 22 novembre 2021 à 7:30:43

        • Partager sur Facebook
        • Partager sur Twitter

        Le Tout est souvent plus grand que la somme de ses parties.

          22 novembre 2021 à 16:02:15

          ta fonction  choixecarte (ligne 51)  n'est jamais appelée il me semble tout comme gagnant et belote_rebelote
          • Partager sur Facebook
          • Partager sur Twitter

          Jeu de belote

          × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
          • Editeur
          • Markdown