Comment afficher sous forme de plateau une matrice avec Tkinter

**Black_Listed** · 26/01/2023, 11h20

Bonjour,

Je souhaite transformer en général mon programme de Jeu de Dame fonctionnant sur la console vers une interface graphique Tkinter. (Il s'agit d'un devoir d'école)
Problème je n'ai jamais touché à cette librairie, c'est pour ça que je vous demande de votre aide !

L'objectif serait de convertir ma matrice en damier sur une interface graphique 10 lignes par 10 colonnes, puis réussir à afficher les pions et réussir à les déplacer.

J'aimerais seulement quelques pistes pour réussir tout ça.
Excusez moi si j'ai mal implémenté le code ci-dessous, c'est la première fois que je poste sur un forum.

Merci d'avance pour vos futurs réponses et je ferais de mon mieux pour répondre à toutes vos questions !

Mon jeu de dame fonctionnant sur console (il n'a pas l'air très beau mais il fonctionne):

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
 
class Damier:
    def __init__(self):
        # 0 = case vide; 1 = pion blanc; 2 = pion noir
        self.damier = [[0, 2, 0, 2, 0, 2, 0, 2, 0, 2],
                       [2, 0, 2, 0, 2, 0, 2, 0, 2, 0],
                       [0, 2, 0, 2, 0, 2, 0, 2, 0, 2],
                       [2, 0, 2, 0, 2, 0, 2, 0, 2, 0],
                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                       [0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
                       [1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
                       [0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
                       [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]
                      ]
        # Pour le joueur contre joueur
        self.joueur_blanc = True
        self.joueur_noir = False
        self.debug = 0
 
    def white_player(self):
        print("\nVous êtes le joueur 1 avec les pions blanc (1) le damier commence index 0 jusqu'a index 9")
        i, j = input("Quel pion voulez-vous déplacer ? Rentrer la position ligne colonne (exemple: 6 1 mettre espace entre les deux valeurs)\n").split()
 
        return int(i), int(j)
 
    def black_player(self):
        print("\nVous êtes le joueur 2 avec les pions noir (2) le damier commence index 0 jusqu'a index 9")
        i, j = input("Quel pion voulez-vous déplacer ? Rentrer la position ligne colonne (exemple: 6 1 mettre espace entre les deux valeurs)\n").split()
 
        return int(i), int(j)
 
    # Methode principal de jeu 
    def maingame(self, damier):
        fonc = True
        cpt = 0
        while fonc:
            if self.joueur_blanc and self.joueur_noir == False:
                reponse_joueur = Damier.white_player(self)
            elif self.joueur_noir and self.joueur_blanc == False:
                reponse_joueur = Damier.black_player(self)
 
            global i, j
            i, j = reponse_joueur
 
            # damier[i][j] ; i represente les lignes, j les colonnes 
            # Si la case est vide 
            if damier[i][j] == 0:
                print("Vous avez selectionne une case vide !")
            # ------------------------------------------------------------------------
            #                           PION BLANC verification
            # ------------------------------------------------------------------------
            if self.joueur_blanc == True and damier[i][j] == 1:
                self.debug = 0
                try:
                    # variable de test
                    limit = 0
                    # On verifie la case diagonale haut gauche s'il y a un pion adversaire
                    if damier[i-1][j-1] == 0:
                        # Vérifie la position du point pour le déplacer dans la diagonale haut gauche 
                        print(f"\n(1) Pion Blanc en position {i},{j} peut avancer en diagonale haut GAUCHE et donc aller en position {i-1}, {j-1}")
                    elif damier[i-1][j-1] == 2 and damier[i-2][j-2] == 0:
                        print(f"(2) Vous pouvez manger le pion diago haut GAUCHE et donc aller en position {i-2}, {j-2}")
                    else:
                        print("\nPion Blanc ne peux se deplacer en diagonale haut gauche\n")
                        limit = 1
                except IndexError:
                    print("\nVous sortez du damier, mouvement impossible\n")
                    limit = 2
                cpt += 1
 
                try:
                    limit = 0
                    # On repete les meme actions pour les cases tout autour
                    # self.damier[i-1][j+1] represente diago en haut a droite
                    if damier[i-1][j+1] == 0:
                        print(f"(3) Pion Blanc en position {i},{j} peut avancer en diagonale haut DROITE et donc aller en position {i-1}, {j+1}")
                    elif damier[i-1][j+1] == 2 and damier[i-2][j+2] == 0:
                        print(f"(4) Vous pouvez manger le pion diago haut DROITE et donc aller en position {i-2}, {j+2}")
                    else:
                        print("\nPion Blanc ne peux se deplacer en diagonale haut droite\n")
                        limit = 1
                except IndexError:
                    print("\nVous sortez du damier, mouvement impossible\n")
                    limit = 2
 
                # Choix du joueur
                choice = input("Que choississez-vous ?\n - Diago Gauche d'une case(1)\n - Prendre pion noir haut gauche(2)\n - Diago Droite d'une case(3)\n - Prendre pion noir haut droite(4)\n")
                # Appel de la methode pour faire avance le pion blanc
                if int(choice) == 1 and limit == 0:
                    Damier.blanc_prise_pion(self, 1)
                    self.damier[i][j] = 0
                    self.affichage()
                # Appel de la methode pour Prendre pion noir haut gauche(2)
                if int(choice) == 2 and limit == 0:
                    Damier.blanc_prise_pion(self, 2)
                    self.damier[i][j] = 0
                    self.affichage()
                # Appel de la methode pour Diago Droite d'une case(3)
                if int(choice) == 3 and limit == 0:
                    Damier.blanc_prise_pion(self, 3)
                    self.damier[i][j] = 0
                    self.affichage()
                # Appel de la methode pour Prendre pion noir haut droite(4)
                if int(choice) == 4 and limit == 0:
                    Damier.blanc_prise_pion(self, 4)
                    self.damier[i][j] = 0
                    self.affichage()
 
 
                self.joueur_blanc = False
                self.joueur_noir = True
 
 
            elif self.joueur_blanc == True and damier[i][j] != 1:
                print("Ce n'est pas un pion Blanc !\n")
 
 
            # ------------------------------------------------------------------------
            #                           PION NOIR verification
            # ------------------------------------------------------------------------
            if self.joueur_noir == True and damier[i][j] == 2:
                cpt += 1
                self.debug = 1
                try:
                    limit = 0
                    # On repete les meme actions pour les cases tout autour
                    # self.damier[i+1][j-1] represente diago en bas a droite
                    if damier[i+1][j-1] == 0:
                        print(f"\n(1) Pion Noir en position {i},{j} peut avancer en diagonale bas GAUCHE et donc aller en position {i+1}, {j-1}")
                    elif damier[i+1][j-1] == 1 and damier[i+2][j-2] == 0:
                        print(f"(2) Vous pouvez manger le pion diago bas GAUCHE et donc aller en position {i+2}, {j-2}")
                    else:
                        print("\nVous ne pouvez vous deplacez en diagonale bas gauche")
                        limit = 1
                except IndexError:
                    print("\nVous sortez du damier, mouvement impossible\n")
                    limit = 2
 
                try:
                    # On repete les meme actions pour les cases tout autour
                    # self.damier[i+1][j-1] represente diago en bas a droite
                    if damier[i+1][j+1] == 0:
                        print(f"(3) Pion Noir en position {i},{j} peut avancer en diagonale bas DROITE et donc aller en position {i+1}, {j+1}")
                    elif damier[i+1][j+1] == 1 and damier[i+2][j+2] == 0:
                        print(f"(4) Vous pouvez manger le pion diago bas DROITE et donc aller en position {i+2}, {j+2}")
                    else:
                        print("\nVous ne pouvez vous deplacez en diagonale bas droite\n")
                        limit = 1
                except IndexError:
                    print("\nVous sortez du damier, mouvement impossible\n")
                    limit = 2
 
 
                # Choix du joueur
                choice = input("Que choississez-vous ?\n - Diago bas Gauche d'une case(1)\n - Prendre pion blanc bas gauche(2)\n - Diago bas Droite d'une case(3)\n - Prendre pion blanc bas droite(4)\n")
                # Appel de la methode pour faire avance les pions noir
                if int(choice) == 1 and limit == 0:
                    Damier.noir_prise_pion(self, 1)
                    self.damier[i][j] = 0
                    self.affichage()
                # Appel de la methode pour Prendre pion blanc bas gauche(2)
                if int(choice) == 2 and limit == 0:
                    Damier.noir_prise_pion(self, 2)
                    self.damier[i][j] = 0
                    self.affichage()
                # Appel de la methode pour Diago bas Droite d'une case(3)
                if int(choice) == 3 and limit == 0:
                    Damier.noir_prise_pion(self, 3)
                    self.damier[i][j] = 0
                    self.affichage()
                # Appel de la methode pour Prendre pion blanc bas droite(4)
                if int(choice) == 4 and limit == 0:
                    Damier.noir_prise_pion(self, 4)
                    self.damier[i][j] = 0
                    self.affichage()
 
 
                self.joueur_noir = False
                self.joueur_blanc = True
 
            if self.joueur_noir == True and damier[i][j] != 2 and self.debug == 1:
                print("Ce n'est pas un pion Noir !\n")
 
        # Au bout de 2000 tours, le partie est finie
        if cpt == 2000:
            print("Match nul, la partie est finie 🙂 ")
            fonc = False
 
 
    # Methode pour le deplacement et la prise de pions (argument n qui nous permet de choisir dans quelle situation nous sommes)
    def blanc_prise_pion(self, n):
        if n == 1:
            # Pion blanc placer en diago haut gauche
            self.damier[i-1][j-1] = 1
        if n == 2:
            #Pion blanc prend pion noir haut gauche(2)
            self.damier[i-2][j-2] = 1
            # Pion capture enleve du jeu
            self.damier[i-1][j-1] = 0
        if n == 3:
            #Diago Droite d'une case(3)
            self.damier[i-1][j+1] = 1
        if n == 4:
            #Prendre pion noir haut droite(4)
            self.damier[i-2][j+2] = 1
            # Pion capture enleve du jeu
            self.damier[i-1][j+1] = 0
 
    # Methode pour le deplacement et la prise de pions (argument n qui nous permet de choisir dans quelle situation nous sommes)
    def noir_prise_pion(self, n):
        if n == 1:
            # Pion noir placer en diago bas gauche
            self.damier[i+1][j-1] = 2
        if n == 2:
            #Pion noir prend pion blanc bas gauche(2)
            self.damier[i+2][j-2] = 2
            # Pion capture qui est enleve du jeu
            self.damier[i+1][j-1] = 0
        if n == 3:
            #Diago bas Droite d'une case(3)
            self.damier[i+1][j+1] = 2
        if n == 4:
            #Prendre pion blanc bas droite(4)
            self.damier[i+2][j+2] = 2
            # Pion capture qui est enleve du jeu
            self.damier[i+1][j+1] = 0
 
 
    # Methode Pour espacer et rendre la matrice plus compréhensible sur le terminal
    def affichage(self):
        c = 0
        for i in self.damier:
            print(f"index{c}:", end="\t")
            c += 1
            for ele in i:
                print(ele, end="\t")
            print()
 
 
    def appel(self):
        self.affichage()
 
if __name__ == "__main__":
    test = Damier()
    test.appel()
    print(test.maingame(test.damier))

**wiztricks** · 26/01/2023, 11h33

Salut,

Envoyé par Black_Listed

Problème je n'ai jamais touché à cette librairie, c'est pour ça que je vous demande de votre aide !

Ce forum n'est pas là pour vous éviter d'avoir à passer du temps à apprendre à programmer avec python ou tkinter et de chercher sur Internet des exemples de code (un damier avec tkinter s'écrit "tkinter checkerboard")...
C'est un minimum pour échanger des idées plutôt que juste des lignes de code.

- W

**Black_Listed** · 26/01/2023, 11h46

Envoyé par wiztricks

Salut,

Ce forum n'est pas là pour vous éviter d'avoir à passer du temps à apprendre à programmer avec python ou tkinter et de chercher sur Internet des exemples de code (un damier avec tkinter s'écrit "tkinter checkerboard")...
C'est un minimum pour échanger des idées plutôt que juste des lignes de code.

- W

Salut wiztricks,

Là n'était pas mon but ! Je ne recherche que des pistes et non des réponses toutes faites, effectivement j'ai cherché et essayer de m'y prendre par moi-même, j'arrive à créer un damier cependant cela se fait sans la matrice que j'essaye tant bien que mal à implémenter.

Peut-être aurais-je du simplement montrer la matrice est non le code entier, car finalement au fil des recherches, j'ai trouvé pas mal de solutions (Déplacement des pions, prise pions adversaire, ect..).

Mais tout cela sans le Board à peu d'utilité.

Merci quand même de ton retour

**Black_Listed** · 26/01/2023, 12h51

Je reviens sur cette discussion, j'ai finalement réussi à trouver comment faire.

Je met le sujet en "Résolu" étant donné que je ne sais pas comment le supprimer ou fermé.

Comment afficher sous forme de plateau une matrice avec Tkinter [Python 3.X]

Python

Vue hybride

Discussions similaires

Partager

Partager