Discussion :

[Kazvert]

Bonjour,

J'essaye de faire un canvas avec une boule que je contrôle avec les flèches directionnelles et un nombre indéfini de boules qui bougent tant qu'elles sont dans le terrain selon un vecteur prédéfini .

Le point bloquant : la boule automatique continue en boucle sans que le graphe ne soit mis à jour entre chaque loop. Du coup, je ne vois le graphe que lorsque la boule est arrivée en bout de course

Par ailleurs, je n'arrive pas à faire un pattern MVC avec tkinter.

Le controller pour moi sont les flèches directionnelles qui sont définies en même temps que le GUI qui est la vue. Le modèle, c'est la carte et les positions des boules. Je n'ai pas trouvé d'exemple concret avec Tkinter et ne vois pas comment dissocier le GUI de l'event.

Pouvez vous m'indiquer un site avec des codes en POO et Tkinter ? Dans la plupart des exemples que j'ai trouvé, il n'y a qu'une unique classe dans le code et ce n'est pas vraiment de la POO

PS wiztricks : depuis la dernière fois, je me suis renseigné d'avantage sur la POO, je comprends mieux les différents liens entre objets possibles (association, agrégation, dépendance, composition, héritage)

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
from tkinter import Tk, Canvas
from numpy import zeros
 
CASE_SIZE = 20
BALL_SIZE = 8 # radius
 
MOTIONS = {
            'Up':   (0, -1),
            'Down': (0, 1),
            'Left': (-1, 0),
            'Right':(1, 0)
           }
 
class Map():
 
    def __init__(self):
        self.map_game = zeros((10,10))
 
    def get_map(self):
        return self.map_game
 
class Ball():    
 
    def __init__(self,object_map,ball_pos,color,moving_status):      
        self.object_map = object_map
        self.ball_pos = ball_pos  
        self.color = color
        self.moving_status = moving_status         
        self.graphic = None 
 
    def check_map(self,vector_dir):
        map_size = self.object_map.get_map()
        row = self.ball_pos[0] + vector_dir[1] 
        col = self.ball_pos[1] + vector_dir[0]
 
        if col >= 0 and col < map_size.shape[1] and \
            row >= 0 and row < map_size.shape[0]:
                return True           
 
    def set_pos(self,vector_dir,ball_number):
        self.ball_pos = [self.ball_pos[0]+vector_dir[1],self.ball_pos[1]+vector_dir[0]]
        self.graphic.update_graphic(vector_dir,ball_number)
 
    def get_pos(self):
        return self.ball_pos 
 
    def get_color(self):
        return self.color
 
    def get_moving_status(self):
        return self.moving_status
 
class GUI():
 
    def __init__(self,map_object, root,list_ball = None):
        self.init_canvas(root, map_object)
        self.init_balls(list_ball)
 
    def init_canvas(self,root, map_object):
        self.root = root       
        map_size = map_object.get_map()
        lar = map_size.shape[0]*CASE_SIZE
        hau = map_size.shape[1]*CASE_SIZE  
 
        self.can_game = Canvas(self.root,width=lar,height=hau,bg="black")
        self.can_game.pack(padx=10,pady=10)
        self.can_game.focus_set() 
 
    def init_balls(self,list_ball):
        self.list_ball = list_ball
 
        self.object_list = list_ball
        self.object_graphic_list = []
 
        for elt in self.object_list:
            graphic_ball = self.ball_creation(elt.get_pos(),elt.get_color())
            self.object_graphic_list.append(graphic_ball)                
            elt.graphic = self
 
            if elt.get_moving_status() == 1:   
                self.ball = elt 
                for key in MOTIONS:
                    self.can_game.bind('<%s>' % key, self.keyboard_event)
 
    def ball_creation(self,pos,coul):
        row = pos[0]
        col = pos[1]
        return self.cercle(col*CASE_SIZE+CASE_SIZE/2,row*CASE_SIZE+CASE_SIZE/2, BALL_SIZE,coul) 
 
    def cercle(self,x, y, r, coul ='black'):
        boule = self.can_game.create_oval(x-r, y-r, x+r, y+r, fill=coul) 
        return boule
 
    def keyboard_event(self,event):
        vector_dir = MOTIONS[event.keysym]
        if self.ball.check_map(vector_dir):
            self.ball.set_pos(vector_dir,0)
 
    def init_auto_balls(self,ball_number,init_vector):
        considered_ball = self.object_list[ball_number]
        if considered_ball.check_map(init_vector):            
            considered_ball.set_pos(init_vector,ball_number) 
            self.can_game.after(1000,self.init_auto_balls(ball_number,init_vector))
 
    def update_graphic(self,vector_dir,ball_number): 
        self.can_game.move(self.object_graphic_list[ball_number],vector_dir[0]*CASE_SIZE,vector_dir[1]*CASE_SIZE) 
 
# --- Main ---
 
root = Tk()
object_map = Map()
ball1 = Ball(object_map,(0,0),'yellow',1)
ball2 = Ball(object_map,(8,8),'red',0)
 
GUI_object = GUI(object_map,root,[ball1,ball2])
GUI_object.init_auto_balls(1,(-1,0))
root.mainloop()

[Kazvert]

J'ai aussi essayé de changer la structure du programme. Le GUI est le premier objet crée. Le problème reste le meme

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
from tkinter import Tk, Canvas
from numpy import zeros
 
CASE_SIZE = 20
BALL_SIZE = 8 # radius
 
MOTIONS = {
            'Up':   (0, -1),
            'Down': (0, 1),
            'Left': (-1, 0),
            'Right':(1, 0)
           }
 
class Application():
 
    def __init__(self,map_object, root):
        self.init_canvas(root, map_object)
        self.manual_ball = None
 
    def init_canvas(self,root, map_object):
        self.root = root       
        map_size = map_object.get_map()
        lar = map_size.shape[0]*CASE_SIZE
        hau = map_size.shape[1]*CASE_SIZE  
 
        self.can_game = Canvas(self.root,width=lar,height=hau,bg="black")
        self.can_game.pack(padx=10,pady=10)
        self.can_game.focus_set() 
 
    def init_manual_ball(self):    
        for key in MOTIONS:
            self.can_game.bind('<%s>' % key, self.keyboard_event)  
 
    def ball_creation(self,pos,coul):
        row = pos[0]
        col = pos[1]
        return self.cercle(col*CASE_SIZE+CASE_SIZE/2,row*CASE_SIZE+CASE_SIZE/2, BALL_SIZE,coul) 
 
    def cercle(self,x, y, r, coul ='black'):
        boule = self.can_game.create_oval(x-r, y-r, x+r, y+r, fill=coul) 
        return boule
 
    def keyboard_event(self,event):         
        vector_dir = MOTIONS[event.keysym]
        self.manual_ball.set_pos(vector_dir)
 
    def init_auto_balls(self,ball_number,init_vector):
        considered_ball = self.object_list[ball_number]
        if considered_ball.check_map(init_vector):            
            considered_ball.set_pos(init_vector,ball_number) 
            self.can_game.after(300,self.init_auto_balls(ball_number,init_vector))
 
    def update_graphic(self,vector_dir,object_to_move): 
        self.can_game.move(object_to_move,vector_dir[0]*CASE_SIZE,vector_dir[1]*CASE_SIZE) 
 
class Map():
 
    def __init__(self):
        self.map_game = zeros((10,10))
 
    def get_map(self):
        return self.map_game
 
class Ball():    
 
    def __init__(self,object_map,ball_pos,color,moving_status,app): 
        self.app = app
        self.object_map = object_map
        self.ball_pos = ball_pos  
        self.color = color
        self.moving_status = moving_status 
 
        self.graphic_ball = self.app.ball_creation(ball_pos,color)
 
        if self.moving_status == 1:    
            self.app.manual_ball = self
            self.app.init_manual_ball()  
        else:
            self.automatic_move((-1,0))                      
 
    def check_map(self,vector_dir):
        map_size = self.object_map.get_map()
        row = self.ball_pos[0] + vector_dir[1] 
        col = self.ball_pos[1] + vector_dir[0]
 
        if col >= 0 and col < map_size.shape[1] and \
            row >= 0 and row < map_size.shape[0]:
                return True 
 
    def automatic_move(self,vector):
        self.set_pos(vector) 
        if self.check_map(vector):
            self.app.can_game.after(1000, self.automatic_move(vector))    
 
    def set_pos(self,vector_dir):
        if self.check_map(vector_dir):
            self.ball_pos = [self.ball_pos[0]+vector_dir[1],self.ball_pos[1]+vector_dir[0]]
            self.app.update_graphic(vector_dir,self.graphic_ball)
 
 
 
# --- Main ---
 
root = Tk()
object_map = Map()
appli_object = Application(object_map,root)
ball1 = Ball(object_map,(8,8),'yellow',0,appli_object)
#ball2 = Ball(object_map,(8,8),'red',0,appli_object)
 
root.mainloop()

[bistouille]

Salut.

Le problème, c'est que ta fonction init_balls gèle l'application, ça se voit direct au lancement puisque la fenêtre met 3 plombes à apparaitre.

Je pense qu'avant de te lancer dans des considérations de pattern mvc (un controller n'a rien à voir avec ce que tu as dit), tu ferais mieux de t'intéresser à comment fonctionne tkinter, il fournit un tas de choses comme toutes les bibliothèques graphiques pour travailler, si tu veux faire des déplacements automatiques d'items, c'est avec la méthode after que cela se fait, et à la longue tu verras que faire du mvc pur et dur avec une biblothèque graphique est difficile tellement les relations sont étroites.

Simple avis d'un amateur.

[Kazvert]

Ok, je vais essayer de regler ca avec after

Merci pour le retour

[Kazvert]

J'ai trouvé:
- Je faisais .after(time, mehode()) , comme si j'appellais ma méthode à cause des parenthèses alors qu'il ne faut pas => .after(time, mehode) . Si javais des arguments, il faudrait passer probablement par du lambda.

- En mode manuel, j'appelais plein de fois le .after chaque fois que je tapais au clavier. Maintenant, le clavier ne modifie que le vector. Et le move_ball_manual est lancé dès le départ. Une condition sur la présence d'un vecteur permet de garder la boule immobile au départ

- J'ai mis le binder dans ma boule au final; l'event du clavier appartient davantage à ma classe boule qu'à ma classe application.

Les boules automatiques restent sur les cotés ici, mais cest assez simple de faire des cases bleues ou elles ne peuvent aller et d'intégrer le tout dans check_map.
Je compte aussi faire rebondir une boule si elle rencontre une autre boule, probablement avec une liste contenant chaque position des boules et que l'on vérifie dans le check_map également

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
from tkinter import Tk, Canvas
from numpy import zeros
from random import choice 
 
CASE_SIZE = 20
BALL_SIZE = 8 
GAME_SPEED = 50
 
MOTIONS = {
            'Up':   (0, -1),
            'Down': (0, 1),
            'Left': (-1, 0),
            'Right':(1, 0)
           }
 
class Application():
 
    def __init__(self,map_object, root):
        self.init_canvas(root, map_object)
 
    def init_canvas(self,root, map_object):
        self.root = root       
        map_size = map_object.get_map()
        lar = map_size.shape[0]*CASE_SIZE
        hau = map_size.shape[1]*CASE_SIZE  
 
        self.can_game = Canvas(self.root,width=lar,height=hau,bg="black")
        self.can_game.pack(padx=10,pady=10)
        self.can_game.focus_set() 
 
class Map():
 
    def __init__(self):
        self.map_game = zeros((10,10))
 
    def get_map(self):
        return self.map_game
 
class Ball():    
 
    def __init__(self,object_map,ball_pos,color,moving_status,app): 
        self.app = app
        self.object_map = object_map
        self.ball_pos = ball_pos  
        self.vector = None 
 
        self.graphic_ball = self.ball_drawing(color)
        self.ball_status(moving_status)
 
    def ball_status(self,moving_status):                    
        if moving_status == 1:    
            self.init_binder_key_ball()
            self.move_ball_manual()             
        else:
            self.vector = (-1, 0)
            self.move_ball_auto()      
 
    def init_binder_key_ball(self):    
        for key in MOTIONS:
            self.app.can_game.bind('<%s>' % key, self.keyboard_event)  
 
    def keyboard_event(self,event):
        self.vector = MOTIONS[event.keysym]
 
    def check_map(self):
        map_size = self.object_map.get_map()
        row = self.ball_pos[0] + self.vector[1] 
        col = self.ball_pos[1] + self.vector[0]
 
        if col >= 0 and col < map_size.shape[1] and \
            row >= 0 and row < map_size.shape[0]:
                return True            
 
    def ball_drawing(self,color):
        row = self.ball_pos[0]
        col = self.ball_pos[1]
        return self.cercle(col*CASE_SIZE+CASE_SIZE/2,row*CASE_SIZE+CASE_SIZE/2, BALL_SIZE,color)         
 
    def cercle(self,x, y, r, coul ='black'):
        return self.app.can_game.create_oval(x-r, y-r, x+r, y+r, fill=coul) 
 
    def move_ball_manual(self): 
            if self.vector and self.check_map():
                self.set_pos()   
                self.update_graphic_ball()
            self.app.can_game.after(GAME_SPEED, self.move_ball_manual)   
 
    def move_ball_auto(self):
        if self.check_map():        
            self.set_pos()                                     
            self.update_graphic_ball()            
        else:
            self.vector = choice(list(MOTIONS.values()))
        self.app.can_game.after(GAME_SPEED, self.move_ball_auto)            
 
    def update_graphic_ball(self):
        self.app.can_game.move(self.graphic_ball,self.vector[0]*CASE_SIZE,self.vector[1]*CASE_SIZE)             
 
    def set_pos(self):
        self.ball_pos = [self.ball_pos[0]+self.vector[1],self.ball_pos[1]+self.vector[0]]
 
    def get_pos(self):
        return self.ball_pos         
 
# --- Main ---
 
root = Tk()
object_map = Map()
appli_object = Application(object_map,root)
ball1 = Ball(object_map,(8,8),'yellow',0,appli_object)
ball2 = Ball(object_map,(5,5),'red',0,appli_object)
ball3 = Ball(object_map,(3,7),'green',1,appli_object)
root.mainloop()