sprite, canvas qui ne se rafraichit pas

Bonsoir a vous,

Question qui a du etre posée maintes fois mais je bloque.
pygame.

ds 1 fenetre j'ai 2 canvas.
ds le canvas de gauche je souhaite afficher 1 cercle qui represente 1 joueur. joueur qui est defini ds 1 classe.
Je fais bouger ce cercle pr des touches clavier ms le canvas ne se rafraichit pas. Je pensais devoir creer 1 surface ds cette classe, ms cela ne fonctionne toujours pas.
Ca fait qques temps que je coice là-dessus, aussi je viens chercher de l'aide sur ce que j'ai produit:

Le fichier qui lance la boucle principale

Code:

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
 
pygame.init()
 
# font initialization for mouse coords
pygame.font.init()
myfont = pygame.font.SysFont('Arial', 15)
 
window_info = pygame.display.Info()
windowWidth = 1000
windowHeight = 600
 
left_canvas_width = 800
left_canvas_height = 600
left_canvas = pygame.Surface((left_canvas_width, left_canvas_height))
left_canvas.fill(WHITE)
 
right_canvas_width = 200
right_canvas_height = 600
right_canvas = pygame.Surface((right_canvas_width, right_canvas_height))
right_canvas.fill(GREY)
 
# rectangle qui prend les posit° du left_canvas
left_canvas_rect = left_canvas.get_rect()
 
# rectangle qui prend les posit° du right_canvas
right_canvas_rect = right_canvas.get_rect()
 
# bouton Start game
# Define button properties
button_width = 150
button_height = 50
button_x = 25
button_y = 25
button_color = BLUE
button_text = "Start Game"
text_color = WHITE
 
# surface qui superposée au bouton Start Game
button_surface = pygame.Surface((button_width, button_height))
button_surface.fill(button_color)
button_text_surface = myfont.render(button_text, True, text_color)
text_x = button_width // 2 - button_text_surface.get_width() // 2
text_y = button_height // 2 - button_text_surface.get_height() // 2
button_surface.blit(button_text_surface, (text_x, text_y))
 
# aire clickable superposée au bouton Start Game
button_area = pygame.Rect((left_canvas_width + button_x),
                          button_y,
                          (800 + button_width),
                          button_height)
 
# Add button Start Game to right canvas
right_canvas.blit(button_surface,
                  (button_x, button_y))
 
#
screen = pygame.display.set_mode((windowWidth, windowHeight),
                                 0)
 
# affichage en bas a gauche de la fenetre
right_canvas.blit(seedsurf, (10, left_canvas_height-20))
 
# remplit screen
screen.fill(WHITE)
 
while True:
    # mouse coords
    textsurface = myfont.render(str(pygame.mouse.get_pos()), False, RED, BLACK)
 
    # Affichage des coordonnées de la souris
    # en haut a gauche de la fenetre
    right_canvas.blit(textsurface, (10, 0))
 
    # handle events
    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit(0)
        elif event.type == pygame.KEYDOWN:
 
            # F7
            if event.key == pygame.K_F7:
                print("F7")
 
            if event.key == pygame.K_h:
                if p01:
                    print("p01 existe")
                    p01.move_left()
                    p01.draw(left_canvas, left_canvas_rect)
                    pygame.display.update()
 
                else:
                    print("p01 n'existe pas")
 
    # draw left & right canvases
    screen.blit(left_canvas, (0, 0))
    screen.blit(right_canvas, (left_canvas_width, 0))
 
    pygame.display.update()
 
# quit pygame
pygame.quit()

la classe Player

Code:

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
 
import pygame
 
 
class Player:
 
    def __init__(self, name, health=100, x=0, y=0):
        self.name = name
        self.health = health
        self.x = x
        self.y = y
        self.color = (0, 255, 0)
        self.radius = 10
        self.speed = 5
 
    def draw(self, surface, left_surface_rect):
        """
        surface = la surface left_canvas definie ds DungeonGen.py
        left_surface_rect = left_canvas_rect definie ds DungeonGen.py
        """
        # Create a new surface
 
        # prend les dimensions du left_canvas_rect defini ds
        # le fichier principal
        surface_player_width = left_surface_rect.width
        surface_player_height = left_surface_rect.height
 
        # placer la surface aux coordonnées du left_canvas defini
        # ds le fichier principal (ou a son rectangle: left_canvas_rect)
        # sert + bas ds la methode de blit
        surface_player_x = left_surface_rect.x
        surface_player_y = left_surface_rect.y
 
        # on applique les dimens° et un canal alpha
        surface_player = pygame.Surface((surface_player_width, surface_player_height),
                                        pygame.SRCALPHA)
 
        #
        # surface_player.set_alpha(50)
 
        # Clear the screen with a transparent surface
        surface_player.fill((0, 0, 0, 0))
 
        pygame.draw.circle(surface_player,
                           self.color,
                           (self.x, self.y),
                           self.radius)
 
        # Blit the surface to the screen
        surface.blit(surface_player, (surface_player_x, surface_player_y))
 
        pygame.display.flip()
 
    def move_left(self):
        self.x -= self.speed
 
    def move_right(self):
        self.x += self.speed
 
    def move_up(self):
        self.y -= self.speed
 
    def move_down(self):
        self.y += self.speed
 
    def get_name(self):
        return self.name
 
    def get_health(self):
        return self.health
 
    def set_name(self, name):
        self.name = name
 
    def set_health(self, health):
        self.health = health
 
    def get_position(self):
        return (self.x, self.y)
 
    def set_position(self, x, y):
        self.x = x
        self.y = y

Peut etre que je ne "blit" pas qque chose qu'il faudrait ou je ne sais quoi? Si vous avez des explications.
Merci bien
grub