Bomberman tkinter python

**Exoplanet** · 24/04/2014, 11h49

Bonjour à tous !
Alors voilà tout est dans le titre, je voudrais créer un bomberman minimaliste en 2D avec :
-un seul joueur
-des cases non traversables
-des briques explosables à l'aide d'une bombe
-des bombes dont l'explosion ferait une croix de 3x3 cases
- une case d'arrivée avec passage à un second niveau similaire.

Rien de bien compliqué mai le langage qui m'est imposé est python avec le module tkinter.
J'aurais donc besoin de votre aide afin de faire déplacer une image du personnage et de gérer les collisions ainsi que si possible pour créer des bombes.

Voilà voilà si vous avez une idée de par ou commencer et qu'elles sont les méthodes à utiliser je suis tout ouïe
Merci d'avance !

**VinsS** · 24/04/2014, 12h31

Salut,

Commence par ici:
http://python.developpez.com/cours/apprendre-python3/

Tu pourras y trouver aussi un exemple de jeu de bombarde, page 275, mais ne sautes pas les étapes élémentaires.

**Exoplanet** · 27/04/2014, 14h51

Merci VinsS pour ta réponse,
Bon j'ai un peu avancé, j'ai programmer les déplacements a l'aide de boutons situés dans le canvas, mais maintenant il me faudrait empecher les déplacements pour certaines coordonnées, voici un fragment de code, ma fonction ne marche plus pourriez vous m'expliquer pourquoi ?

Code :

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

1
2
3
4
5
6
7
8
9
def move_down():
    if x1 in (0,100,200,300,400,500,600,700)== True :
        global y1,y2
        y1=y1+50
        y2=y2+50
    else :
        y1=y1
        y2=y2
    can.coords(Perso,x1,y1,x2,y2)

EDIT :
Au final j'ai trouvé, voici le code :

Code :

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

1
2
3
4
5
6
7
8
9
def move_down():
    if x1%100 == 0 :
        global y1,y2
        y1=y1+50
        y2=y2+50
    else :
        y1=y1
        y2=y2
    can.coords(Perso,x1,y1,x2,y2)

**Exoplanet** · 28/04/2014, 15h57

Bonjour a tous,J'ai un nouveau problème : Voila j'ai créé des rectangles aléatoirement dans mon canvas et je voudrais que le cercle que je deplace ne puisse pas les traverser, auriez vous une technique pour interdire a mon cercle de coordonnées x1,y1,x2,y2 de passer par les coordonnées des rectangles marrons ? Voici le 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
x1=5
y1=5
x2=45
y2=45
 
def move_down():
    if x1%100 == 5 :
        global y1,y2
        if y1<400:
            y1=y1+50
            y2=y2+50
    else :
        y1=y1
        y2=y2
    can.coords(Perso,x1,y1,x2,y2)
def move_up():
    if x1%100 == 5 :
        global y1,y2
        if y1>50:
            y1=y1-50
            y2=y2-50
    else :
        y1=y1
        y2=y2
    can.coords(Perso,x1,y1,x2,y2)
def move_left():
    if y1%100==5:
        global x1,x2
        if x1>50:
            x1=x1-50
            x2=x2-50
    else :
        x1=x1
        x2=x2
    can.coords(Perso,x1,y1,x2,y2)
def move_right():
    if y1%100==5:
        global x1,x2
        if x1<700:
            x1=x1+50
            x2=x2+50
    else:
        x1=x1
        x2=x2
    can.coords(Perso,x1,y1,x2,y2)
 
def blocs():
    a=randint(1,15)
    b=randint(1,8)
    x=a*50
    y=b*50
    if x != x1:
        can.create_rectangle(x,y,x+50,y+50,fill="brown")

**VinsS** · 28/04/2014, 17h49

Salut,

Si tu utilise global, utilise-le réellement, dans ton code, ton global est soumis à condition mais tu utilises dans tous les cas les noms x1, y1 ...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
def move_down():
    if x1%100 == 5 :
        global y1,y2    # Conditionné au if !
        if y1<400:
            y1=y1+50
            y2=y2+50
    else :
        y1=y1    # Si y1 ne change pas ce n'est pas utile !
        y2=y2    # Pareil
    can.coords(Perso,x1,y1,x2,y2)

Ceci fait la même chose:

Code :

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

1
2
3
4
5
6
7
8
9
 
def move_down():
    global x1, x2, y1, y2
    if x1%100 == 5 :
        if y1<400:
            y1=y1+50
            y2=y2+50
 
    can.coords(Perso,x1,y1,x2,y2)

Pour ta question de collision, je ne pense pas que Tkinter propose cela, d'autres frameworks le font, il faut donc que tu tiennes un dictionnaire de tes rectangles avec leurs coordonnées respectives et, dans une boucle, que tu compares la position de ton cercle par rapport aux coordonnées de chaque rectangle.

**Exoplanet** · 28/04/2014, 18h03

Seulement mes rectangles se places de manière aléatoire du coup je ne peux pas programmer leur position...

**VinsS** · 28/04/2014, 18h20

Mais si, disons que tu traces 10 rectangles:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
def blocs():
    a=randint(1,15)
    b=randint(1,8)
    x=a*50
    y=b*50
    if x != x1:
        can.create_rectangle(x,y,x+50,y+50,fill="brown")
    return x, y
 
rectangles = {}
for i in range(10):
    rectangles['rect%s' %i] = blocs()

Maintenant ton dictionnaire contient les coordonnées supérieur-gauche de chacun de tes 10 rectangles.

**Exoplanet** · 28/04/2014, 18h28

Et du coup quelle condition pourrai-je ajouter a mes déplacements pour qu'il ne se fassent pas sur les coordonnées des rectangles ? Parce que j'ai un peu de mal a saisir les trois lignes de codes que tu as rajoutées

**Exoplanet** · 05/05/2014, 23h19

Bon j'ai réussi a insérer une condition a mes déplacements pour qu'ils ne se fassent pas sur les rectangles crées aléatoirement

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
def move_right():
    global y1,y2,x1,x2,liste_blocs
    if y1%100==5:
        if x1<700:
            ytest=y1-5
            xtest=x1+50-5
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                x1=x1+50
                x2=x2+50
                can.coords(Perso,x1,y1,x2,y2)
 
def blocs():
    global liste_blocs
    a=randint(0,14)
    b=randint(0,8)
    if (a+b)%2!=0:
        if a==0 and b==0:
            return False
        else:
            x=a*50
            y=b*50
            can.create_rectangle(x,y,x+50,y+50,fill="brown")
            liste_blocs.append([x,y]) # on fait une liste des coordonnées des blocs
            return True
    else:return False

J'aimerais maintenant créer un bouton qui me permettrait de supprimer les blocs les plus proches de mon objet afin de le laisser passer, auriez vous une idée de comment faire ?

**Exoplanet** · 08/05/2014, 13h44

Bonjour a tous, voila j'ai trouver comment placer des rectangles aléatoirement, interdire leur passage a mon perso et créer un bouton pour permettre le passage des blocs a coté du personnages, seulement j'aimerais que ces blocs s'enlèvent de mon canevas qua nd je clic sur le bouton, comment faire pour supprimer un objet placé aléatoirement dans le canevas ? Merci

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
from tkinter import*
from random import*
 
############
x1=5
y1=5
x2=45
y2=45
 
def move_down():
    global y1,y2,x1,x2,liste_blocs,jeu
    if x1%100 == 5 :
        if y1<400:
            ytest=y1+45
            xtest=x1-5
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                y1=y1+50
                y2=y2+50
                can.coords(Perso,x1,y1,x2,y2)
                if x1==705 and y1==405:
                    jeu==0
def move_up():
    global y1,y2,x1,x2,liste_blocs
    if x1%100 == 5 :
        if y1>50:
            ytest=y1-55
            xtest=x1-5
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                y1=y1-50
                y2=y2-50
                can.coords(Perso,x1,y1,x2,y2)
def move_left():
    global y1,y2,x1,x2,liste_blocs
    if y1%100==5:
        if x1>50:
            ytest=y1-5
            xtest=x1-55
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                x1=x1-50
                x2=x2-50
                can.coords(Perso,x1,y1,x2,y2)
def move_right():
    global y1,y2,x1,x2,liste_blocs,jeu
    if y1%100==5:
        if x1<700:
            ytest=y1-5
            xtest=x1+50-5
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                x1=x1+50
                x2=x2+50
                can.coords(Perso,x1,y1,x2,y2)
                if x1==705 and y1==405:
                    jeu==0
def blocs():
    global liste_blocs
    a=randint(0,14)
    b=randint(0,8)
    if (a+b)%2!=0:
        if a==0 and b==0:
            return False
        else:
            x=a*50
            y=b*50
            can.create_rectangle(x,y,x+50,y+50,fill="brown")
            liste_blocs.append([x,y]) # on fait une liste des coordonnées des blocs
            return True
    else:return False
 
def bloc_destroy():
    global y1,y2,x1,x2,liste_blocs
    if [x1+45,y1-5] in liste_blocs:
        liste_blocs.remove([x1+45,y1-5]) #carré a droite
        can.create_rectangle(x1+45,y1-5,x1+95,y1+45,fill="white")
 
 
    if [x1-5,y1+45] in liste_blocs:
       liste_blocs.remove([x1-5,y1+45]) #carré en bas
       can.create_rectangle(x1-5,y1+45,x1+45,y1+95,fill="white")
 
    if [x1-55,y1-5] in liste_blocs:
        liste_blocs.remove([x1-55,y1-5])#carré a gauche
        can.create_rectangle(x1-55,y1-5,x1-5,y1+45,fill="white")
 
    if [x1-5,y1-55] in liste_blocs:
        liste_blocs.remove([x1-5,y1-55])#carré en haut
        can.create_rectangle(x1-5,y1-55,x1+45,y1-5,fill="white")
 
 
 
 
 
 
################
liste_blocs=[]
 
 
root = Tk()
jeu=1
can = Canvas(root, height=450, width=750)
 
for i in range (9):
    can.create_line(0,i*50,750,i*50)
for i in range (15):
    can.create_line(50*i,0,50*i,450)
 
for i in range (4):
    can.create_rectangle(50,50+100*i,100,100+100*i,fill='grey')
    can.create_rectangle(150,50+100*i,200,100+100*i,fill='grey')
    can.create_rectangle(250,50+100*i,300,100+100*i,fill='grey')
    can.create_rectangle(350,50+100*i,400,100+100*i,fill='grey')
    can.create_rectangle(450,50+100*i,500,100+100*i,fill='grey')
    can.create_rectangle(550,50+100*i,600,100+100*i,fill='grey')
    can.create_rectangle(650,50+100*i,700,100+100*i,fill='grey')
i=0
while i<40:
    test=blocs()
    if test==True:
        i=i+1
print(liste_blocs)    
Perso = can.create_oval(x1,y1,x2,y2)
if jeu==0:
    can.delete(ALL)
    print ("Gagné !")
 
 
 
 
 
 
 
bouPersoUP=Button(root,text="Haut",command=move_up)
bouPersoDOWN=Button(root,text="Bas",command=move_down)
bouPersoLEFT=Button(root,text="Gauche",command=move_left)
bouPersoRIGHT=Button(root,text="Droit",command=move_right)
bouSuppBloc=Button(root,text="Faites place !",command=bloc_destroy)
 
bouPersoUP.grid(column=50,row=76)
bouPersoDOWN.grid(column=50,row=78)
bouPersoLEFT.grid(column=49,row=77)
bouPersoRIGHT.grid(column=51,row=77)
bouSuppBloc.grid(column=52,row=77)
 
 
can.grid(column=0,row=0,rowspan=75,columnspan=100)
 
###############
root.mainloop()

Invité · 08/05/2014, 15h28

Envoyé par Exoplanet

Bonjour a tous, voila j'ai trouver comment placer des rectangles aléatoirement, interdire leur passage a mon perso et créer un bouton pour permettre le passage des blocs a coté du personnages, seulement j'aimerais que ces blocs s'enlèvent de mon canevas qua nd je clic sur le bouton, comment faire pour supprimer un objet placé aléatoirement dans le canevas ? Merci

Bonjour,

Voici de quoi s'inspirer :

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import random
 
import tkinter as TK
 
 
 
def init_jeu ():
 
    global blocs
 
    blocs = dict()
 
    for i in range(7):
 
        ajouter_bloc_aleatoire(blocs)
 
    # end for
 
# end def
 
 
 
def ajouter_bloc_aleatoire (blocs):
 
    taille_bloc = 50
 
    while True:
 
        x = taille_bloc * random.randint(0, 5)
 
        y = taille_bloc * random.randint(0, 5)
 
        if (x, y) not in blocs:
 
            blocs[(x, y)] = canvas.create_rectangle(
 
                x, y,
 
                x + taille_bloc, y + taille_bloc,
 
                fill="blue",
            )
 
            break
 
        # end if
 
    # end while
 
# end def
 
 
 
def clic_souris (tkevent):
 
    x, y = tkevent.x, tkevent.y
 
    canvas_items = canvas.find_overlapping(x, y, x, y)
 
    if canvas_items:
 
        bloc_id = canvas_items[0]
 
        enlever_bloc(bloc_id)
 
    # end if
 
# end def
 
 
 
def enlever_bloc (bloc_id):
 
    canvas.delete(bloc_id)
 
# end def
 
 
 
root = TK.Tk()
 
root.resizable(width=False, height=False)
 
canvas = TK.Canvas(root, width=300, height=300, bg="white")
 
canvas.bind("<Button-1>", clic_souris)
 
canvas.pack()
 
TK.Label(root, text="Cliquez sur un bloc pour l'enlever").pack()
 
TK.Button(root, text="Quitter", command=root.quit).pack()
 
init_jeu()
 
root.mainloop()

Et voici de quoi se documenter :

http://infohost.nmt.edu/tcc/help/pub...s-methods.html

Bon courage.

@+.

**Exoplanet** · 08/05/2014, 23h53

J'ai ajouté un tag au rectangle situé a droite en haut a gauche et en bas de mon cercle ainsi je peux utiliser la méthode can.delete(tag)
Seulement le code marche bien avec can.addtag_overlapping() mais pas avec can.addta_enclosed() alors que c'est exactement ce qu'il me faudrait, une idée de pourquoi ça ne marche pas ?

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
def move_down():
    pass
    global y1,y2,x1,x2,liste_blocs,newTagdroit,newTagbas,newTaggauche,newTaghaut
    if x1%100 == 5 :
        if y1<400:
            ytest=y1+45
            xtest=x1-5
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                y1=y1+50
                y2=y2+50
                can.coords(Perso,x1,y1,x2,y2)
    if x1==705:
        if y1==405:
            can.delete(ALL)
            can.create_text(225,375,text='Gagné !',font="Arial 50")
            son.stop()
    can.addtag_enclosed("newTagdroit", x1+45, y1-5, x2+55,y2+5)
    can.addtag_enclosed("newTagbas", x1-5, y1+45,x2+5,y2+55)
    can.addtag_enclosed("newTaggauche", x1-55, y1-5,x2-45,y2+5)
    can.addtag_enclosed("newTaghaut", x1-5, y1-55,x2-45,y2+5)
 
 
def move_up():
    pass
    global y1,y2,x1,x2,liste_blocs,newTagdroit,newTagbas,newTaggauche,newTaghaut
    if x1%100 == 5 :
        if y1>50:
            ytest=y1-55
            xtest=x1-5
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                y1=y1-50
                y2=y2-50
                can.coords(Perso,x1,y1,x2,y2)
    can.addtag_enclosed("newTagdroit", x1+45, y1-5, x2+55,y2+5)
    can.addtag_enclosed("newTagbas", x1-5, y1+45,x2+5,y2+55)
    can.addtag_enclosed("newTaggauche", x1-55, y1-5,x2-45,y2+5)
    can.addtag_enclosed("newTaghaut", x1-5, y1-55,x2-45,y2+5)
def move_left():
    pass
    global y1,y2,x1,x2,liste_blocs,newTagdroit,newTagbas,newTaggauche,newTaghaut
    if y1%100==5:
        if x1>50:
            ytest=y1-5
            xtest=x1-55
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                x1=x1-50
                x2=x2-50
                can.coords(Perso,x1,y1,x2,y2)
    can.addtag_enclosed("newTagdroit", x1+45, y1-5, x2+55,y2+5)
    can.addtag_enclosed("newTagbas", x1-5, y1+45,x2+5,y2+55)
    can.addtag_enclosed("newTaggauche", x1-55, y1-5,x2-45,y2+5)
    can.addtag_enclosed("newTaghaut", x1-5, y1-55,x2-45,y2+5)
def move_right():
    pass
    global y1,y2,x1,x2,liste_blocs,newTagdroit,newTagbas,newTaggauche,newTaghaut
    if y1%100==5:
        if x1<700:
            ytest=y1-5
            xtest=x1+50-5
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                x1=x1+50
                x2=x2+50
                can.coords(Perso,x1,y1,x2,y2)
    if x1==705:
        if y1==405:
            can.delete(ALL)
            can.create_text(350,250,text='Gagné !',font="Arial 50")
            son.stop()
    can.addtag_enclosed("newTagdroit", x1+45, y1-5, x2+55,y2+5)
    can.addtag_enclosed("newTagbas", x1-5, y1+45,x2+5,y2+55)
    can.addtag_enclosed("newTaggauche", x1-55, y1-5,x2-45,y2+5)
    can.addtag_enclosed("newTaghaut", x1-5, y1-55,x2+5,y2-45)
def blocs():
    global liste_blocs,obs
    a=randint(0,14)
    b=randint(0,8)
    if (a+b)%2!=0:
        if a==0 and b==0:
            return False
        else:
            x=a*50
            y=b*50
            can.create_rectangle(x,y,x+50,y+50,fill="brown")
            liste_blocs.append([x,y]) # on fait une liste des coordonnées des blocs
            return True
    else:return False
 
def bloc_destroy():
    global y1,y2,x1,x2,liste_blocs,obs
    if [x1+45,y1-5] in liste_blocs:
        liste_blocs.remove([x1+45,y1-5]) #carré a droite
        #can.create_rectangle(x1+45,y1-5,x1+95,y1+45,fill="white")
        can.delete("newTagdroit")
 
    if [x1-5,y1+45] in liste_blocs:
       liste_blocs.remove([x1-5,y1+45]) #carré en bas
       #can.create_rectangle(x1-5,y1+45,x1+45,y1+95,fill="white")
       can.delete("newTagbas")
 
    if [x1-55,y1-5] in liste_blocs:
        liste_blocs.remove([x1-55,y1-5])#carré a gauche
        #can.create_rectangle(x1-55,y1-5,x1-5,y1+45,fill="white")
        can.delete("newTaggauche")
 
    if [x1-5,y1-55] in liste_blocs:
        liste_blocs.remove([x1-5,y1-55])#carré en haut
        #can.create_rectangle(x1-5,y1-55,x1+45,y1-5,fill="white")
        can.delete("newTaghaut")

EDIT : En fait j'ai trouver, il faut que les coordonnées du rectangle de addtag_enclosed soit supérieur a celle de l'objet compris dedans, du coup c'est bon tout marche pour le mieux

**Exoplanet** · 08/05/2014, 23h57

AH et merci tarball de ta réponse, je suis tellement dans le speed que j'en oublie la politesse

Invité · 09/05/2014, 09h39

Envoyé par Exoplanet

J'ai ajouté un tag au rectangle situé a droite en haut a gauche et en bas de mon cercle ainsi je peux utiliser la méthode can.delete(tag)
Seulement le code marche bien avec can.addtag_overlapping() mais pas avec can.addta_enclosed() alors que c'est exactement ce qu'il me faudrait, une idée de pourquoi ça ne marche pas ?

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
def move_down():
    pass
    global y1,y2,x1,x2,liste_blocs,newTagdroit,newTagbas,newTaggauche,newTaghaut
    if x1%100 == 5 :
        if y1<400:
            ytest=y1+45
            xtest=x1-5
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                y1=y1+50
                y2=y2+50
                can.coords(Perso,x1,y1,x2,y2)
    if x1==705:
        if y1==405:
            can.delete(ALL)
            can.create_text(225,375,text='Gagné !',font="Arial 50")
            son.stop()
    can.addtag_enclosed("newTagdroit", x1+45, y1-5, x2+55,y2+5)
    can.addtag_enclosed("newTagbas", x1-5, y1+45,x2+5,y2+55)
    can.addtag_enclosed("newTaggauche", x1-55, y1-5,x2-45,y2+5)
    can.addtag_enclosed("newTaghaut", x1-5, y1-55,x2-45,y2+5)
 
 
def move_up():
    pass
    global y1,y2,x1,x2,liste_blocs,newTagdroit,newTagbas,newTaggauche,newTaghaut
    if x1%100 == 5 :
        if y1>50:
            ytest=y1-55
            xtest=x1-5
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                y1=y1-50
                y2=y2-50
                can.coords(Perso,x1,y1,x2,y2)
    can.addtag_enclosed("newTagdroit", x1+45, y1-5, x2+55,y2+5)
    can.addtag_enclosed("newTagbas", x1-5, y1+45,x2+5,y2+55)
    can.addtag_enclosed("newTaggauche", x1-55, y1-5,x2-45,y2+5)
    can.addtag_enclosed("newTaghaut", x1-5, y1-55,x2-45,y2+5)
def move_left():
    pass
    global y1,y2,x1,x2,liste_blocs,newTagdroit,newTagbas,newTaggauche,newTaghaut
    if y1%100==5:
        if x1>50:
            ytest=y1-5
            xtest=x1-55
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                x1=x1-50
                x2=x2-50
                can.coords(Perso,x1,y1,x2,y2)
    can.addtag_enclosed("newTagdroit", x1+45, y1-5, x2+55,y2+5)
    can.addtag_enclosed("newTagbas", x1-5, y1+45,x2+5,y2+55)
    can.addtag_enclosed("newTaggauche", x1-55, y1-5,x2-45,y2+5)
    can.addtag_enclosed("newTaghaut", x1-5, y1-55,x2-45,y2+5)
def move_right():
    pass
    global y1,y2,x1,x2,liste_blocs,newTagdroit,newTagbas,newTaggauche,newTaghaut
    if y1%100==5:
        if x1<700:
            ytest=y1-5
            xtest=x1+50-5
            if [xtest,ytest] in liste_blocs:
                return 
            else:
                x1=x1+50
                x2=x2+50
                can.coords(Perso,x1,y1,x2,y2)
    if x1==705:
        if y1==405:
            can.delete(ALL)
            can.create_text(350,250,text='Gagné !',font="Arial 50")
            son.stop()
    can.addtag_enclosed("newTagdroit", x1+45, y1-5, x2+55,y2+5)
    can.addtag_enclosed("newTagbas", x1-5, y1+45,x2+5,y2+55)
    can.addtag_enclosed("newTaggauche", x1-55, y1-5,x2-45,y2+5)
    can.addtag_enclosed("newTaghaut", x1-5, y1-55,x2+5,y2-45)
def blocs():
    global liste_blocs,obs
    a=randint(0,14)
    b=randint(0,8)
    if (a+b)%2!=0:
        if a==0 and b==0:
            return False
        else:
            x=a*50
            y=b*50
            can.create_rectangle(x,y,x+50,y+50,fill="brown")
            liste_blocs.append([x,y]) # on fait une liste des coordonnées des blocs
            return True
    else:return False
 
def bloc_destroy():
    global y1,y2,x1,x2,liste_blocs,obs
    if [x1+45,y1-5] in liste_blocs:
        liste_blocs.remove([x1+45,y1-5]) #carré a droite
        #can.create_rectangle(x1+45,y1-5,x1+95,y1+45,fill="white")
        can.delete("newTagdroit")
 
    if [x1-5,y1+45] in liste_blocs:
       liste_blocs.remove([x1-5,y1+45]) #carré en bas
       #can.create_rectangle(x1-5,y1+45,x1+45,y1+95,fill="white")
       can.delete("newTagbas")
 
    if [x1-55,y1-5] in liste_blocs:
        liste_blocs.remove([x1-55,y1-5])#carré a gauche
        #can.create_rectangle(x1-55,y1-5,x1-5,y1+45,fill="white")
        can.delete("newTaggauche")
 
    if [x1-5,y1-55] in liste_blocs:
        liste_blocs.remove([x1-5,y1-55])#carré en haut
        #can.create_rectangle(x1-5,y1-55,x1+45,y1-5,fill="white")
        can.delete("newTaghaut")

EDIT : En fait j'ai trouver, il faut que les coordonnées du rectangle de addtag_enclosed soit supérieur a celle de l'objet compris dedans, du coup c'est bon tout marche pour le mieux

Bonjour,

les tags de canvasItems c'est très bien quand on traite un groupe de canvasItems.

en revanche, quand on veut supprimer un seul bloc précisément, il vaut mieux recourir à son numéro d'identifiant ID (fourni au moment de sa création par id = canvas.create_rectangle()), identifiant ID qui -lui- est vraiment unique pour chaque bloc dessiné.

autrement dit, il vaut mieux faire can.delete(bloc_id) que can.delete("newTaghaut"), par exemple.

bien sûr, il faut tout d'abord récupérer bloc_id dans liste_blocs, d'où le code que je vous avais fourni précédemment, regardez bien ce que j'avais écrit dans la fonction ajouter_bloc_aleatoire().

Ensuite, par exemple :

Code :

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

1
2
3
def move_down():
    pass
    global y1,y2,x1,x2,liste_blocs,newTagdroit,newTagbas,newTaggauche,newTaghaut

pass ne sert que pour "boucher un trou" lorsque l'on n'a pas encore décidé du code que l'on va mettre dans un bloc d'instructions, exemple :

Code :

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

1
2
3
if collision(x, y):
    pass # on fournira le code plus tard et en général, on note aussi FIXME en commentaire
# end if

global ne sert que pour les variables globales que vous allez MODIFIER dans votre code.

Tant que vous accédez une variable globale en LECTURE SEULE, vous n'avez pas besoin de la mentionner.

Vous citez global ... newTag..., mais ce sont des tags de canevas graphique, pas des variables globales.

Ne laissez pas la broussaille envahir votre code : élaguez, élaguez, élaguez.

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
16
17
18
19
20
21
22
23
def move_down():
    global y1, y2 # seuls y1 et y2 sont réellement modifiés ici
    if x1 % 100 == 5 and y1 < 400:
        ytest = y1 + 45
        xtest = x1 - 5
        if [xtest, ytest] not in liste_blocs:
            y1 += 50
            y2 += 50
            #can.coords(Perso, x1, y1, x2, y2) NON
            can.move(Perso, 0, 50) # si déjà
    if x1 == 705 and y1 == 405:
        # les bonnes habitudes de programmation veulent que l'on
        # appelle une fonction par tâche distincte
        # ici, vous devriez appeler la fonction bravo()
        # et y placer le code suivant :
        can.delete(ALL)
        can.create_text(225, 375, text='Gagné !', font="Arial 50")
        son.stop()
    # ce qui suit est source de bugs (à éviter autant que possible)
    can.addtag_enclosed("newTagdroit", x1 + 45, y1 - 5, x2 + 55, y2 + 5) 
    can.addtag_enclosed("newTagbas", x1 - 5, y1 + 45, x2 + 5, y2 + 55)
    can.addtag_enclosed("newTaggauche", x1 - 55, y1 - 5, x2 - 45, y2 + 5)
    can.addtag_enclosed("newTaghaut", x1 - 5, y1 - 55, x2 - 45, y2 + 5)

@+.

Invité · 09/05/2014, 09h39

Envoyé par Exoplanet

AH et merci tarball de ta réponse, je suis tellement dans le speed que j'en oublie la politesse

De rien, nous sommes là pour ça.

**Exoplanet** · 10/05/2014, 00h54

Merci de toute tes réponses, j'en tiendrai compte dans la rédaction finale de mon programme

Juste un dernier truc pour rendre mon programme fonctionnel, pourrait tu me dire pourquoi mon can.bind() ne marche pas ? Car pour le moment j'utilise des boutons pour mes déplacements mais ce serait plus pratique avec les touches du clavier

Invité · 10/05/2014, 09h02

Envoyé par Exoplanet

Merci de toute tes réponses, j'en tiendrai compte dans la rédaction finale de mon programme

Juste un dernier truc pour rendre mon programme fonctionnel, pourrait tu me dire pourquoi mon can.bind() ne marche pas ? Car pour le moment j'utilise des boutons pour mes déplacements mais ce serait plus pratique avec les touches du clavier

Pour que can.bind() capte les événements clavier, il faut que le focus soit sur le canvas.

C'est une technique plutôt aléatoire.

Pour un jeu simple, l'idéal reste d'utiliser root.bind_all() et d'affecter les événements clavier au niveau de l'application tout entière.

Documentation :

http://infohost.nmt.edu/tcc/help/pub...universal.html

@+.