IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Help sur les classes: Jeu de carte en Python ?


Sujet :

Python

  1. #1
    Membre habitué
    Profil pro
    Inscrit en
    Mai 2005
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2005
    Messages : 9
    Par défaut Help sur les classes: Jeu de carte en Python ?

    Je programme depuis 30 ans mais je me met à Python et à la programmation objet depuis peu...
    Etant amené à programmer des prototypes de jeux de cartes de société, je souhaite avoir une librairies de classes qui me permettrait de manipuler rapidement ces cartes.
    Donc un jeu de cartes est constitué d'un ou plusieurs decks et une surface de jeu (et on peux même considérer que la surface de jeu est aussi un deck comme un autre ou les cartes sont disposés visibles, la main d'un joueur est un deck: ex: DeckJoueur1.)
    Chaque deck contient une ou plusieurs cartes qui peuvent être visibles, cachées, accessible lorsqu'on clique dessus ou non. Les cartes bougeront d'un deck à un autre.

    Ensuite, je pourrais utiliser des méthodes comme DeckJoueur1. affiche ou deck3.melange ou card15.movecardtodeck(nomdudeck)

    Donc j'ai besoin d'instancier une classe CARD et une classe DECK comme j'ai pu le faire là :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
     
    class card:
        index=0
        def __init__(self):
            card.index+=1
            self.nom=""
            self.description=""
            self.facevisible=True
            self.enable=True
            self.visible=True
            self.deck=""
            self.faceimage=""
            self.backimage=""
        def flip(self):
            self.facevisible=not(self.facevisible)
    class deck:
        def __init__(self)
        self.nom=""
        self.description=""
        self.index=""
        self.nbcards=0
     
    # code principal
    for i in range(10):
        carte=card()
    Ma question est la suivante :
    Dès le départ, je dois créer un deck PIOCHE qui contient supposons 3 cartes(carte1, carte2, carte3).
    1) Comment faire au mieux pour créer un deck et créer en même temps les 3 cartes qui appartiendrait à ce deck ?
    2) je n'arrive pas à créer dynamiquement les 3 cartes? (à part faire manuellement : carte1=card() puis carte2=card() puis carte3=card()
    j'aurais bien aimer adressé une carte d'index i avec un truc du style : carte+str(i).visible=True (avec i=2, cela devrait me donner carte2.visible=True)
    3) Comment finalement si j'agis sur un deck savoir les noms des instances de cartes qui y figurent (par exemple pour mélanger les cartes du deck PIOCHE : deckPIOCHE.melange() ?

    J'espère que j'ai été clair dans mes intentions et merci pour votre aide.

    Jean Marc

  2. #2
    Membre Expert
    Homme Profil pro
    Inscrit en
    Avril 2004
    Messages
    1 068
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Avril 2004
    Messages : 1 068
    Par défaut
    un Deck c'est une liste de cartes en fait.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    class Deck(list,object):
        bla,bla...
    une liste ça se mélange, ça se pioche, etc ...

    après pour mettre des cartes ...
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    deck = Deck()
    deck.append(Card())
    ou
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    deck.extend((card(),card(),etc...))

  3. #3
    Membre éclairé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Janvier 2010
    Messages
    553
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Janvier 2010
    Messages : 553
    Par défaut
    Salut,

    Citation Envoyé par speccy Voir le message
    Dès le départ, je dois créer un deck PIOCHE qui contient supposons 3 cartes(carte1, carte2, carte3).
    1) Comment faire au mieux pour créer un deck et créer en même temps les 3 cartes qui appartiendrait à ce deck ?
    moi je ferai l'instanciation de toute les cartes dans l'initialisation du deck deck d'origine. et je redistribuerai ensuite dans les decks idoines. comme dans une vrai partie de carte quoi.
    un truc dans ce genre:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    class Deck:
        def __init__(self, nb_cards)
            self.nom = ""
            self.description = ""
            self.cards = []
            for i in xrange(nb_cards):
                self.cards.append(Card(i))
    mais la solution de josmiley de faire hériter la classe Deck directement du type list fonctionne aussi


    Citation Envoyé par speccy Voir le message
    2) je n'arrive pas à créer dynamiquement les 3 cartes? (à part faire manuellement : carte1=card() puis carte2=card() puis carte3=card()
    j'aurais bien aimer adressé une carte d'index i avec un truc du style : carte+str(i).visible=True (avec i=2, cela devrait me donner carte2.visible=True)
    voir ci-dessus et réponse josmiley. tu peux pas créer de variables à la volée avec des noms composés (quoi que avec un peu d'instrospection ça doit pouvoir se faire, mais ça serait pas le plus malin), mais tu peux créer une liste de cartes et accéder à chaque carte par son indice dans la liste.

    Citation Envoyé par speccy Voir le message
    3) Comment finalement si j'agis sur un deck savoir les noms des instances de cartes qui y figurent (par exemple pour mélanger les cartes du deck PIOCHE : deckPIOCHE.melange() ?
    admettons que tu instancie les cartes comme je l'ai montré en réponse au point 1, tu pourrais alors accéder à tes cartes comme ça:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    deck = Deck(32)  # instanciation du deck
    deck.cards[0]  # première carte du deck
    deck.cards[1]  # deuxième carte du deck
    deck.cards[31] # dernière carte du deck
    deck.cards[-1] # dernière carte du deck (même effet que la ligne juste au dessus)
    deck.cards[-2] # avant-dernière carte du deck
    fout voir la doc Python, qui est pas trop mal faite, pour plus d'infos sur les listes et les iterables en général.

  4. #4
    Membre éclairé
    Homme Profil pro
    Développeur en formation
    Inscrit en
    Juillet 2013
    Messages
    300
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur en formation
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Juillet 2013
    Messages : 300
    Par défaut
    Je suggère d'abord de faire la liste des cartes existantes "manuellement".
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    cartes_existantes = [card(description="tuez un monstre au choix"),
    card(description="piochez deux cartes"),
    ...]
    La classe carte contiendrait toutes les instructions possibles, après ce sera balaise s'il faut pour chaque carte non pas une simple description mais une fonction "effet" qui déclencherait l'effet (et là bonjour, il va falloir coder l'effet pour chaque carte, heureusement il est possible de passer une fonction en paramètre).
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    class Card :
        def __init__(self, description, effet...) : #où effet doit être la fonction qui réalise l'effet de la carte. Son codage peut être compliqué. Peut éventuellement être mis en fonction lambda.
             self.description=description
             self.effet = effet
             self.visible = True
             ...
        def flip(self) : self.visible = not self.visible
        #et pas besoin de définir la méthode effet, on l'a mise dynamiquement dans la classe
    Et la classe Deck serait une liste de cartes :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    from random import *
     
    class Deck :
        def __init__(self,*cartes) : #la fonction prend un nombre indéfini de cartes en paramètre
             self.cartes = list(cartes)
        def shuffle(self) :
             self.cartes.shuffle()
        def piocher_premiere_carte(self) :
            return self.cartes.pop(0)
        def piocher_carte_hasard(self) : return self.cartes.pop(randrange(len(self.cartes)))
        def insert_card(self,card,position) :
            if position=="bottom" : self.cartes.append(card)
            elif position=="top" : self.cartes.insert(0,card)
            elif position=="random" : self.cartes.insert(randrange(len(self.cartes)),card)
            else : raise ValueError

  5. #5
    Membre habitué
    Profil pro
    Inscrit en
    Mai 2005
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2005
    Messages : 9
    Par défaut
    Bon! déjà merci! je vais étudier tout cela et je reviendrais vous posez quelques questions sans doute....

  6. #6
    Membre habitué
    Profil pro
    Inscrit en
    Mai 2005
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2005
    Messages : 9
    Par défaut
    Bon! déjà merci pour vos réponses que j'étudie avec soin....
    ==>Tryph : j'ai une hésitation sur l'ordre dans lequel je dois créer tout cela...

    si j'ai bien compris ta méthode, mon deck instancié contiendrait une liste d'objets qui sont des cartes (objet CARD)...et après avoir créer le deck, je viendrais paramétrer chaque carte (CARD) avec son contenu réel du style :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    DeckdeDebut=Deck(32)
    DeckdeDebut.description =" Deck de création des cartes"
    DeckdeDebut.cards[0].nom="Carte E"
    DeckdeDebut.cards[1].nom="Carte F"
    DeckdeDebut.cards[2].nom="Carte Z"
    1) Puis je adresser les noms des cartes comme cela?
    2) autre question, j'ai du mal à conceptualiser le passage d'une carte d'un deck vers un autre (on enlève l'objet de la liste mais comment le rajouter dans une liste d'un autre deck ??...
    En fait, du coup, je n'ai plus vraiment l'impression qu'une carte est un objet puisque cela devient un indice d'une liste.... il va falloir lorsque je cliquerais sur cette carte que je récupère l'index de cet objet qui correspondra à sa position dans la liste du deck où elle est affectée?? pas clair tout cela pour moi....

    Merci.

  7. #7
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 707
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 707
    Par défaut
    Salut,

    Citation Envoyé par speccy Voir le message
    2) autre question, j'ai du mal à conceptualiser le passage d'une carte d'un deck vers un autre (on enlève l'objet de la liste mais comment le rajouter dans une liste d'un autre deck ??...
    En fait, du coup, je n'ai plus vraiment l'impression qu'une carte est un objet puisque cela devient un indice d'une liste.... il va falloir lorsque je cliquerais sur cette carte que je récupère l'index de cet objet qui correspondra à sa position dans la liste du deck où elle est affectée?? pas clair tout cela pour moi....
    Mouais...
    Une liste n'est qu'une collection d'objets parmi d'autres.
    remplacez vos cartes par des objets de type "integers", déplacer d'une liste à l'autre se fait simplement via l'identifiant de l'objet (qui dans ce cas est "caché"):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>> deck1 = [ 1, 2, 3 ]
    >>> deck2 = [ 4, 5, 6 ]
    >>> deck1.remove(2)
    >>> deck1
    [1, 3]
    >>> deck2.append(2)
    >>> deck2
    [4, 5, 6, 2]
    >>>
    On peut faire la même chose en remplaçant les entiers par des objets "utilisateurs":
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    >>> class C:
    ...     def __init__(self, number):
    ...         self.number = number
    ...     def __str__(self):
    ...         return 'C(%d)' % self.number
    ...
    >>> deck1 = [ C(n) for n in range(3) ]
    >>> deck2 = [ C(n) for n in range(3, 3+3) ]
    >>> print ('deck1', ' '.join(str(c) for c in deck1))
    deck1 C(0) C(1) C(2)
    >>> print ('deck2', ' '.join(str(c) for c in deck2))
    deck2 C(3) C(4) C(5)
    >>>
    >>> carte = deck1[0]
    >>>
    >>> deck1.remove(carte)
    >>> deck2.append(carte)
    >>> print ('after move')
    after move
    >>> print ('deck1',' '.join(str(c) for c in deck1))
    deck1 C(1) C(2)
    >>> print ('deck2',' '.join(str(c) for c in deck2))
    deck2 C(3) C(4) C(5) C(0)
    >>>
    >>>
    On fait toujours deck1.remove, deck2.append mais la sauce à ajouter autour est plus touffue...

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  8. #8
    Membre éclairé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Janvier 2010
    Messages
    553
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Janvier 2010
    Messages : 553
    Par défaut
    Citation Envoyé par speccy Voir le message
    Bon! déjà merci pour vos réponses que j'étudie avec soin....
    ==>Tryph : j'ai une hésitation sur l'ordre dans lequel je dois créer tout cela...

    si j'ai bien compris ta méthode, mon deck instancié contiendrait une liste d'objets qui sont des cartes (objet CARD)...et après avoir créer le deck, je viendrais paramétrer chaque carte (CARD) avec son contenu réel du style :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    DeckdeDebut=Deck(32)
    DeckdeDebut.description =" Deck de création des cartes"
    DeckdeDebut.cards[0].nom="Carte E"
    DeckdeDebut.cards[1].nom="Carte F"
    DeckdeDebut.cards[2].nom="Carte Z"
    1) Puis je adresser les noms des cartes comme cela?
    oui, pour peu que la classe Card possède un attribut "nom" bien évidemment.
    après, si j'étais à ta place, je ferai probablement comme proposé par Stalacta, c'est à dire préparer mes descriptions et autre infos au sujet de chaque carte dans une structure quelconque que je passerai ensuite au constructeur du DeckDebut pour que ça soit lui même qui s'occupe d'instancier complètement chaque carte.
    car si le DeckDebut ne s'occupe que de créer les instance de Card sans les initialiser, il n'y que peu d'intérêt à faire comme ça.
    dans ma première réponse, j'ai défini l'initialisation de la classe Deck comme ça:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    def __init__(self, nb_cards)
    mais il va de soi que le paramètre nb_cards est là en exemple que c'est probablement pas ce qu'on va vouloir faire au final, à moins de vouloir des cartes qui ne possède qu'une valeur numérique et rien d'autre. dans la pratique on voudra plutôt passer des infos utiles pour la création de chaque carte.
    après la structure qui possède les infos de chaque carte peut être un dictionnaire ou quelque chose de plus complexe, suivant le besoin.

    Citation Envoyé par speccy Voir le message
    2) autre question, j'ai du mal à conceptualiser le passage d'une carte d'un deck vers un autre (on enlève l'objet de la liste mais comment le rajouter dans une liste d'un autre deck ??...
    En fait, du coup, je n'ai plus vraiment l'impression qu'une carte est un objet puisque cela devient un indice d'une liste....
    si les indice sont trop abstraits, tu peux utiliser un dictionnaire à la place d'une liste faire en sorte que chaque carte ait un "nom_abrégé" unique qui pourra servir entre autre de clef de dictionnaire.
    par exemple, admettons que ton deck contienne 4 cartes:
    As de pique: nom_abrégé = "pique_1"
    Reine de coeur: nom_abrégé = "coeur_reine"
    Roi de carreau: nom_abrégé = "carreau_roi"
    2 de trèfle: nom_abrégé = "trelfe_2"

    la liste cards du DeckDebut pourrait donc devenir le dictionnaire suivant (à construire dynamiquement évidemment et à adapter au besoi réel):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    cards = {
        "pique_1": Card("As de Pique"),
        "coeur_reine": Card("Reine de Coeur"),
        "carreau_roi": Card("Roi de Carreau"),
        "trelfe_2": Card("2 de trèfle")}
    du coup au lieu de manipuler tes cartes à partir d'indice, tu les manipuleras par leur nom_abrégé, et comme chaque carte connaitra son propre nom_abrégé tu n'aura aucun mal à retrouver celui-ci.

    Citation Envoyé par speccy Voir le message
    il va falloir lorsque je cliquerais sur cette carte que je récupère l'index de cet objet qui correspondra à sa position dans la liste du deck où elle est affectée?? pas clair tout cela pour moi....

    Merci.
    après ce que je te propose là n'est qu'une technique pour gérer le fonctionnement de ton jeu de carte, pas son affichage et les interactions avec l'utlisateur. Là tu parles de clique, mais tu ne cliques pas sur une instance de classe, tu cliques sur une représentation graphique d'une carte et ça sera à l'objet codant cette représentation de gérer cet aspet. tu peux éventuellement coder l'aspet graphique et l'aspet fonctionnement du jeu dans les même objets Python mais tout le monde te le déconseillera je pense.

    quoi qu'il en soit, une simple méthode move_card(card, deck) sur chaque classe Deck (au passage, chaque classe Deck devrait hériter de la même classe de base) devrait te permettre de gérer les mouvements de carte d'une carte d'un deck à l'autre.
    Cette méthode pourrait se contenter de supprimer la carte du deck sur lequel la méthode est appelée et de l'ajouter au deck fourni en paramètre. les dictionnaires, comme les listes, permettent de faire ça.

    après, tout cas, ce ne sont que des pistes ...

Discussions similaires

  1. Help sur les services Internet
    Par kouky dans le forum Dépannage et Assistance
    Réponses: 3
    Dernier message: 12/12/2006, 14h39
  2. [COM] informations sur les classes
    Par gorgonite dans le forum Visual C++
    Réponses: 3
    Dernier message: 12/12/2006, 14h31
  3. [POO] Besoin de tutorat sur les classes
    Par misterniark dans le forum Langage
    Réponses: 11
    Dernier message: 20/04/2006, 13h48
  4. demande de renseignements sur les classes
    Par altadeos dans le forum Langage
    Réponses: 4
    Dernier message: 08/04/2006, 15h59
  5. Question de base sur les classes
    Par deaven dans le forum C++
    Réponses: 3
    Dernier message: 27/11/2005, 16h20

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo