Discussion :

[Supral]

Bonjour à tous,

Je suis aujourd'hui face à un problème que je n'arrive pas à résoudre, en effet je souhaite réaliser le déplacement de mes pions. J'ai déjà réalisé les test de déplacement pour qu'à partir d'un pions donné deux pions sont crée pour représenter les possibilités.

Cependant je n'arrive pas à écrire la fonction de déplacement, je vous joins mon code ci-dessous :

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
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
 
 
########################
#### Importations ######
########################
 
from tkinter import *
from tkinter.simpledialog import *
from tkinter.messagebox import showerror
 
#########################
### Variables globales###
#########################
player1=''
player2=''
started=True
 
#########################################################################
############################# Fonctions principales #####################
#############################                       #####################
#########################################################################
 
 
##### Les fonctions pions1 et pions2 permettent l'affichage des pions sur le damier
def pions1():
    global pionsNoirs,black
    x,j=0,0
    for y, x in pionsNoirs:
        damier.create_oval(x*dimension_case, y*dimension_case, (x+1)*dimension_case, (y+1)*dimension_case,outline='white', fill="#623005")## Pions Noirs
 
def pions2():
    global pionsblanc,white
    x,j=0,0
 
    for y, x in pionsBlancs:
        damier.create_oval(x*dimension_case, y*dimension_case, (x+1)*dimension_case, (y+1)*dimension_case,outline='black', fill="#D78A46")## Pions Blancs
 
 
 
##### La fonction generateDamier permet l'affichage du damier
def generateDamier():
 
    i=0
    while i<sizeDamier:
        j=0
        while j<sizeDamier:
            if i%2==0:
                if j%2==0:
                    damier.create_rectangle(j*dimension_case, i*dimension_case, (j*dimension_case)+dimension_case, (i*dimension_case)+dimension_case, fill="#E49E60")## Couleur foncé
                else:
                    damier.create_rectangle(j*dimension_case, i*dimension_case, (j*dimension_case)+dimension_case, (i*dimension_case)+dimension_case,fill="#623005")## Couleur claire
            else:
                if j%2==0:
                    damier.create_rectangle(j*dimension_case, i*dimension_case, (j*dimension_case)+dimension_case, (i*dimension_case)+dimension_case, fill="#623005")
                else:
                    damier.create_rectangle(j*dimension_case, i*dimension_case, (j*dimension_case)+dimension_case, (i*dimension_case)+dimension_case, fill="#E49E60")
            j+=1
        i+=1
        pions1()
        pions2()
 
##### Les fonctions damier8 et damier10 permettent l'affichage d'un damier de 8X8 10X10 ou encore 12X12 cases
def damier8():
    global dimension_case, sizeDamier, rangee_pions,damier,x0,y0,c,nb,casesBlanches,casesNoires, pionsNoirs,pionsBlancs,casesDamier,provisoireBlancs
    dimension_case=75##600/8
    sizeDamier=8
    rangee_pions=3
    nb= 8# nombre de cases (grille carree)
    c=75
    x0,y0=0,0
 
    pionsNoirs=[   [0,1],[0,3],[0,5],[0,7],
                   [1,0],[1,2],[1,4],[1,6],
                   [2,1],[2,3],[2,5],[2,7]]
 
    casesDamier=[  [0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],
                   [1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],
                   [2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],
                   [3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7],
                   [4,0],[4,1],[4,2],[4,3],[4,4],[4,5],[4,6],[4,7],
                   [5,0],[5,1],[5,2],[5,3],[5,4],[5,5],[5,6],[5,7],
                   [6,0],[6,1],[6,2],[6,3],[6,4],[6,5],[6,6],[6,7],
                   [7,0],[7,1],[7,2],[7,3],[7,4],[7,5],[7,6],[7,7] ]
 
 
    casesNoires=[  [0,1],[0,3],[0,5],[0,7],
                   [1,0],[1,2],[1,4],[1,6],
                   [2,1],[2,3],[2,5],[2,7],
                   [3,0],[3,2],[3,4],[3,6],
                   [4,1],[4,3],[4,5],[4,7],
                   [5,0],[5,2],[5,4],[5,6],
                   [6,1],[6,3],[6,5],[6,7],
                   [7,0],[7,2],[7,4],[7,6]]
 
    pionsBlancs=[  [5,0],[5,2],[5,4],[5,6],
                   [6,1],[6,3],[6,5],[6,7],
                   [7,0],[7,2],[7,4],[7,6]]
 
    provisoireBlancs=[]
 
 
    generateDamier()
 
def damier10():
    global dimension_case, sizeDamier, rangee_pions,damier,nb,c,x0,y0,casesBlanches,casesNoires,pionsNoirs,pionsBlancs,casesDamier,provisoireBlancs
    dimension_case=60## 600/15
    sizeDamier=10
    rangee_pions=4
    nb=10
    c=60## Tailles des cases d'un damier en 10*10
    x0,y0=0,0
 
    pionsNoirs=[   [0,1],[0,3],[0,5],[0,7],[0,9],
                   [1,0],[1,2],[1,4],[1,6],[1,8],
                   [2,1],[2,3],[2,5],[2,7],[2,9],
                   [3,0],[3,2],[3,4],[3,6],[3,8]]
 
    casesDamier=[  [0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[0,9],
                   [1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],[1,9],
                   [2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[2,8],[2,9],
                   [3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7],[3,8],[3,9],
                   [4,0],[4,1],[4,2],[4,3],[4,4],[4,5],[4,6],[4,7],[4,8],[4,9],
                   [5,0],[5,1],[5,2],[5,3],[5,4],[5,5],[5,6],[5,7],[5,8],[5,9],
                   [6,0],[6,1],[6,2],[6,3],[6,4],[6,5],[6,6],[6,7],[6,8],[6,9],
                   [7,0],[7,1],[7,2],[7,3],[7,4],[7,5],[7,6],[7,7],[7,8],[7,9],
                   [8,0],[8,1],[8,2],[8,3],[8,4],[8,5],[8,6],[8,7],[8,8],[8,9],
                   [9,0],[9,1],[9,2],[9,3],[9,4],[9,5],[9,6],[9,7],[9,8],[9,9]]
 
 
 
    casesNoires=[  [0,1],[0,3],[0,5],[0,7],[0,9],
                   [1,0],[1,2],[1,4],[1,6],[1,8],
                   [2,1],[2,3],[2,5],[2,7],[2,9],
                   [3,0],[3,2],[3,4],[3,6],[3,8],
                   [4,1],[4,3],[4,5],[4,7],[4,9],
                   [5,0],[5,2],[5,4],[5,6],[5,8],
                   [6,1],[6,3],[6,5],[6,7],[6,9],
                   [7,0],[7,2],[7,4],[7,6],[7,8],
                   [8,1],[8,3],[8,5],[8,7],[8,9],
                   [9,0],[9,2],[9,4],[9,6],[9,8]]
 
 
    pionsBlancs=[  [6,1],[6,3],[6,5],[6,7],[6,9],
                   [7,0],[7,2],[7,4],[7,6],[7,8],
                   [8,1],[8,3],[8,5],[8,7],[8,9],
                   [9,0],[9,2],[9,4],[9,6],[9,8]]
 
    provisoireBlancs=[]
 
    generateDamier()
 
 
 
def deplacementsBlancs(event):
    ## Les conditions de déplacement sont réalisées ici
def deplacementpossiblesBlancs():
    global hautdroit,hautgauche
 
############TEST possibilitées
    ### Possibilités pionsBlancs
    if[y,x] in pionsBlancs:
        t1.delete("0.0",END)
 
        ## Déplacement pionsBlancs en haut à droite
        if [y-1,x+1] in casesNoires:
            if [y-1,x+1]not in( pionsNoirs and pionsBlancs):
                t1.insert(END,"(coup haut droite )+")
 
                hautdroit=damier.create_oval((x+1)*dimension_case, (y-1)*dimension_case, (x+2)*dimension_case, (y)*dimension_case,outline='white', fill="green")## Pions Noirs
                provisoireBlancs.append([y-1,x+1]) ## on ajoute à la variable provisoireBlancs les coordonnées d'un déplacement possible
                print(provisoireBlancs)
                damier.bind("<Button-1>",deplacementsBlancs)## si on clique on lance la fonction deplacement    
 
 
 
            if [y-1,x+1] in (pionsBlancs or pionsNoirs):
                t1.insert(END,"")               
 
        ## Déplacement pionsBlancs en haut à gauche
        if [y-1,x-1] in casesNoires:
            if [y-1,x-1]not in( pionsNoirs and pionsBlancs):
                t1.insert(END,"(coup haut gauche)+")
 
 
                hautgauche=damier.create_oval((x-1)*dimension_case, (y-1)*dimension_case, (x)*dimension_case, (y)*dimension_case,outline='white', fill="red")## Pions Noirs
                provisoireBlancs.append([y-1,x-1])
                print(provisoireBlancs)
 
                damier.bind("<Button-1>",deplacementsBlancs)    
 
            if [y-1,x-1] in (pionsBlancs or pionsNoirs):
                t1.insert(END,"")
 
 
        ## Si ce n'est pas dans une cases noire déplacement impossible
        if [y-1,x+1] not in casesNoires:
                t1.insert(END,"")
 
 
def deplacementpossibleNoirs():
 
    ## possibilitées pionsNoirs
    if[y,x] in pionsNoirs:
        t1.delete("0.0",END)
 
        ## Déplacement pionsNoirs en bas à droite
        if [y+1,x+1] in casesNoires:
            if [y+1,x+1]not in( pionsNoirs or pionsBlancs):
                t1.insert(END,"(coup bas droite )")
 
            if [y+1,x+1] in (pionsBlancs or pionsNoirs):
                t1.insert(END,"")
 
 
 
        ## Déplacement pionsNoirs en bas à gauche
        if [y+1,x-1] in casesNoires:
            if [y+1,x-1]not in( pionsNoirs or pionsBlancs):
                t1.insert(END,"(coup bas gauche )")
            if [y+1,x-1] in (pionsBlancs or pionsNoirs):
                t1.insert(END,"")
 
 
 
 
 
### Detection des coordonnées     
# fonction de correspondance
def correspond(x,y):
    global  damier,mainFen,texto,coord
    return((y-y0)//c,(x-x0)//c)
 
def ecrire(event):
    global  damier,mainFen,texto ,sizeDamier,dimension_case,coord,x,y
 
    t.delete("0.0",END)
    t1.delete("0.0",END)
    (i,j)=correspond(event.x,event.y)
    if i in range(nb) and j in range (nb):
        t.insert(END,"click dans la case  ou i  et j vallent " + str(int(i)) + "," + str(int(j)))
    coord=[i,j]
    y=i
    x=j
 
 
    testCases()
 
 
def testCases():
 
    if started:
        deplacementpossiblesBlancs()
 
 
    if not started : 
        deplacementpossibleNoirs()
 
######################################################################################
####################################                     #############################
#################################### INTERFACE GRAPHIQUE #############################
######################################################################################
 
 
def graphInterface():
 
 
    global mainFen,texto,dimension_case,damier,t1,t,t2
 
    mainFen=Tk()
    mainFen.title("Jeu de Dame")
 
 
    ###### Demande aux joueurs leurs noms
    player1 = askstring("Initialisation de la partie", "Joueur 1 (pions blancs) :" )
    player2 = askstring("Initialisation de la partie", "Joueur 2 (pions noirs) :")
 
    while (not player1 and not player2)or(not player1 or not player2) :
        false=showerror('Saisie incorrecte', 'Votre saisie est incorrecte veuillez recommencer')
        player1 = askstring("Initialisation de la partie", "Joueur 1 (pions blancs) :" )
        player2 = askstring("Initialisation de la partie", "Joueur 2 (pions noirs) :")
 
###### Label score Noirs
    scoreNoirs=Label(mainFen,text=player2+' :(score noir) : ',fg='#4E2E12',width=75,font = "Arial 22 bold italic",bg='#D78A46')
    scoreNoirs.pack()
    t2=Text(mainFen,height=1,width=60,bg="light grey",font=("comic",18,"bold"))
    t2.pack
##### Canvas du damier
    damier=Canvas(mainFen, width=600, height=600, bg="#4E2E12",relief='solid', borderwidth=4)
    damier.pack()
 
    scoreBlancs=Label(mainFen, text=player1+' :(score blanc) : ', fg='#D78A46',relief='sunken',width=75,font = "Arial 22 bold italic",bg='#4E2E12')
    scoreBlancs.pack()
 
    boutonNewGame=Button(mainFen, text="Nouvelle Partie", command=newGame)
    boutonNewGame.pack(side=LEFT)   
 
    boutonQuitter=Button(mainFen, text="Quitter", command=mainFen.destroy)
    boutonQuitter.pack(side=RIGHT)
 
    b2=Button(mainFen,text="Commencer la partie",command=plateauSize)
    b2.pack()
 
    t1=Text(mainFen,height=1,width=60,bg="light grey",font=("comic",18,"bold"))
    t1.pack()
    t=Text(mainFen ,height=1,width=40,bg="light grey",font=("comic",18,"bold"))
    t.pack()
 
    damier.bind("<Button-1>",ecrire)    
    ######################
    ### Menu en cascade###
    ######################
    menuCascading = Menu(mainFen)  ## Créer la barre de menu
 
 
    menuFile = Menu(menuCascading)
    menuCascading.add_cascade(label = "Fichier", menu=menuFile)
    menuFile.add_command(label="Nouvelle partie",command=newGame ) 
    menuFile.add_command(label="Quitter", command=mainFen.destroy)
 
 
    menuConfig=Menu(menuCascading)
    menuCascading.add_cascade(label = "Configuration", menu=menuConfig)
    menuConfig.add_command(label="Taille du plateau", command=plateauSize)
 
    menuSauvegarde=Menu(menuCascading)
    menuCascading.add_cascade(label = "Sauvegarde", menu=menuSauvegarde)
    menuSauvegarde.add_command(label="Sauvegarder partie", command=plateauSize)
    menuSauvegarde.add_command(label="Charger partie", command=plateauSize)
 
    menuInfo=Menu(menuCascading)
    menuCascading.add_cascade(label = "Informations", menu=menuInfo)
    menuInfo.add_command(label="Règles du jeu ", command=Regles)
 
    mainFen.config(menu = menuCascading)
 
 
    mainFen.mainloop()
 
 
 
## Règles du jeu
 
def Regles():
    regle=Tk()
    regle.title('Règles du jeu ')
    regle.geometry('1000x1000+150+150')
    ##  lecture du fichier test.txt qui contient les règles du jeu de dames
 
    f=open('regle.txt','r')
    data=f.read()
 
    texte=Text(regle,fg='blue',bg='grey',width=100,height=40)
    texte.insert(END, data)
    texte.pack()
 
    boutonQuitter=Button(regle, text="Quitter", command=regle.destroy)
    boutonQuitter.pack(side=BOTTOM)
 
## paramètre de la taille du plateau
 
def plateauSize():
    plateau=Tk()
    plateau.title('Paramètres du damier')
    plateau.geometry("225x150+785+50")
    def afterPlateauSize8():
        plateau.destroy()
        damier8()
    def afterPlateauSize10():
        plateau.destroy()
        damier10()
 
    bouton8=Button(plateau, text="Damier de 8 X 8 cases", command=afterPlateauSize8)
    bouton8.pack(pady=15)
 
    bouton10=Button(plateau, text="Damier de 10 X 10 cases", command=afterPlateauSize10)
    bouton10.pack(pady=15)
 
    boutonQuitter=Button(plateau, text="Quitter", command=plateau.destroy)
    boutonQuitter.pack()
 
    plateau.mainloop()
 
 
 
 
 
## Accueil du jeux demandant de choisir si l'on souhaite jouer contre une personne ou contre l'ordinateur
 
def accueil():
    accueil=Tk()
    accueil.title("Page d'accueil")
    accueil.geometry("367x330+785+230")
 
    ## La fonction afteraccueil permet de tuer le processus de la fenètre actuelle tout en lançant la fonction d'une autre fenètre
    def afteraccueil():   
        accueil.destroy()
        graphInterface()
 
 
 
    ####### Fond d'écran de la page d'accueil
    image=Canvas(accueil,width="801",height="801")
    photo = PhotoImage(file= "DECO62.gif")
    image.create_image(40,90,image=photo)
    image.grid(row=0, column=0, rowspan=12,columnspan=12)
 
 
    humanvshuman=Button(text='Joueur contre Joueur',command=afteraccueil,font = "Arial 19 bold italic")
    humanvshuman.grid(row=1,column=1)
 
    humanvsmachine=Button(text='Joueur contre ordinateur',command=afteraccueil,font = "Arial 19 bold italic")
    humanvsmachine.grid(row=2,column=1)
 
    boutonQuitter=Button(accueil, text="Quitter", command=accueil.destroy,font = "Arial 19 bold italic")
    boutonQuitter.grid(row=3,column=1)
 
 
    accueil.mainloop()
 
 
 
## Fonction qui relance la partie
def newGame():
    mainFen.destroy()
    accueil()
 
 
### TEST
accueil()

Si vous avez des question par rapport à mon code ou par rapport à mon problème n'hésitez surtout pas.
Je vous remercie d'avance.

[Invité]

Bonjour à tous,

Je suis aujourd'hui face à un problème que je n'arrive pas à résoudre, en effet je souhaite réaliser le déplacement de mes pions. J'ai déjà réalisé les test de déplacement pour qu'à partir d'un pions donné deux pions sont crée pour représenter les possibilités.

Cependant je n'arrive pas à écrire la fonction de déplacement, je vous joins mon code ci-dessous :

(snip)(snip)

Si vous avez des question par rapport à mon code ou par rapport à mon problème n'hésitez surtout pas.
Je vous remercie d'avance.

Bonjour,

J'ai testé votre code vite fait : y a du boulot ! Bravo !

Ceci dit :

* Je ne vois pas l'intérêt de fractionner "écran d'accueil" > puis "écran principal" > puis "écran règles du jeu" > ... et caetera desunt... ?

* Pour la saisie des noms de joueurs : ne soyez pas aussi contraignant ! Après tout, ce n'est qu'un jeu => si le joueur néglige de donner son nom, mettez "Joueur1" et "Joueur2" en valeurs par défaut, les gens préféreront cela à une boucle sans fin qui leur force la main ;

* Pourquoi afficher les règles du jeu ailleurs que dans la fenêtre principale ? Que doit faire le joueur de la fenêtre principale pendant le temps de la lecture des règles du jeu ? Rien ? => ressource devenue temporairement inutile et grosse source de bugs à gérer le cas échéant => du travail inutile en plus, tout ça ;

* Utilisez des classes pour vos composants : c'est fou le nombre de jeunes qui font de l'urticaire dès qu'on leur parle de classes ! Une classe, ce n'est pas si compliqué, à la base : au pire, c'est un sac fourre-tout dans lequel vous mettez vos variables et vos fonctions en fonction du rôle que vous voulez leur faire tenir : par exemple, des variables/fonctions pour la classe Voiture n'iront pas dans une classe Hélicoptère car elles sont spécifiques à Voiture, etc ;

* En plus, l'utilisation de classes vous permettra d'y voir beaucoup plus clair dans votre code en spécialisant chaque portion de votre logiciel : une classe ReglesDuJeu dérivée de tkinter.Frame pour afficher les règles du jeu, une classe Damier dérivée de tkinter.Canvas pour gérer le damier, une autre classe Accueil dérivée de tkinter.Frame pour afficher votre écran d'accueil à l'intérieur de la fenêtre principale ;

* Créez un fichier séparé par classe : cela vous permettra de vous concentrer sur un seul problème à la fois e.g. d'abord je traite les menus dans une classe dans un fichier séparé, ensuite je traite l'écran d'accueil dans une classe dans un fichier séparé, etc, etc, vous incorporerez ensuite vos composants avec import ... dans le fichier d'application principal ;

* Dans un premier temps, vous ne devriez pas avoir besoin de plus d'un écran : la fenêtre principale ;

* Créez-vous une classe Application ou JeuDeDames - si vous préférez mieux - et qui dérive la fenêtre principale tkinter.Tk, insérez-y un conteneur de widgets type self.mainframe puis "switchez" d'un écran à l'autre à l'aide d'une petite fonctionnalité générique ;

* De plus, avec cette façon de procéder, vous n'aurez plus besoin de gérer les ressources laissées en plan qui ne servent à rien le temps que l'utilisateur réponde à un autre écran ;

* En n'affichant qu'un seul écran à la fois, vous ne dispersez pas l'attention du joueur : il a UN ET UN SEUL endroit à regarder et à interagir, c'est votre logiciel qui gère les successions d'écrans, pas l'utilisateur ;

Un exemple générique de code :

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import tkinter as TK
 
import tkinter.messagebox as MB
 
# importez ici les modules correspondant
# à chacun des composants de votre logiciel
 
import menu_principal as MENU       # correspond à menu_principal.py
 
import ecran_accueil as ACCUEIL     # correspond à ecran_accueil.py
 
import regles_du_jeu as REGLES      # correspond à regles_du_jeu.py
 
import canevas_damier as DAMIER     # correspond à canevas_damier.py
 
 
class JeuDeDames (TK.Tk):
    """Jeu de Dames - classe principale"""
 
    def __init__ (self):
        """Constructeur de la classe"""
 
        # super class inits - toujours commencer par là
 
        TK.Tk.__init__(self)
 
        # note: ici 'self' représente la fenêtre principale Tk()
 
        # member inits - composants logiciels
 
        self.mainframe = None   # conteneur principal
 
        self.topmenu = MENU.MenuPrincipal(self)
 
        self.accueil = ACCUEIL.EcranAccueil(self)
 
        self.regles_jeu = REGLES.ReglesDuJeu(self)
 
        self.damier = DAMIER.CanevasDamier(self)
 
        # la toute première fois qu'on lance l'application
        # on commence par l'écran d'accueil
 
        self.afficher_accueil()
 
    # end def
 
 
    def afficher_accueil (self):
 
        self.afficher_ecran(self.accueil)
 
        # c'est le contenu de self.accueil qui provoquera
        # le basculement vers l'écran suivant (clic bouton)
 
        self.accueil.ecran_suivant(self.afficher_damier)
 
    # end def
 
 
    def afficher_regles_du_jeu (self):
 
        self.afficher_ecran(self.regles_jeu)
 
    # end def
 
 
    def afficher_damier (self):
 
        self.afficher_ecran(self.damier)
 
    # end def
 
 
    def afficher_ecran (self, widget):
 
        if isinstance(widget, TK.Widget):
 
            if self.mainframe:
 
                self.mainframe.grid_remove()
 
            # end if - mainframe
 
            self.mainframe = widget
 
            self.mainframe.grid(row=0, column=0, in_=self)
 
            # make widget resizable
 
            self.rowconfigure(0, weight=1)
 
            self.columnconfigure(0, weight=1)
 
        # end if - TK.Widget
 
    # end def
 
    # etc, etc...
    # ne mettez dans JeuDeDames que ce qui concerne
    # les généralités du programme,
    # chaque problème spécifique étant géré par le
    # composant qui lui est dédié;
    # ex: les problèmes de damier sont traités
    # dans la classe CanevasDamier du fichier canevas_damier.py,
    # les problèmes de menu sont traités chez menu_principal.py,
    # et ainsi de suite...
    # votre code sera beaucoup plus clair et beaucoup plus facile
    # à maintenir et/ou à faire évoluer;
 
# end class JeuDeDames
 
 
# lancement du jeu
 
if __name__ == "__main__":
 
    JeuDeDames().mainloop()
 
# end if - main

Bon courage !

[Supral]

Bonjour,

je te remercie pour tes précieux conseils, je vais m'occuper de ça tout de suite.Toutefois il y a une chose que je ne comprend pas trop, ce sont les self et les classes je ne les aient jamais vu avant en cour et ne comprend donc pas leur signification, si tu pouvais me renvoyer vers une documentation ou encore m'expliquer en quoi cela consiste, cela serait parfait.
Et quant à la marche à suivre pour déplacer les pions à partir des fonctions test aurais tu une idée pour la marche à suivre?

Je te remercie énormément pour ton aide.

Cordialement.

[Invité]

Bonjour,

je te remercie pour tes précieux conseils, je vais m'occuper de ça tout de suite.Toutefois il y a une chose que je ne comprend pas trop, ce sont les self et les classes je ne les aient jamais vu avant en cour et ne comprend donc pas leur signification, si tu pouvais me renvoyer vers une documentation ou encore m'expliquer en quoi cela consiste, cela serait parfait.
Et quant à la marche à suivre pour déplacer les pions à partir des fonctions test aurais tu une idée pour la marche à suivre?

Je te remercie énormément pour ton aide.

Cordialement.

De rien, j'estime que c'est normal d'aider celles et ceux qui débutent dans ce merveilleux métier.

Une classe, c'est une sorte de paquet spécialisé dans lequel on met des propriétés (appelés membres) et des comportements (appelés méthodes).

Tout comme une voiture peut être bleue et rouler, tu peux créer un paquet class Voiture qui contienne la propriété couleur="bleu" et l'action rouler().

Une classe c'est une capsule spéciale, même si elle ne te permettra pas forcément d'aller décrocher la lune.

Pour 'self' : il s'agit du pointeur d'instance de la classe. Quand tu écris une classe, tu rédiges essentiellement des définitions (c'est du grosso modo vite fait, hein).

Ensuite, pour pouvoir exploiter ces définitions, tu dois créer un objet à partir de la définition de la classe.

Exemple :

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
class Voiture:
    COULEUR = "bleu"
    def rouler (self):
        vroum()
        vroum()
    # end def
# end class Voiture
 
# pour utiliser Voiture, je dois l'"instancier" en créant un objet
# qui contiendra une copie des propriétés comme COULEUR
# et des références aux actions comme rouler()
 
ma_caisse = Voiture()
 
print("couleur:", ma_caisse.COULEUR) # ici self=ma_caisse directement

Lorsque tu crées ton objet "ma_caisse" un pointeur d'instance "self" représente cet objet "ma_caisse" fraîchement créé à travers les définitions de ta classe "Voiture", c'est pour cela que tu vois des "self" partout dans les définitions de classe.

Tu peux considérer le pointeur d'instance "self" comme étant la logique "voilà l'objet en cours d'utilisation", objet émanant d'une copie de la classe, d'où la notion de "self" (soi-même).

Pour approfondir le sujet, je te renvoie vers le site ici présent developpez.net qui regorge de tutoriels en tout genre, que ce soit pour apprendre Python, les classes, les propriétés, les méthodes, les membres, les attributs, etc, etc.

http://python.developpez.com/faq/?page=TkinterPrerequis

http://programmation.developpez.com/cours-tutoriels/

http://python.developpez.com/cours/

Tu as évidemment aussi Goooooooooooooooooogle, Wikipedia, Wikiversité, Wikibooks et plein plein d'autres sites d'apprentissage.

Pars toujours du principe que si tu es confronté à un problème technique, quelqu'un l'a aussi été avant toi et vu le nombre d'ingénieurs qui peuplent le coin, au moins une solution a déjà dû être publiée quelque part.

Une bonne requête dans le petit moteur de recherche qui va bien et -hop!- normalement tu trouves réponse à (presque) toutes tes questions.

Et quant à la marche à suivre pour déplacer les pions à partir des fonctions test aurais tu une idée pour la marche à suivre?

Bon, je n'y connais pas grand-chose dans le jeu de dames, mais théoriquement, il suffirait de suivre cette logique :

1. créer une grille avec des cases blanches et des cases noires qui alternent l'une l'autre ;
2. placer les pions blancs sur les cases (noires?) et les pions noirs sur les cases (blanches?) face-à-face;
3. lorsque l'utilisateur clique sur un pion, montrer les directions jouables avec des flèches cliquables;
4. lorsque l'utilisateur clique sur une flèche, déplacer le pion vers le point d'arrivée;

En pratique, cela reviendrait à dire :

1. utiliser une classe Damier dérivant un tkinter.Canvas, exemple : class Damier (tkinter.Canvas) ;
2. dessiner une grille carrée de n x n cases à l'aide d'une méthode Damier.dessiner_grille(n) ;
3. la méthode utilisera sans doute canvas.create_line(...) ou canvas.create_rectangle(...) si on trace plutôt des carrés colorés pleins ;
4. initialiser les pions avec une méthode Damier.init_pions() ;
5. les pions pourront être soit des disques colorés genre canvas.create_oval(...),
6. soit des images GIF créées pour le besoin du jeu et placées avec canvas.create_image(...) ;
7. rendre le damier sensible aux clics souris : self.bind("<Button-1>", self.clics_souris) ;
8. 'self' représente ici l'objet en cours d'utilisation créé à partir de la classe Damier ;
9. la méthode Damier.clics_souris() recevra de la part de Tkinter un objet tk_event qui contiendra plein d'infos intéressantes au sujet du clic souris ;
10. il nous faudra récupérer cet objet dans les arguments de la méthode comme suit : def clics_souris (self, tk_event): ;
11. toujours dans la méthode Damier.clics_souris() on utilisera canvas.find_closest(x, y) pour déterminer quel objet a été cliqué par l'utilisateur,
12. avec (x, y) les coordonnées de la flèche de la souris fournies par l'objet tk_event dont on vient de parler ;
13. on profite de (x, y) pour calculer l'emplacement du pion sur le damier ;
14. en fonction des règles du jeu, on détermine les cases jouables dans le voisinage du pion ;
15. ensuite on vérifie que ces cases soient réellement jouables (pas déjà occupées) toujours avec canvas.find_closest(x, y) ;
16. une fois qu'on a les cases vraiment jouables, on affiche les flèches cliquables adéquates soit avec canvas.create_polygon(...)
17. soit avec des images GIF prévues à cet effet;
18. au prochain clic souris de l'utilisateur si l'objet cliqué est une flèche ou l'une ou l'autre des cases jouables, on appelle la méthode Damier.deplacer_pion(coords_destination)
19. avec coords_destination les coordonnées de la case d'arrivée ;
20. l'animation pourra se faire avec Damier.after(xxx, self.animation_pion, *arguments) ;

ça c'est pour l'algorithmique générale, après, il faut détailler chaque étape, évidemment.

@+

[Supral]

Bonjour,
je te remercie de ta précision et de tes informations malheureusement en cour nous n'avons encore jamais utilisé les classes, par conséquent je suis un peu perdu dans ce que tu m'a indiqué comme procédure à suivre, il me reste 3 semaines pour réaliser mon projet et repartir de 0 risquerait d'être périlleux.

Si tu avais une idée pour réaliser la partie déplacement à partir de mes fonctions test avec des méthodes comme celle-ci:

maliste.append([coordonnée du pion])
maliste.remove([coordonnée du pion])

Ensuite réactualiser le damier avec la nouvelle liste de coordonnée ce qui ferait un déplacement

J'avais essayé de mon coté la procédure suivante:

• Je créer un variable liste vide ou seront intégré des coordonnées temporaire correspondant aux pions possibilités

• Si l'utilisateur clique sur un pion possibilité le pion de départ et l'autre pion possibilité disparaissent

• si l'utilisateur clique sur un autre endroit du damier on laisse le pion de départ à sa place et on supprime les deux pions possibilités

Je te remercie encore pour tes réponses aussi rapides que précises, si tu as des idées pour ce que je cherche à faire qui pourrait être faite à partir de mon code actuel cela serait parfait.

Cordialement.

[Invité]

Bonjour,
je te remercie de ta précision et de tes informations malheureusement en cour nous n'avons encore jamais utilisé les classes, par conséquent je suis un peu perdu dans ce que tu m'a indiqué comme procédure à suivre, il me reste 3 semaines pour réaliser mon projet et repartir de 0 risquerait d'être périlleux.

Si tu avais une idée pour réaliser la partie déplacement à partir de mes fonctions test avec des méthodes comme celle-ci:

maliste.append([coordonnée du pion])
maliste.remove([coordonnée du pion])

Ensuite réactualiser le damier avec la nouvelle liste de coordonnée ce qui ferait un déplacement

J'avais essayé de mon coté la procédure suivante:

• Je créer un variable liste vide ou seront intégré des coordonnées temporaire correspondant aux pions possibilités

• Si l'utilisateur clique sur un pion possibilité le pion de départ et l'autre pion possibilité disparaissent

• si l'utilisateur clique sur un autre endroit du damier on laisse le pion de départ à sa place et on supprime les deux pions possibilités

Je te remercie encore pour tes réponses aussi rapides que précises, si tu as des idées pour ce que je cherche à faire qui pourrait être faite à partir de mon code actuel cela serait parfait.

Cordialement.

Ton code a évolué depuis ton premier post ici ?

Ou je peux récupérer le code du premier post pour voir ce que je peux faire ?