déplacement de pions jeu de dames

**Supral** · 22/03/2014, 17h54

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é · 23/03/2014, 10h02

Envoyé par 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 :

(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** · 23/03/2014, 10h25

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é · 23/03/2014, 13h25

Envoyé par 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.

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** · 23/03/2014, 15h50

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é · 23/03/2014, 16h00

Envoyé par 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.

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 ?

**Supral** · 23/03/2014, 16h04

Tu peux récupérer le premier code je n'ai pas du tout réussis à avancer depuis.
je te remercie de l'attention que tu portes à mon travail.
Cordialement.

Invité · 23/03/2014, 18h03

Envoyé par Supral

Tu peux récupérer le premier code je n'ai pas du tout réussis à avancer depuis.
je te remercie de l'attention que tu portes à mon travail.
Cordialement.

Bon, j'ai essayé ce que j'ai pu, mais désolé : le code est vraiment trop illisible pour moi.

Tu utilises des globales de partout, souvent nommées avec une seule lettre, du coup, on ne sait pas qui fait quoi ni qui vient d'où ?

L'intérêt d'une fonction, c'est de lui passer en arguments ce dont elle a besoin pour son traitement.

Au lieu d'écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
def ma_fonction ():
    global x,y,l,t,u,p,n,e
    # à partir de là, quiconque n'est pas dans ta tête
    # ne comprend plus rien

Ecris plutôt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
def ma_fonction (coordonnees, taille_case, nb_cases, etc):
 
    # extraction des coordonnées
 
    x, y = coordonnees
 
    # init dimensions grille
 
    grille_largeur = grille_hauteur = nb_cases * taille_case
 
    # etc...

Ne perds pas de vue que le code n'est pas fait pour être écrit, il est avant tout fait pour être RELU et même le plus souvent RELU PAR D'AUTRES que toi.

Donc si tu ne fais pas un effort de clarification, ton code fonctionnera peut-être, mais il sera IMPOSSIBLE à maintenir par quiconque repassera après toi - ou même juste pour te donner un coup de main.

Du moins, pas sans un remaniement en profondeur du code, qui fera perdre beaucoup de temps à la personne qui interviendra.

Si à chaque fois que quelqu'un s'assoit devant ton code, tu es obligé de lui expliquer ce que tu as fait ou même voulu faire, alors quelque chose ne va pas : ton code devrait s'expliquer de lui-même, non seulement avec suffisamment de commentaires à chaque étape, mais aussi et surtout avec un choix dans les noms de variables et de fonctions qui ne soient pas inutilement abrégés, obscurs ou sibyllins.

OK, j'ai vu que pour le moment, tu remplaces les classes par des grosses fonctions qui en contiennent des plus petites, mais même là, tu ne délègues pas assez les tâches.

Du coup, les fonctions s'allongent interminablement et deviennent illisibles.

Essaie de "ramasser" un peu plus ton code.

Au lieu d'écrire :

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

Va à l'essentiel, délègue les tâches :

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
def graphInterface ():
 
    # c'est qui ceux-là ? avons-nous été présentés ?
    # d'où ils sortent ? où ils vont ? que veux-tu faire avec ?
 
    global mainFen, texto, dimension_case, damier, t1, t, t2
 
    # création fenêtre principale
 
    mainFen = Tk()
 
    mainFen.title("Jeu de Dames")
 
    # demander aux joueurs leurs noms
 
    player1, player2 = demander_noms_joueurs()
 
    # mise en place des éléments graphiques
 
    init_scores(mainFen)
 
    init_damier(mainFen)
 
    init_boutons(mainFen)
 
    # création menus
 
    init_menus(mainFen)
 
    # boucle principale de la fenêtre
 
    mainFen.mainloop()

N'aie pas peur de sauter des lignes entre chaque instruction : un code aéré, ça sent moins le renfermé.

Dans la belle théorie, on devrait pouvoir lire ton code comme on lit un journal. Enfin, ouais, c'est la belle théorie, quoi.

Disons qu'on essaie tous de viser cet objectif au mieux.

En tout cas, pour le moment, ce code est trop brouillon pour moi, je n'arrive même pas à lire le déroulement algorithmique du programme.

Désolé, je ne peux pas t'aider plus que ça.

@+

**Supral** · 23/03/2014, 18h06

D'accord, je te remercie de ta patience et de tes explications. J'essaierais à l'avenir de faire selon ta méthode.

Cordialement

Invité · 23/03/2014, 18h10

Envoyé par Supral

D'accord, je te remercie de ta patience et de tes explications. J'essaierais à l'avenir de faire selon ta méthode.

Cordialement

Je précise, ce n'est pas MA méthode : c'est l'expérience et le travail en équipe qui mènent vers ces contraintes.

Tous les professionnels te le diront : le code, c'est fait surtout pour être relu, bien plus que pour être écrit.

Bon courage. @+

**Supral** · 23/03/2014, 18h12

Merci pour tes conseils je vais essayer de les appliquer au mieux.
A plus .

**Supral** · 23/03/2014, 19h04

Bonsoir, j'aurais une dernière question qui est la suivante.

Comment réaliser une fonction qui si l'utilisateur clique sur un objet du canvas celui-ci disparaisse.

je m'explique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
def circle():
 
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
 
def testClic():
 ## Instructions pour vérifier si un clic est fait sur hautdroit, si ce clic est fait on le supprime

Mon problème est la façon de réaliser la condition je ne vois pas comment l'écrire.
Je te remercie pour ta patience

Invité · 23/03/2014, 20h54

Envoyé par Supral

Bonsoir, j'aurais une dernière question qui est la suivante.

Comment réaliser une fonction qui si l'utilisateur clique sur un objet du canvas celui-ci disparaisse.

je m'explique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
def circle():
 
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
 
def testClic():
 ## Instructions pour vérifier si un clic est fait sur hautdroit, si ce clic est fait on le supprime

Mon problème est la façon de réaliser la condition je ne vois pas comment l'écrire.
Je te remercie pour ta patience

N'hésite pas à lâcher ton fichier programme principal pour aller tester une idée dans un fichier test.py à part (on appelle ça faire un test sur un coin de table).

Crée-toi un fichier test.py et mets-y uniquement ce que tu veux étudier :

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import tkinter as TK
 
# création fenêtre principale
 
fenetre = TK.Tk()
 
# pas de chichis, on va à l'essentiel
 
canevas = TK.Canvas(
 
    fenetre,
 
    bg="black",
 
    width=400,
 
    height=300,
)
 
# on affiche le canevas étendu autant que possible dans la fenêtre
 
canevas.pack(expand=1, fill=TK.BOTH)
 
 
# on dessine un disque dans le canevas
 
diametre = 50
 
x = (canevas.winfo_reqwidth() - diametre) / 2      # pour centrer l'objet
 
y = (canevas.winfo_reqheight() - diametre) / 2     # par rapport au canevas
 
# tracé du disque
 
id_disque = canevas.create_oval(
 
    x, y, (x + diametre), (y + diametre),
 
    fill="yellow", outline="blue", width=5,
)
 
# on peut laisser une trace dans la console pour vérifications
 
print("ID du disque créé :", id_disque)
 
 
# on définit un gestionnaire de clics de souris
# qui va récupérer l'objet tk_event envoyé par Tkinter
# lors d'un clic de souris
 
def clics_souris (tk_event):
 
    # on récupère les coordonnées de la flèche de la souris
 
    _x, _y = tk_event.x, tk_event.y
 
    # on peut laisser une trace dans la console pour vérifications
 
    print("coords souris (x, y) = ({0}, {1})".format(_x, _y))
 
    # on essaie de récupérer l'objet se trouvant à ces coordonnées
    # NOTE: la méthode canevas.find_closest(x,y) semble déconner;
    # je la remplace par .find_overlapping() qui -elle- fonctionne;
 
    item_id = canevas.find_overlapping(_x, _y, _x, _y)
 
    # trace pour vérifier
 
    print("ID de l'objet trouvé à cet endroit :", item_id)
 
    # avons-nous un objet à cet endroit ?
 
    if item_id:
 
        # on demande au canevas de le retirer (delete = supprimer)
 
        canevas.delete(item_id)
 
        # à partir de là, l'objet est *définitivement* effacé
        # du canevas, il ne sera plus possible de le récupérer
        # par la suite;
 
    # end if - item_id
 
# end def
 
 
# le gestionnaire est défini : on peut l'utiliser maintenant
 
canevas.bind("<Button-1>", clics_souris)
 
# on ajoute un bouton quitter pour se faciliter la vie
 
TK.Button(fenetre, text="Quitter", command=fenetre.quit).pack()
 
# boucle fenêtre principale
 
fenetre.mainloop()

Note : ce test en coin de table a permis de lever un problème : la méthode canvas.find_closest(x,y) semble déconner complètement.

Qu'on clique sur l'objet ou à perpète les oies, c'est kif-kif la bourrique, cette méthode détecte toujours l'objet au centre du canevas (!)

Du coup, j'ai testé canvas.find_overlapping(x,y,x,y) qui me paraissait une bonne alternative au problème.

C'était ça que tu voulais résoudre ?

@+

**Supral** · 23/03/2014, 21h08

Je te remercie c'est parfaitement ce que je souhaitais faire il me faut maintenant l'adapter à mon code pour faire ce que je souhaite .
Encore merci pour m'avoir autant aider .
Bonne soirée.
Cordialement.

**Benzo_** · 22/04/2015, 15h09

Bonjour , je suis bloqué dans mon programme d'isn qui consiste a creer un jeu de dame version anglaise , le seul probleme c'est que nous sommes bloqués au niveau des déplacements. Est ce que quelqu'un pourrait nous aider s'il vous plait ?
Merci.

**Supral** · 22/04/2015, 18h38

Bonjour ,

Concernant le déplacement des pions et des dames, il est nécessaire de visualiser ton plateau comme une matrice (en python une liste de liste par exemple) comme l'exemple ci-dessous :

[ [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] ]
Ainsi cette matrice qui aurait pour abscisse x et pour ordonnée y permettrait un accès aux différentes cases.

Un déplacement du pion (pion se trouvant en bas du plateau et devant aller vers le haut du plateau) en haut à droite correspondrait à une modification de ses coordonnées en x+1, y+1.

Après un changement de coordonnées d'une pièce il suffit d'afficher à nouveau le plateau avec les déplacements effectués.

Si tu as d'autres questions concernant ce que je viens d'expliquer, n'hésites pas. Sinon essaye de nous montrer ce que tu as déjà fait pour que l'on puisse voir par rapport à ton code.

Bon courage

**Benzo_** · 22/04/2015, 21h59

Bonsoir!
Je vous remercie , je vois de quoi vous voulez parler.On a fait ça pour le pionNoirs, on a fait y+1 et x+1 mais quand on essaye pour le blanc on doit faire y-1 et x-1 ca n'as pas fonctionné. Notre seul probleme c'est que nous voulons , par exemple c'est que le pion Blanc ne se déplace seulement de bas gauche et bas droit , car pour le moment il se déplace partout sur le plateau appart les cases interdites bien-sur ,contrairement au pion noir il se déplace de haut gauche et haut droit Avant tout , je vous explique un peu:
Le Clics[l-2] est le premier clique c'est a dire celui qui selectionne le Pion , et le clics[l-1] est le deuxieme qui , donc celui qui déplace notre pion.

Sinon est ce que je pourrai vous contacter via mails pour vous envoyer le programme ? Car je suis en Terminal S en ISN et j'ai peur que mon professeur croit que j'ai fait un simple copier coller de mon programme

Merciiii

**Supral** · 22/04/2015, 22h14

Envoyé par Benzo_

Bonsoir!
Je vous remercie , je vois de quoi vous voulez parler.On a fait ça pour le pionNoirs, on a fait y+1 et x+1 mais quand on essaye pour le blanc on doit faire y-1 et x-1 ca n'as pas fonctionné. Notre seul probleme c'est que nous voulons , par exemple c'est que le pion Blanc ne se déplace seulement de bas gauche et bas droit , car pour le moment il se déplace partout sur le plateau appart les cases interdites bien-sur ,contrairement au pion noir il se déplace de haut gauche et haut droit Avant tout , je vous explique un peu:
Le Clics[l-2] est le premier clique c'est a dire celui qui selectionne le Pion , et le clics[l-1] est le deuxieme qui , donc celui qui déplace notre pion.

Sinon est ce que je pourrai vous contacter via mails pour vous envoyer le programme ? Car je suis en Terminal S en ISN et j'ai peur que mon professeur croit que j'ai fait un simple copier coller de mon programme

Merciiii

Renvoyez moi par MP votre code je vais regarder et vous dire ce que j'en pense j'ai pour le moment du mal à comprendre l'histoire des clics.