sprite, canvas qui ne se rafraichit pas

**grub_fr** · 29/03/2023, 20h35

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 :

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
 
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 :

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

**grub_fr** · 30/03/2023, 11h21

re,

bon a priori, j'ai trouvé:
il faut que j'execute la methode qui affiche le left_canvas (et son contenu) a chaque x que je presse 1 touche.

je poste la boucle while principale:

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
 
while True:
    # mouse coords
    textsurface = myfont.render(str(pygame.mouse.get_pos()), False, RED, BLACK)
 
    # Affichage des coordonnées de la souris
    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:
            # left_canvas.fill(WHITE)
 
            # permet de redessiner le left_canvas avec le
            # la map qui est chargée depuis le fichier
            # json correspondant au niveau courant
            # utilitaires.loadLevel("Save/saveGAME/",
                                  # left_canvas,
                                  #*WHITE,
                                  # index_current_level)
 
            # F12
            if event.key == pygame.K_F12:
                print("F12")
 
            # F11
            if event.key == pygame.K_F11:
                print("F11")
 
            # F9
            if event.key == pygame.K_F9:
                print("F9")
 
            # F8
            if event.key == pygame.K_F8:
                print("F8")
                # utilitaires.makeSVG03("Save/saveGAME/57.json")
 
            # F7
            if event.key == pygame.K_F7:
                print("F7")
 
            if event.key == pygame.K_a:
                if (index_current_level <= 0):
                    index_current_level = 0
                    utilitaires.loadLevel("Save/saveGAME/",
                                          left_canvas,
                                          WHITE,
                                          index_current_level)
 
                else:
                    index_current_level -= 1
                    utilitaires.loadLevel("Save/saveGAME/",
                                          left_canvas,
                                          WHITE,
                                          index_current_level)
 
                print(index_current_level)
 
            if event.key == pygame.K_z:
                if (index_current_level >= len(files)):
                    index_current_level = len(files)
                    utilitaires.loadLevel01PrTest("Save/saveGAME/",
                                                  left_canvas,
                                                  WHITE,
                                                  index_current_level)
 
                else:
                    index_current_level += 1
                    utilitaires.loadLevel01PrTest("Save/saveGAME/",
                                                  left_canvas,
                                                  WHITE,
                                                  index_current_level)
 
                print(index_current_level)
 
            if event.key == pygame.K_h:
                if p01:
                    print("p01 existe")
                    utilitaires.loadLevel("Save/saveGAME/",
                                  left_canvas,
                                  WHITE,
                                  index_current_level)
 
                    p01.move_left()
                    p01.draw(left_canvas, left_canvas_rect)
                    pygame.display.update()
 
                else:
                    print("p01 n'existe pas")
 
            if event.key == pygame.K_j:
                if p01:
                    print("p01 existe")
                    utilitaires.loadLevel("Save/saveGAME/",
                                  left_canvas,
                                  WHITE,
                                  index_current_level)
 
                    p01.move_right()
                    p01.draw(left_canvas, left_canvas_rect)
                    pygame.display.update()
 
                else:
                    print("p01 n'existe pas")
 
            if event.key == pygame.K_p:
                if p01:
                    print("p01 existe")
                    utilitaires.loadLevel("Save/saveGAME/",
                                  left_canvas,
                                  WHITE,
                                  index_current_level)
 
                    p01.move_up()
                    p01.draw(left_canvas, left_canvas_rect)
                    pygame.display.update()
 
                else:
                    print("p01 n'existe pas")
 
            if event.key == pygame.K_m:
                if p01:
                    print("p01 existe")
                    utilitaires.loadLevel("Save/saveGAME/",
                                  left_canvas,
                                  WHITE,
                                  index_current_level)
 
                    p01.move_down()
                    p01.draw(left_canvas, left_canvas_rect)
                    pygame.display.update()
 
                else:
                    print("p01 n'existe pas")
 
            # ESC quitte le programme
            if event.key == pygame.K_ESCAPE:
                pygame.quit()
                sys.exit(0)
 
        # qd les boutons souris st relachés
        elif event.type == pygame.MOUSEBUTTONUP:
 
            # qd le bouton gauche de la souris est relaché
            # imprime les coordonnées de la souris
            # et de chacun des rooms
            if event.button == 1:  # left mouse button
                print("01: Mouse clicked")
                pos = pygame.mouse.get_pos()
                if button_area.collidepoint(pos[0] - right_canvas_rect.x,
                                            pos[1] - right_canvas_rect.y):
                    print(pos)
                    print("sur le bouton")
 
                    # charge le 1° fichier json du repertoire
                    # en tant que 1° niveau
                    """
                    print("")
                    print("CONTENU de lvl: " +
                          str(lvl))
                    print("")
                    """
 
                    lvl = utilitaires.loadLevel01PrTest("Save/saveGAME/",
                                                        left_canvas,
                                                        WHITE,
                                                        index_current_level)
 
                    p01 = utilitaires.createPlayer("Audrey")
                    print("nom du joueur: " + str(p01.get_name()))
                    p01.draw(left_canvas, left_canvas_rect)
                    pygame.display.update()
 
                    """
                    utilitaires.placePlayer(left_canvas,
                                            lvl, p01)
                    """
 
                    # print("nom du joueur: " + str(p01.get_name()))
 
            # qd le bouton droit de la souris est relaché
            # imprime 1 message
            elif event.button == 3:  # right mouse button
                print("04: Right button clicked")
 
    # draw left & right canvases
    screen.blit(left_canvas, (0, 0))
    screen.blit(right_canvas, (left_canvas_width, 0))
 
    pygame.display.update()

Voilà l'idée, la methode est executée à differents endroits, differentes touches.
je dois optimiser mais le probleme semble resolu.

Merci+
a+
grub

sprite, canvas qui ne se rafraichit pas

Programmation multimédia/Jeux Python

Discussions similaires

Partager

Partager