PYTHON bataille de cartes POO
Répondre à la discussion
Affichage des résultats 1 à 3 sur 3

PYTHON bataille de cartes POO



  1. #1
    dutturu

    PYTHON bataille de cartes POO


    ------

    Bonjour il faut que je fasse la class bataille. Pour obtenir dans la console (regarder la pièce jointe).

    Pour l'instant j'ai fait les class Carte(), JeuCarte() et Joueur().

    Code:
    -class carte:
    
    # Variables globales
    couleurs = ('CARREAU', 'COEUR', 'TREFLE', 'PIQUE')
    noms = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'Valet', 'Dame', 'Roi', 'As']
    valeurs = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '10': 10, 'Valet': 11, 'Dame': 12, 'Roi': 13, 'As': 14}
     
    # Classe Carte
    class Carte:
        def __init__(self, nom, couleur):
            if nom in noms:
            # Affectation des attributs nom et couleur (avec contrôle dans un deuxième temps).
                self.nom = nom
                self.valeur = valeurs[nom]
            else:
                print("erreur de nom")
            if couleur in couleurs:
                self.couleur = couleur
            else:
                print("erreur de couleur")
        ################# Définition des méthodes d'instances avec contrôle #######
        def setNom(self, nouveauNom): # setter
            self.nom = nouveauNom
            self.valeur = valeurs[nouveauNom]
     
        def getNom(self): # getter
            return self.nom
     
        def getCouleur(self): # getter
            return self.couleur
     
        def getValeur(self): # getter
            return self.valeur
     
        def egalite(self, carteN2):
            ''' Renvoie True si les cartes ont même valeur, False sinon
            carte: Objet de type Carte '''
            if self.getValeur() == carteN2.getValeur():
                return True
            else:
                return False
     
        def estSuperieureA(self, carteN2):
            ''' Renvoie True si la valeur de self est supérieure à celle de carte,
            False sinon
            carte: Objet de type Carte '''
            if self.getValeur() > carteN2.getValeur():
                return True
            else:
                return False
     
        def estInferieureeA(self, carteN2):
            ''' Renvoie True si la valeur de self est inferieure à celle de carte,
            False sinon
            carte: Objet de type Carte '''
            if self.getValeur() < carteN2.getValeur():
                return True
            else:
                return False
     
        def __str__(self):
            return "La carte est le "+self.getNom()+" de "+self.couleur
    
    -class Jeucarte:
    
    class JeuCartes():
        def __init__(self, nbCartes=52):
            # Le jeu doit comporter 32 ou 52 cartes, effectuer un contrôle
            self.nbCartes = nbCartes
            self.jeu = [] # self.jeu est une liste des self.nbCartes
            self.creerJeu() # on appelle la méthode adequate qui fera le boulot
     
        ###########################################################################
        ################# Définition des méthodes d'instances #####################
        ###########################################################################
        def getTailleJeu(self):
            ''' Fonction qui retourne le nombre de cartes du jeu
            Valeur retournée: type int '''
            return self.nbCartes
     
        def creerJeu(self): # utilise des objet
            '''Créée la liste des cartes de l'attribut self.jeu.
            Lors de cette création, les cartes sont rangés dans un ordre prédéfini.
            On exploitera les variables globales se trouvant dans le fichier python contenant la classe Carte
            Pour la suite, la liste de cartes pourra être vue comme une pile:
                 l'indice 0 est la carte la plus en dessous,
                 l'indice le plus élevé correspondant à la carte du dessus qui pourra être distribuée par la suite
            '''
            for couleur in couleurs:
                for nom in noms:
                    if (self.nbCartes == 32 and nom not in ['2','3','4','5','6']):
                        self.jeu.append(Carte(nom, couleur))
                    if (self.nbCartes == 52):
                        self.jeu.append(Carte(nom, couleur))
        def getJeu(self):
            '''Renvoie la liste des cartes correspondant à l'attribut self.jeu'''
            return self.jeu
     
        def melanger(self): # utiliser une fonction tout faite se trouvant dans le module random ...
            '''Mélange sur place les cartes de la liste des cartes associée au champ self.jeu'''
            return random.shuffle(self.jeu)
     
        def distribuerCarte(self):
            ''' Cette fonction permet de distribuer une carte à un joueur. Elle retourne la carte
            Valeur retournée: Objet de type Carte '''
            derniereCarte= (self.jeu[-1])
            self.jeu.pop()
            return derniereCarte
     
        def distribuerJeu(self, nbJoueurs, nbCartes):
            ''' Cette méthode distribue nbCartes à chacun des nbJoueurs,
            Cela reviendra à retourner un tableau à nbJoueurs lignes et nbCartes colonne contenant les cartes
            '''
            if (nbJoueurs*nbCartes<=self.nbCartes):
                tableau=[]
                for i in range(nbJoueurs):
                    tableau.append([])
                    for j in range(nbCartes):
                        tableau[i].append(self.distribuerCarte())
                return tableau
            else:
                print("Pas assez de cartes dans le jeu")
    
    -class Joueur:
    
    
    class Joueur():
        def __init__(self, surnom):
            # On peut imaginer que lors de la création du joueur, ce dernier n'a pas encore de carte.
            self.nom = surnom
            self.nbCartes = 0 # valeur par défaut qui sera modifiée
            self.mainJoueur = []  # valeur par défaut qui sera modifiée
     
        ###########################################################################
        ################# Définition des méthodes d'instances #####################
        ###########################################################################
        def setMain(self,listeCartes):
            ''' Initialise la main du joueur avec la liste des cartes donnée comme paramètre d’entrée '''
            self.mainJoueur = listeCartes
            self.nbCartes= self.nbCartes + len(self.mainJoueur)
     
        def getNom(self):
            '''Accesseur de l’attribut nom '''
            return self.nom
     
        def getNbCartes(self):
            '''Accesseur de l’attribut nbCartes'''
            return self.nbCartes
     
        def jouerCarte(self):
            '''Enlève et renvoie la dernière carte du dessus (objet de type Carte) de la main du joueur,
             ou retourne None s’il n’y a plus de cartes dans la main du joueur'''
            derniereCarte= (self.mainJoueur[-1])
            if (derniereCarte == []):
                print("None")
            else:
                self.mainJoueur.pop()
                self.nbCartes = self.nbCartes - 1
                return derniereCarte
     
        def insererMain(self,listeCartesGagnees):
            ''' Méthode qui insère des cartes dans la main du Joueur « en dessous »'''
            for liste in listeCartesGagnees:
                self.mainJoueur.insert(0,liste)
                self.nbCartes = self.nbCartes +1
            return self.mainJoueur
    Et j'ai essayer de faire la class bataille:

    Code:
    class Bataille():
        def __init__(self, nomJ1, nomJ2, tailleJeuCartes):
            # L'initialisation va créer les 2 joueurs, mélanger et distribuer les cartes
            self.J1 = joueur(nomJ1)
            self.J2 = joueur(nomJ2) # valeur par défaut qui sera modifiée
            self.jeuCartes = JeuCartes(tailleJeuCartes) # valeur par défaut qui sera modifiée
            ## On mélange le jeu et on le distribue aux 2 joueurs
     
     
        ###########################################################################
        ################# Définition des méthodes d'instances #####################
        ###########################################################################
        def jouer(self):
            ''' Chaque joueur pose une carte. On regarde qui gagne. Ce dernier remporte les cartes.
            En cas d'égalité, chacun reprend sa carte (<- Ici, on peut changer la règle)
            '''
            toto=Joueur("Toto")
            dupont=Joueur("Dupont")
            print("Debut:", self.jeuCartes)
     
            print(toto.getNom()," a gagné. Nombre de carte du joueur:",toto.getNbCartes())

    Merci d'avance de votre réponse...

    -----
    Images attachées Images attachées  
    Dernière modification par JPL ; 03/10/2020 à 21h57. Motif: ajout de la balise Code (#) pour garder l’indentation

  2. #2
    JPL
    Responsable des forums

    Re : PYTHON bataille de cartes POO

    Comme indiqué en tête de ce forum les codes doivent être obligatoirement entourés des balises [Code]...[/Code].
    Rien ne sert de penser, il faut réfléchir avant - Pierre Dac

  3. #3
    dutturu

    Re : PYTHON bataille de cartes POO

    Code:
    -class carte:
    
    # Variables globales
    couleurs = ('CARREAU', 'COEUR', 'TREFLE', 'PIQUE')
    noms = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'Valet', 'Dame', 'Roi', 'As']
    valeurs = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '10': 10, 'Valet': 11, 'Dame': 12, 'Roi': 13, 'As': 14}
     
    # Classe Carte
    class Carte:
        def __init__(self, nom, couleur):
            if nom in noms:
            # Affectation des attributs nom et couleur (avec contrôle dans un deuxième temps).
                self.nom = nom
                self.valeur = valeurs[nom]
            else:
                print("erreur de nom")
            if couleur in couleurs:
                self.couleur = couleur
            else:
                print("erreur de couleur")
        ################# Définition des méthodes d'instances avec contrôle #######
        def setNom(self, nouveauNom): # setter
            self.nom = nouveauNom
            self.valeur = valeurs[nouveauNom]
     
        def getNom(self): # getter
            return self.nom
     
        def getCouleur(self): # getter
            return self.couleur
     
        def getValeur(self): # getter
            return self.valeur
     
        def egalite(self, carteN2):
            ''' Renvoie True si les cartes ont même valeur, False sinon
            carte: Objet de type Carte '''
            if self.getValeur() == carteN2.getValeur():
                return True
            else:
                return False
     
        def estSuperieureA(self, carteN2):
            ''' Renvoie True si la valeur de self est supérieure à celle de carte,
            False sinon
            carte: Objet de type Carte '''
            if self.getValeur() > carteN2.getValeur():
                return True
            else:
                return False
     
        def estInferieureeA(self, carteN2):
            ''' Renvoie True si la valeur de self est inferieure à celle de carte,
            False sinon
            carte: Objet de type Carte '''
            if self.getValeur() < carteN2.getValeur():
                return True
            else:
                return False
     
        def __str__(self):
            return "La carte est le "+self.getNom()+" de "+self.couleur
    
    -class Jeucarte:
    
    class JeuCartes():
        def __init__(self, nbCartes=52):
            # Le jeu doit comporter 32 ou 52 cartes, effectuer un contrôle
            self.nbCartes = nbCartes
            self.jeu = [] # self.jeu est une liste des self.nbCartes
            self.creerJeu() # on appelle la méthode adequate qui fera le boulot
     
        ###########################################################################
        ################# Définition des méthodes d'instances #####################
        ###########################################################################
        def getTailleJeu(self):
            ''' Fonction qui retourne le nombre de cartes du jeu
            Valeur retournée: type int '''
            return self.nbCartes
     
        def creerJeu(self): # utilise des objet
            '''Créée la liste des cartes de l'attribut self.jeu.
            Lors de cette création, les cartes sont rangés dans un ordre prédéfini.
            On exploitera les variables globales se trouvant dans le fichier python contenant la classe Carte
            Pour la suite, la liste de cartes pourra être vue comme une pile:
                 l'indice 0 est la carte la plus en dessous,
                 l'indice le plus élevé correspondant à la carte du dessus qui pourra être distribuée par la suite
            '''
            for couleur in couleurs:
                for nom in noms:
                    if (self.nbCartes == 32 and nom not in ['2','3','4','5','6']):
                        self.jeu.append(Carte(nom, couleur))
                    if (self.nbCartes == 52):
                        self.jeu.append(Carte(nom, couleur))
        def getJeu(self):
            '''Renvoie la liste des cartes correspondant à l'attribut self.jeu'''
            return self.jeu
     
        def melanger(self): # utiliser une fonction tout faite se trouvant dans le module random ...
            '''Mélange sur place les cartes de la liste des cartes associée au champ self.jeu'''
            return random.shuffle(self.jeu)
     
        def distribuerCarte(self):
            ''' Cette fonction permet de distribuer une carte à un joueur. Elle retourne la carte
            Valeur retournée: Objet de type Carte '''
            derniereCarte= (self.jeu[-1])
            self.jeu.pop()
            return derniereCarte
     
        def distribuerJeu(self, nbJoueurs, nbCartes):
            ''' Cette méthode distribue nbCartes à chacun des nbJoueurs,
            Cela reviendra à retourner un tableau à nbJoueurs lignes et nbCartes colonne contenant les cartes
            '''
            if (nbJoueurs*nbCartes<=self.nbCartes):
                tableau=[]
                for i in range(nbJoueurs):
                    tableau.append([])
                    for j in range(nbCartes):
                        tableau[i].append(self.distribuerCarte())
                return tableau
            else:
                print("Pas assez de cartes dans le jeu")
    
    -class Joueur:
    
    
    class Joueur():
        def __init__(self, surnom):
            # On peut imaginer que lors de la création du joueur, ce dernier n'a pas encore de carte.
            self.nom = surnom
            self.nbCartes = 0 # valeur par défaut qui sera modifiée
            self.mainJoueur = []  # valeur par défaut qui sera modifiée
     
        ###########################################################################
        ################# Définition des méthodes d'instances #####################
        ###########################################################################
        def setMain(self,listeCartes):
            ''' Initialise la main du joueur avec la liste des cartes donnée comme paramètre d’entrée '''
            self.mainJoueur = listeCartes
            self.nbCartes= self.nbCartes + len(self.mainJoueur)
     
        def getNom(self):
            '''Accesseur de l’attribut nom '''
            return self.nom
     
        def getNbCartes(self):
            '''Accesseur de l’attribut nbCartes'''
            return self.nbCartes
     
        def jouerCarte(self):
            '''Enlève et renvoie la dernière carte du dessus (objet de type Carte) de la main du joueur,
             ou retourne None s’il n’y a plus de cartes dans la main du joueur'''
            derniereCarte= (self.mainJoueur[-1])
            if (derniereCarte == []):
                print("None")
            else:
                self.mainJoueur.pop()
                self.nbCartes = self.nbCartes - 1
                return derniereCarte
     
        def insererMain(self,listeCartesGagnees):
            ''' Méthode qui insère des cartes dans la main du Joueur « en dessous »'''
            for liste in listeCartesGagnees:
                self.mainJoueur.insert(0,liste)
                self.nbCartes = self.nbCartes +1
            return self.mainJoueur
    et
    Code:
    class Bataille():
        def __init__(self, nomJ1, nomJ2, tailleJeuCartes):
            # L'initialisation va créer les 2 joueurs, mélanger et distribuer les cartes
            self.J1 = joueur(nomJ1)
            self.J2 = joueur(nomJ2) # valeur par défaut qui sera modifiée
            self.jeuCartes = JeuCartes(tailleJeuCartes) # valeur par défaut qui sera modifiée
            ## On mélange le jeu et on le distribue aux 2 joueurs
     
     
        ###########################################################################
        ################# Définition des méthodes d'instances #####################
        ###########################################################################
        def jouer(self):
            ''' Chaque joueur pose une carte. On regarde qui gagne. Ce dernier remporte les cartes.
            En cas d'égalité, chacun reprend sa carte (<- Ici, on peut changer la règle)
            '''
            toto=Joueur("Toto")
            dupont=Joueur("Dupont")
            print("Debut:", self.jeuCartes)
     
            print(toto.getNom()," a gagné. Nombre de carte du joueur:",toto.getNbCartes())
    C'EST BON?

Discussions similaires

  1. Informations sur les cartes-mère et cartes graphique
    Par SirConvolution dans le forum Matériel - Hardware
    Réponses: 4
    Dernier message: 30/04/2016, 21h10
  2. en python le multi tache n'est pas possible alors pourquoi les threads existent sur python?
    Par docEmmettBrown dans le forum Programmation et langages, Algorithmique
    Réponses: 5
    Dernier message: 10/06/2015, 15h47