Discussion :

[speccy]

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

[josmiley]

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...))

[Tryph]

Salut,

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

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.

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.

[stalacta]

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

[speccy]

Bon! déjà merci! je vais étudier tout cela et je reviendrais vous posez quelques questions sans doute....

[speccy]

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.

[wiztricks]

Salut,

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

[Tryph]

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.

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.

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 ...