Bataille_MAC/essaie.py

# quelque idée, qui peuvent peut-être aider, ou pas ...

import tkinter as tk
from random import randint
from Pile import Pile_lst as Pile
from File import File_lst as File

p52 = Pile() # Création d'une pile vide pour un paquet de 52 cartes
p32 = Pile() # Création d'une pile vide pour un paquet de 32 cartes
paquet_j1 = File () # paquet de carte du joueur 1
paquet_j2 = File () # paquet de carte du joueur 2

class Carte:
    def __init__ (self,valeur, couleur):
        self.valeur = valeur
        self.couleur = couleur
    
    def __repr__ (self): #permet de mettre "Carte(11, 1)" sous forme "Valet de cœur" (trouver sur python pas a pas) 
        couleurs = {1: "Cœur", 2: "Carreau", 3: "Trèfle", 4: "Pique"}
        valeurs = {11: "Valet", 12: "Dame", 13: "Roi", 14: "As"}
        valeur_str = valeurs.get(self.valeur, self.valeur)
        couleur_str = couleurs.get(self.couleur, self.couleur)
        return f"{valeur_str} de {couleur_str}"
        
    def cartes_52 (self) : #créer les 52 cartes dans l'ordre 
        valeurs = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
        couleurs = [1, 2, 3, 4]
        for couleur in couleurs:
            for valeur in valeurs:
                p52.empiler(Carte(valeur, couleur))  # Empiler chaque carte
        return p52
    
    
    
    def cartes_32 (self) : #créer les 32 cartes dans l'ordre
        valeurs = [7,8,9,10,11,12,13,14] # la valeur de l'as est mise a 14 pour facilité le travail 
        couleurs = [1,2,3,4]
        for couleur in couleurs:
            for valeur in valeurs:
                p32.empiler(Carte(valeur, couleur))  # Empiler chaque carte
        return p32
    
    def compare (self,other):
        if other.valeur > self.valeur: # si other est une carte avec une valeur plus grande
            return -1
        elif other.valeur < self.valeur: # si self est une carte avec une valeur plus grande
            return 1
        else : # même valeur, il y a bataille
            return 0


paquet_j1 = File ()
paquet_j2 = File ()

class Jeux :
    def __init__ (self):
        self.valeur_paquet = int(input("voulez vous jouer avec un paquet de 32 ou de 52 cartes?")) # nombre de carte dans le paquet,à remplacer  par un boutton
        
        # essaie de mélange, j'ai tester avec un jeu de carte papier ça mélange vraiment
        x = 3
        p = Pile () # pile pour aider à mélanger
        f = File () # file pour aider à mélanger
        if self.valeur_paquet == 32:
            for i in range(32):
                for i in range (x) :
                    p.empiler(p32.depiler)
                for i in range (x - 1) :
                    f.enfiler(p.depiler)
                if p.taille() == 10 :
                    for i in range (10):
                        f.enfiler(p.depiler)
            while p.taille() != 0 :
                f.enfiler(p.depiler)
            while f.taille() != 0 :
                p32.empiler(f.defiler)
                
        elif self.valeur_paquet == 52:
            for i in range(52):
                for i in range (x) :
                    p.empiler(p52.depiler)
                for i in range (x - 1) :
                    f.enfiler(p.depiler)
                if p.taille() == 10 :
                    for i in range (10):
                        f.enfiler(p.depiler)
            while p.taille() != 0 :
                f.enfiler(p.depiler)
            while f.taille() != 0 :
                p52.empiler(f.defiler)
                                                        
    def distribut (self): # distribut les cartes mélanger dans deux files, avec le même nombre de cartes        
        if self.valeur_paquet == 32: #faudra changer là aussi pour l'interface graphique
            for i in range (16):
                paquet_j1.enfiler(p32.depiler)
                paquet_j2.enfiler(p32.depiler)
                
        elif self.valeur_paquet == 52:
            for i in range (26):
                paquet_j1.enfiler(p52.depiler)
                paquet_j2.enfiler(p52.depiler)
                
def mélange (y, p_c) : # essaie de mélange, avec y le nombre de cartes a mélanger et p_c le paquet a mélanger (une file)
        x = 3 
        p = Pile () # pile pour aider à mélanger
        f = File () # file pour aider à mélanger
        for i in range(y):
            for i in range (x) :
                  p.empiler(p_c.depiler)
            for i in range (x - 1) :
                f.enfiler(p.depiler)
                if p.taille() == 10 :
                    for i in range (10) :
                        f.enfiler(p.depiler)
            while p.taille() != 0 :
                f.enfiler(p.depiler)
        while f.taille() != 0 :
                p_c.enfiler(f.defiler)
        return p_c


def on_joue ():
    while (paquet_j1.taille() != 0) or (paquet_j2.taille() != 0): # tant que les deux joueur on des cartes, on continue de jouer. 
        carte_j1 = paquet_j1.defiler()
        carte_j2 = paquet_j2.defiler()
        
        #on perd
        if Carte.compare(carte_j1,carte_j2) == -1 :
            paquet_j2.enfiler(carte_j1)
            paquet_j2.enfiler(carte_j2)
        
        #on gagne
        if Carte.compare(carte_j1,carte_j2) == 1 :
            paquet_j1.enfiler(carte_j1)
            paquet_j1.enfiler(carte_j2)
            
        # égalité on fait la bataille 
        if Carte.compare(carte_j1,carte_j2) == 0 :
            p1 = Pile () # pile de bataille du joueur 1
            p2 = Pile () # pile de bataille du joueur 2
            p1.empiler(carte_j1)
            p2.empiler(carte_j2)
            p1.empiler(paquet_j1.defiler()) #cette carte ne sera visible que si la troisiéme est égale a celle de l'adversaire
            p2.empiler(paquet_j1.defiler()) #cette carte ne sera visible que si la troisiéme est égale a celle de l'adversaire
            carte_3b_j1 = paquet_j1.defiler() #troisième carte de la bataille
            carte_3b_j2 = paquet_j2.defiler() # troisième carte de la bataille
            
            #on perd la bataille
            if Carte.compare(carte_3b_j1,carte_3b_j2) == -1 :
                while p2.taille() != 0 : # si p2 est vide, alors p1 aussi
                    paquet_j2.enfiler(p1.depiler())
                    paquet_j2.enfiler(p2.depiler())
            
            #on gagne la bataille
            if Carte.compare(carte_3b_j1,carte_3b_j2) == -1 :
                while p2.taille() != 0 : # si p2 est vide, alors p1 aussi
                    paquet_j2.enfiler(p1.depiler())
                    paquet_j2.enfiler(p2.depiler())
                    
            #égalité a la bataille, on regarde la carte du milieu
            if Carte.compare(carte_3b_j1,carte_3b_j2) == 0 :
                carte_2b_j1 = p1.depiler() #deuxième carte de la bataille
                carte_2b_j2 = p2.depiler() # deuxième carte de la bataille
                
                #on perd la bataille
                if Carte.compare(carte_2b_j1,carte_2b_j2) == -1 :
                    paquet_j2.enfiler(p1.depiler())
                    paquet_j2.enfiler(p2.depiler())
                    paquet_j2.enfiler(carte_2b_j1)
                    paquet_j2.enfiler(carte_2b_j2)
                    paquet_j2.enfiler(carte_3b_j1)
                    paquet_j2.enfiler(carte_3b_j2)
            
                #on gagne la bataille
                if Carte.compare(carte_2b_j1,carte_2b_j2) == 1 :
                    paquet_j1.enfiler(p1.depiler())
                    paquet_j1.enfiler(p2.depiler())
                    paquet_j1.enfiler(carte_2b_j1)
                    paquet_j1.enfiler(carte_2b_j2)
                    paquet_j1.enfiler(carte_3b_j1)
                    paquet_j1.enfiler(carte_3b_j2)
                    
                # égalité 
                if Carte.compare(carte_2b_j1,carte_2b_j2) == 0 :
                    print("le jeu de carte doit ếtre mal mélanger, on va y remédier")
                    mélange(paquet_j1.taille(), paquet_j1)
                    mélange(paquet_j2.taille(), paquet_j2)