Discussion :

[chris7522]

Bonjour a toutes et a tous,
J’ai du mal a comprendre quelque chose dans ce code que j’ai récupéré: qu’est ce qui fait que les animations du jeux sont «gelées» lorsque Je clique le bouton Pause .

J’ai éssayé de simplifier ce code , pas sur que ce soit claire .
J’ai dabord dans mon fichier main.py:

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 start():
    pygame.init()
 
 
    game = True
    menu = True
    run = False
 
    while game:
 
        while menu:
            number = men.menu(win)
            if number == 0:
                menu = False
                game = False
            elif number == 1:
                run = True
                menu = False
 
 
        while run:
            num = gamerun.run(win, org_win)  
            if num == 0:
                run = False
                game = False
            if num == 1:
                run = False
                menu = True
 
 
if __name__ == '__main__':
    start()

Ensuite dans mon fichier gamerun.py:

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
battleship = Spaceship('spaceship1_', 250, 120)  # instance héro
 
aliens = []
aliens2 = []
alien3 = []
stars = []
enemyspaceships = []
 
 
def run(win):
 
    redrawGameWindow(win)
 
    if battleship.health <= 0:
        if not ru:          #initialisé a True en début de fichier
            go = gameover(win)
            if go == 0 or go == 1:  
                ru = True
                return go  
        ru = False
 
    if len(aliens) == 0 and len(enemyspaceships) == 0 and len(aliens2) == 0 and len(alien3) == 0:
        generateLevel(win)       #fonction qui permet l’avancement dans les différents niveau
 
        redrawGameWindow(win)     #affiche tous les éléments graphiques 
 
    keys = pygame.key.get_pressed()
    if pausebutton or keys[pygame.K_ESCAPE]:
        pausebutton = False
        pau = True
        while pau:
            g = pause(win)
            if g == 1:
                pau = False
            elif g == 0:
                pau = False
                return 1
 
 
    pygame.display.update()

La fonction redrawGameWindow() affiche tout ce qu’il y a a l’ecran .

La fonction gameover() dans l’intégralité :

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
def gameover(win):
    global alienkills
    global spaceshipkills
    global totaltestseconds
    global level
    global levelcounter
    global aliens
    global alien3
    global aliens2
    global lasers
    global enemyspaceships
    global enemylasers
    global timee
 
    pygame.mixer.music.stop()
    helplevel = level
 
    ptime = calculateTime()
    if int(ptime[1]) < 10:
        timee = ptime[0] + ':0' + ptime[1]
    else:
        timee = ptime[0] + ':' + ptime[1]
 
    if helplevel > s.readlevel():
        s.save(helplevel, alienkills, spaceshipkills, timee, totaltestseconds)
        highscoreloop = True
        hslo = 0
        ybutton = 370
    elif helplevel == s.readlevel() and totaltestseconds > s.readseconds():
        s.save(helplevel, alienkills, spaceshipkills, timee, totaltestseconds)
        highscoreloop = True
        hslo = 0
        ybutton = 370
    else:
        highscoreloop = False
        ybutton = 350
 
    f = True
    g = True
    h = True
    i = True
    j = True
    k = True
    l = True
    m = True
    n = True
 
    while f:
        try:
            aliens.pop()
        except:
            f = False
    while i:
        try:
            aliens2.pop()
        except:
            i = False
    while j:
        try:
            alien3.pop()
        except:
            j = False
    while k:
        try:
            enemyspaceships.pop()
        except:
            k = False
 
    while g:
        try:
            lasers.pop()
        except:
            g = False
    while h:
        try:
            enemylasers.pop()
        except:
            h = False
    while l:
        try:
            aliens2_lasers.pop()
        except:
            l = False
    while m:
        try:
            aliens2_lasers2.pop()
        except:
            m = False
    while n:
        try:
            alien3_lasers.pop()
        except:
            n = False
 
    gaov = True
    while gaov:
        clock.tick(30)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                ptime = calculateTime()
                if int(ptime[1]) < 10:
                    timee = ptime[0] + ':0' + ptime[1]
                else:
                    timee = ptime[0] + ':' + ptime[1]
                return 0
        pygame.draw.rect(win, yellow, (50, 75, 600, 400))  # cadre resultat final
        pygame.draw.rect(win, black, (60, 85, 580, 380))
 
        gameoverfont = pygame.font.Font(set.font, 50)
        text = gameoverfont.render('Game Over!', 1, yellow)
        win.blit(text, (350 - round(text.get_width() / 2), 80))
 
        statfont = pygame.font.Font(set.font, 30)
        text = statfont.render('Level: ' + str(helplevel), 1, white)
        win.blit(text, (350 - round(text.get_width() / 2), 160))
 
        text = statfont.render('Aliens killed: ' + str(alienkills), 1, white)
        win.blit(text, (350 - round(text.get_width() / 2), 190))
 
        text = statfont.render('Enemy spaceships destroyed: ' + str(spaceshipkills), 1, white)
        win.blit(text, (350 - round(text.get_width() / 2), 220))
 
        if highscoreloop:  # si True : nouveau score
            hslo += 1  # la boucle hslo va permettre l'affichage par intermitence de
            # 'New Highscore!'
            if hslo < 15:
                highfont = pygame.font.Font(set.font, 40)
                text = highfont.render('New Highscore!', 1, yellow)
                win.blit(text, (350 - round(text.get_width() / 2), 290))
            elif hslo == 30:
                hslo = 0
 
        text = statfont.render('Survived time: ' + timee, 1, white)
        win.blit(text, (350 - round(text.get_width() / 2), 250))
 
        exbutton = t.button(win, 'Main Menu', 250, ybutton, 200, 50, yellow, black, yellow)
        if exbutton:
            reset()
            return 1
 
        pygame.display.update()

Et la fonction pause() dans l’intégralité:

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
def pause(win):
    global timee
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            ptime = calculateTime()
            if int(ptime[1]) < 10:
                timee = ptime[0] + ':0' + ptime[1]
            else:
                timee = ptime[0] + ':' + ptime[1]
            return 0
 
    pygame.draw.rect(win, green, (150, 115, 600, 380))
    pygame.draw.rect(win, black, (160, 125, 580, 360))
 
    paufont = pygame.font.Font(set.font, 50)
    text = paufont.render('Pause', 1, green)
    win.blit(text, (350 - round(text.get_width() / 2), 150))
 
    notefont = pygame.font.Font(set.font, 30)
    text = notefont.render('NOTE: if you quit, you can go back to the current', 1, green)
    win.blit(text, (180, 340))
    text = notefont.render('save by just starting the game via the main menu.', 1, green)
    win.blit(text, (180, 360))
    text = notefont.render('If you close the whole game with an unfinished save,', 1, green)
    win.blit(text, (180, 380))
    text = notefont.render('it will be saved regularly but you wont be able to', 1, green)
    win.blit(text, (180, 400))
    text = notefont.render('finish it.', 1, green)
    win.blit(text, (180, 420))
 
    resumebutton = t.button(win, 'Reprise', 250, 200, 200, 50, green, black, green)
    if resumebutton:  # si clique sur resumebutton
        return 1
 
    quitbutton = t.button(win, 'Quit', 250, 260, 200, 50, green, black, green)
    if quitbutton:  # si clique sur quitbutton
        ptime = calculateTime()
        if int(ptime[1]) < 10:
            timee = ptime[0] + ':0' + ptime[1]
        else:
            timee = ptime[0] + ':' + ptime[1]
        return 0
 
    pygame.display.update()

En espérant que vous puissiez m’aider , je vous remercie de votre aide .

[wiztricks]

Salut,

qu’est ce qui fait que les animations du jeux sont «gelées» lorsque Je clique le bouton Pause .

C'est gelé côté écran c'est soit parce que le programme ne fait rien (attend quelque chose) ou qu'il boucle quelque part (sans que la condition de sortie de la boucle soit réalisée).
Et quand je lis:

Code :

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

1
2
3
4
5
6
7
        while pau:
            g = pause(win)
            if g == 1:
                pau = False
            elif g == 0:
                pau = False
                return 1

je vois déjà un problème (qui n'est peut être pas la cause de...).

- W

[chris7522]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
keys = pygame.key.get_pressed()
    if pausebutton or keys[pygame.K_ESCAPE]:
        pausebutton = False
        pau = True
        while pau:
            g = pause(win)
            if g == 1:
                pau = False
            elif g == 0:
                pau = False
                return 1

Si je comprends bien cette partie de code , lorsque je clique sur pause (pausebutton) , pausebutton renvoie True , on rentre dans la condition , pausebutton est au passage réinitialisé a False pour la fois suivante , on rentre dans la boucle 'pau'.

1 ere possibilité : Le retour de pause est 1 ( si cliqué sur reprise) on sort de la boucle et le jeu reprend .
2 eme possibilité : Le retour de pause est 0 ( si cliqué sur quit) , on sort de la boucle , on retourne 1 donc run = False et menu = True (on quitte la partie et on revient au menu )

Lorsque la fonction pause() est appelé , il y a une fenetre qui est crée , a l'intérieure de celle-ci du texte est ecrit

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
    notefont = pygame.font.Font(set.font, 30)
    text = notefont.render('NOTE: if you quit, you can go back to the current', 1, green)
    win.blit(text, (180, 340))
    text = notefont.render('save by just starting the game via the main menu.', 1, green)
    win.blit(text, (180, 360))
    text = notefont.render('If you close the whole game with an unfinished save,', 1, green)
    win.blit(text, (180, 380))
    text = notefont.render('it will be saved regularly but you wont be able to', 1, green)
    win.blit(text, (180, 400))
    text = notefont.render('finish it.', 1, green)
    win.blit(text, (180, 420))

Puis 2 rectangles sont affichés :

Code :

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

1
2
3
4
5
resumebutton = t.button(win, 'Reprise', 250, 200, 200, 50, green, black, green)
    if resumebutton:  # si clique sur resumebutton
        return 1
 
 quitbutton = t.button(win, 'Quit', 250, 260, 200, 50, green, black, green)

(resumebutton pour reprendre ma partie et quitbutton pour la quitter)

Que le contenu de la fonction pause() soit affiché a l'ecran , c'est une chose mais pourquoi , et qu'est ce qui a provoqué l'arret de toutes les animations a l'ecran ? Les fenetres auraient pu etre affichés tout en continuant le jeu . Je ne comprends pas bien le mécanisme qui a "geler" toutes les animations .

[wiztricks]

Je ne comprends pas bien le mécanisme qui a "geler" toutes les animations .

Quelle est la partie du code qui est responsable des animations?
Etes vous certain qu'on y passe? Et sinon que fait le programme?
C'est du temps à passer pour faire des hypothèses sur ce que fait le code et les vérifier via des "print" ou autre.
Un truc comme:

Code :

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

1
2
3
4
5
6
7
8
        pau = True
        while pau:
            g = pause(win)
            if g == 1:
                pau = False
            elif g == 0:
                pau = False
                return 1

où la boucle ne sert à rien (on sort des la première itération puisque pau passe à False dans tous les cas) n'aide pas à comprendre... et si tout le code est comme ça, on va y passer beaucoup de temps à se prendre le chou...

- W

[chris7522]

La partie du code qui gere les animations est la fonction redrawGameWindow(win) si je ne me trompe pas . Vous avez raison , c'est une vrai usine a gaz et j'en ai rajouté une couche , donc peut etre que c'est mieux d'en rester la . Je vous remercie une nouvelle fois de l'aide que vous m'apportez .
Mais bon, je poste quand meme le code de la fonction redrawGameWindow(win) au cas ou :

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
def redrawGameWindow(win):
    global powerups
    global battleship
    global alienkills
    global spaceshipkills
    global pausebutton
    global holdingpowerup
    global usepowerup
    global poweruploop
    global alien2kills
    global move_back
    global count
    global poweruploop2
    global circle
    global flash
    global no_protection
    img_explose = "data/shrapnel.png"
 
    fog.draw(win)
 
    lvlfont = pygame.font.Font(set.font, 40)
    text = lvlfont.render('Niveau: ' + str(level), 1, red)  # texte en haut
    win.blit(text, (1100 - round(text.get_width() / 2), 10))
 
    text = lvlfont.render('Pouvoirs : ', 1, (green))  # texte Powerups seul en haut ecran
    win.blit(text, (5, 55))
 
    if circle:
        color = counter()
        textp = text_font('PROTECTION', color, 'large')  # fonction text_font gere largeur police
        win.blit(textp, (350, 950))
        flash = False  # plus d'eclaire sur héro
        no_protection = False  # le score héro ne bouge plus
        anneau.animate('anneaux')
 
    for powerup in powerups:
        if powerup[1] == True:
            holdingpowerup = True
            color = counter()
            textp = text_font(powerup[0], color, 'large')  # fonction text_font gere largeur police
            win.blit(textp, (text.get_width() + 10, 55))
            poweruploop2 += 1
            if poweruploop2 == 1500:
                poweruploop2 = 0
                holdingpowerup = False
                for powerup in powerups:
                    if powerup[1] == True:
                        powerup[1] = False
 
    if holdingpowerup:  # holdingpowerup : maintien du pouvoir
        usebutton = t.button(win, 'Utilisation', 50 + text.get_width() + textp.get_width() + 20, 25, 150, 40, green,
                             black,
                             green)
        if usebutton:
            holdingpowerup = False
            usepowerup = True  # utilisation du pouvoir
 
    if usepowerup:  # utiliser la pouvoir , a False au debut fichier
        for powerup in powerups:  # powerup : pouvoir utilisé
            if powerup[1] == True:  # remise de powerup a False
                powerup[1] = False
                powerup[2] = True  # 2eme booleen passe a True
 
    for powerup in powerups:
        if powerup[2]:
            textp = lvlfont.render(powerup[0], 1, green)
            win.blit(textp, (text.get_width() + 10, 55))
            poweruploop += 1
            if poweruploop == 1720:
                poweruploop = 0
                powerup[2] = False
                usepowerup = False
 
    if not holdingpowerup and not usepowerup:
        textp = lvlfont.render('aucun', 1, green)
        win.blit(textp, (text.get_width() + 10, 55))
 
    pausebutton = t.button(win, 'Pause', 825, 10, 150, 50, green, black, green)
 
    keys = pygame.key.get_pressed()
    if pausebutton or keys[pygame.K_ESCAPE]:  # if pausebutton = si clique sur pause
        pause(win)
 
    for laser in lasers:
        laser.draw(win)
 
    for laser in enemylasers:
        laser.draw(win)
 
    for laser in aliens2_lasers:
        laser.draw(win)
 
    for laser in aliens2_lasers2:
        laser.draw(win)
 
    for laser in alien3_lasers:
        laser.draw(win)
 
    for alien in aliens:
        if alien.health >= 1:
            alien.draw(win)
        else:
            for x in range(17):
                shrap = Shrapnel(2, alien.rect.x, alien.rect.y, 40, 8, 8, img_explose, 16)  # "explode" shrapnel
                shrap.x_force = random.randrange(-40, 40) / 5
                shrap.y_force = random.randrange(-40, 40) / 5
                shrapnel_list.add(shrap)
            explosesound.play()
            explosesound.set_volume(0.5)
            aliens.pop(aliens.index(alien))
            alienkills += 1
        if alien.rect.x + alien.hitbox[2] < 0:
            aliens.pop(aliens.index(alien))
 
    for v in enemyspaceships:
        if v.health >= 1:
            v.animate('paon')
            v.draw(win)
        else:
            explosesound.play()
            explosesound.set_volume(0.5)
            explosion = Animations(v.rect.x, v.rect.y, 'explose2', 300, 300)
            explosion_group.add(explosion)
            enemyspaceships.pop()
            spaceshipkills += 1
 
    for alien in aliens2:
        global alien2loop
        if alien.health >= 1:
            if len(aliens) <= 25:
                alien2loop += 1
                if alien2loop < 250:
                    alien.animate('sentinel_2')
                    alien.move(win)
                    alien.fire()
 
                if alien2loop > 250 and alien2loop < 1500:
                    alien.animate('sentinel')
                    move_back = False
 
                    alien.up_and_down(win)
                    alien.fire()
 
                if alien2loop > 1500 and alien2loop < 1800:
                    alien.animate('sentinel')
                    move_back = False
                    alien.move_back(win)
 
                if alien2loop > 1800 and alien2loop < 3000:
                    move_back = True
                    alien.animate('sentinel_2')
                    alien.up_and_down(win)
                    alien.fire()
 
                if alien2loop > 3000:
                    alien.animate('sentinel_2')
                    move_back = True
                    alien.move_exit(win)
 
        else:
            explosesound.play()
            explosesound.set_volume(0.5)
            explosion = Animations(alien.rect.x, alien.rect.y, 'explose', 250, 250)
            explosion_group.add(explosion)
            aliens2.pop()
            alienkills += 1
            alien2loop = 0
 
        if alien.rect.x + alien.image.get_width() < 0:
            aliens2.pop()
            alien2loop = 0
 
    for alien in alien3:
        global alien3loop
 
        if alien.health >= 1:
            alien3loop += 1
            if alien3loop < 630:
                alien.animate('bouleRight') # 550,400
                alien.move(win)
            if alien3loop > 630 and alien3loop < 5000:
                alien.animate('boule')
                alien.up_and_down(win)
            if alien3loop > 5000:
                alien.animate('boule')
                alien.move_exit(win)
 
 
        else:
            shrap = Shrapnel(2, alien.rect.x, alien.rect.y, 40, 8, 8, "data/shrapnel.png")
            shrapnel_list.add(shrap)
            for x in range(17):
                shrap = Shrapnel(2, alien.rect.x, alien.rect.y, 40, 8, 8, "data/shrapnel.png")  # "explode" shrapnel
                shrap.x_force = random.randrange(-20, 20) / 10
                shrap.y_force = random.randrange(-20, 20) / 10
                shrapnel_list.add(shrap)
            explosesound.play()
            explosesound.set_volume(0.5)
            alien3.pop(alien3.index(alien))
            alienkills += 1
 
 
        if alien.rect.x + alien.img_w + 50 < 0:
            alien3.pop()
        if len(alien3) == 0:
            alien3loop = 0
 
    shrapnel_list.update()
    shrapnel_list.draw(win)
 
    if battleship.visible:  # battleship : instance héro
        battleship.draw(win)
        if circle:
            anneau.draw(win)
 
    battleship.drawHealthBar(win)  # barre de vie
 
    explosion_group.draw(win)
    explosion_group.update()
 
    anim_group.draw(win)
    anim_group.update()
 
    pygame.display.update()

Et la fonction run() car redrawGameWindow() est appelé dans run .

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
def run(win, org_win):
    global alienkills
    global spaceshipkills
    global battleship
    global ru
    global seccount
    global pausebutton
    global totaltestseconds
    global timee
    global new_aliens
    global offset
    global right
    global left
    global circle
    global flash
    global no_protection
    global circle_loop
 
    clock.tick(60)
 
    org_win.fill((0, 0, 0))
    background.update_background(win)
 
    circle_loop += 1
    if circle_loop == 2500:
        circle = False
        circle_loop = 0
        flash = True  # eclaire sur héro
        no_protection = True  # le score héro bouge
 
    seccount += 1
    if seccount == 60:
        totaltestseconds += 1
        seccount = 0
 
    redrawGameWindow(win)
 
    global shootloop
 
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            ptime = calculateTime()  # retourne le temps en minute et secondes
            if int(ptime[1]) < 10:  # ptime[1] = secondes
                timee = ptime[0] + ':0' + ptime[1]
            else:
                timee = ptime[0] + ':' + ptime[1]
            return 0
        if event.type == ECLAIRE:
            if right and flash:
                eclaire = Animations(battleship.rect.x + 110, battleship.rect.y + 20, 'eclaire', 250, 200)
                explosion_group.add(eclaire)
                right = False
        if event.type == ECLAIRE:
            if left and flash:
                eclaire = Animations(battleship.rect.x - 110, battleship.rect.y + 20, 'eclaire', 250, 200)
                explosion_group.add(eclaire)
                left = False
        """
        if event.type == ANIM:
        
 
                # circle1 = Animations(battleship.rect.x - 400, battleship.rect.y - 400, 'anim', 1100, 1100)
                # anim_group.add(circle1)
        """
    if battleship.visible:
        global moving_up
        global moving_down
 
        keys = pygame.key.get_pressed()
 
        if keys[pygame.K_LEFT]:
            if battleship.rect.x > battleship.vel:  # permet de ne pas sortir sur la gauche
                battleship.rect.x -= battleship.vel
                left = True
 
        if keys[pygame.K_RIGHT]:
            if battleship.rect.x < screen_w - battleship.image.get_width() - battleship.vel:  # breite : largeur
                battleship.rect.x += battleship.vel
                right = True
 
        if keys[pygame.K_UP]:
            if battleship.rect.y > 100:
                battleship.rect.y -= battleship.vel
                moving_up = True
        else:
            moving_up = False
 
        if keys[pygame.K_DOWN]:
            if battleship.rect.y + battleship.image.get_height() < screen_h:
                battleship.rect.y += battleship.vel
                moving_down = True
        else:
            moving_down = False
 
        if keys[pygame.K_SPACE]:
            if shootloop == 0:
                battleship.fire()
                shootloop = 1
 
    if shootloop > 0:  # boucle d'attente entre 2 tirs héro
        shootloop += 1
    if shootloop > battleship.interval_fire:
        shootloop = 0
 
    for laser in lasers:  # laser du vaisseau héro
        if laser.rect.x < screen_w:
            laser.rect.x += laser.vel
 
        else:
            lasers.pop(lasers.index(laser))  # supression laser héros si sortie par la droite
 
        # gestion collision laser héro avec les lasers enemis 1er groupe
        for e in enemylasers:  # on inbrique ce for car permet de recuperer de laser.x et laser.y
            xx = e.rect.x - laser.rect.x  # distance x entre le laser enemie et le laser héro
            yy = e.rect.y - laser.rect.y  # distance y entre le laser enemie et le laser héro
 
            if xx < 10 and yy < 10 and yy > -10 and xx > -10:  # permet de gerer la collision entre les lasers du héros et les lasers aliens si elle est comprise entre 5 et -5 ,c'est qu'il y a collision et on le supprime
                enemylasers.pop(enemylasers.index(e))  # suppression laser enemies si collision
                lasers.pop(lasers.index(laser))  # supression laser héros si collision
 
        for e in aliens2_lasers:  # on inbrique ce for car permet de recuperer de laser.x et laser.y
            xx = e.rect.x - laser.rect.x  # distance x entre le laser enemie et le laser héro
            yy = e.rect.y - laser.rect.y  # distance y entre le laser enemie et le laser héro
 
            if xx < 10 and yy < 10 and yy > -10 and xx > -10:  # permet de gerer la collision entre les lasers du héros et les lasers aliens si elle est comprise entre 5 et -5 ,c'est qu'il y a collision et on le supprime
                aliens2_lasers.pop(aliens2_lasers.index(e))  # suppression laser enemies si collision
                lasers.pop(lasers.index(laser))  # supression laser héros si collision
 
        for e in aliens2_lasers2:  # on inbrique ce for car permet de recuperer de laser.x et laser.y
            xx = e.rect.x - laser.rect.x  # distance x entre le laser enemie et le laser héro
            yy = e.rect.y - laser.rect.y  # distance y entre le laser enemie et le laser héro
 
            if xx < 10 and yy < 10 and yy > -10 and xx > -10:  # permet de gerer la collision entre les lasers du héros et les lasers aliens si elle est comprise entre 5 et -5 ,c'est qu'il y a collision et on le supprime
                aliens2_lasers2.pop(aliens2_lasers2.index(e))  # suppression laser enemies si collision
                lasers.pop(lasers.index(laser))  # supression laser héros si collision
 
        for e in alien3_lasers:
            xx = e.rect.x - laser.rect.x  # distance x entre le laser enemie et le laser héro
            yy = e.rect.y - laser.rect.y  # distance y entre le laser enemie et le laser héro
 
            if xx < 10 and yy < 10 and yy > -10 and xx > -10:  # permet de gerer la collision entre les lasers du héros et les lasers aliens si elle est comprise entre 5 et -5 ,c'est qu'il y a collision et on le supprime
                alien3_lasers.pop(alien3_lasers.index(e))  # suppression laser enemies si collision
                lasers.pop(lasers.index(laser))  # supression laser héros si collision
 
    for alien in aliens:  # aliens = 1 er groupe d'aliens
        # gestion collision du laser héro avec 1er groupe aliens
        if alien.visible:
            for laser in lasers:  # lasers:liste lasers héros
                if laser.rect.x + laser.laser_w > alien.rect.x and laser.rect.x + laser.laser_w < alien.rect.x + \
                        alien.hitbox[2]:
                    if laser.rect.y + laser.laser_h > alien.rect.y and laser.rect.y + laser.laser_h < alien.rect.y + \
                            alien.hitbox[3]:
                        alien.hit()
                        lasers.pop(lasers.index(laser))
    for alien in aliens2:  # gestion collision du laser héro avec chaque aliens_2
        for laser in lasers:  # lasers:liste lasers héros
            if laser.rect.x + laser.laser_w > alien.rect.x and laser.rect.x + laser.laser_w < alien.rect.x + alien.image.get_width():
                if laser.rect.y + laser.laser_h > alien.rect.y and laser.rect.y + laser.laser_h < alien.rect.y + alien.image.get_height():
                    alien.hit()
                    lasers.pop(lasers.index(laser))
    for alien in alien3:
        for laser in lasers:  # lasers:liste lasers héros
            if laser.rect.x + laser.laser_w > alien.rect.x and laser.rect.x + laser.laser_w < alien.rect.x + alien.image.get_width():
                if laser.rect.y + laser.laser_h > alien.rect.y and laser.rect.y + laser.laser_h < alien.rect.y + alien.image.get_height():
                    alien.hit()
                    lasers.pop(lasers.index(laser))
    for v in enemyspaceships:  # gestion collision laser héro avec 3eme groupe aliens
        for laser in lasers:
            if laser.rect.y < v.hitbox[1] + v.hitbox[3] and laser.rect.y > v.hitbox[
                1]:  # c'est a dire s'ilest en plein dans le corps de l'enemi  en y
                if laser.rect.x > v.hitbox[0] and laser.rect.x < v.hitbox[0] + v.hitbox[2]:
                    v.hit()
                    lasers.pop(lasers.index(laser))
            elif laser.rect.y + laser.laser_h < v.hitbox[1] + v.hitbox[3] and laser.rect.y + laser.laser_h > v.hitbox[
                1]:
                if laser.rect.x > v.hitbox[0] and laser.rect.x < v.hitbox[0] + v.hitbox[2]:
                    v.hit()
                    lasers.pop(lasers.index(laser))
 
    for laser in enemylasers:  # gestion de la collision des lasers de enemylasers vers le vaisseau héro
        offset_x = battleship.rect.x - laser.rect.x
        offset_y = battleship.rect.y - laser.rect.y
        if laser.laser_mask.overlap(battleship.spaceship_mask, (offset_x, offset_y)):
            enemylasers.pop(enemylasers.index(laser))
            if no_protection:
                offset = shake()
                battleship.hit()
 
    for laser in aliens2_lasers:  # gestion de la collision des lasers de alien2_laser vers le vaisseau héro
        offset_x = battleship.rect.x - laser.rect.x
        offset_y = battleship.rect.y - laser.rect.y
        if laser.laser_mask.overlap(battleship.spaceship_mask, (offset_x, offset_y)):
            offset = shake()
            battleship.hit()
            aliens2_lasers.pop(aliens2_lasers.index(laser))
 
    for laser in aliens2_lasers2:  # gestion de la collision des lasers de alien2_laser2 vers le vaisseau héro
        offset_x = battleship.rect.x - laser.rect.x
        offset_y = battleship.rect.y - laser.rect.y
        if laser.laser_mask.overlap(battleship.spaceship_mask, (offset_x, offset_y)):
            offset = shake()
            battleship.hit()
            aliens2_lasers2.pop(aliens2_lasers2.index(laser))
 
    for laser in alien3_lasers:
        offset_x = battleship.rect.x - laser.rect.x
        offset_y = battleship.rect.y - laser.rect.y
        if laser.laser_mask.overlap(battleship.spaceship_mask, (offset_x, offset_y)):
            offset = shake()
            battleship.hit()
            alien3_lasers.pop(alien3_lasers.index(laser))
 
    for laser in enemylasers:  # gestion sortie de tous les lasers enemylasers
        if laser.rect.x > 0:
            laser.rect.x -= laser.vel
        else:
            enemylasers.pop(enemylasers.index(laser))
 
    for laser in aliens2_lasers:  # gestion sortie de tous les lasers enemies 2
        laser.rect.x -= laser.vel
        if laser.rect.x < 0:
            aliens2_lasers.pop(aliens2_lasers.index(laser))
 
    for laser in aliens2_lasers2:
        laser.rect.x += laser.vel
        if laser.rect.x > screen_w:
            aliens2_lasers2.pop(aliens2_lasers2.index(laser))
 
    for laser in alien3_lasers:
        if laser.rect.x > 0:
            laser.rect.x -= laser.vel
        else:
            alien3_lasers.pop(alien3_lasers.index(laser))
 
    if battleship.health <= 0:
        if not ru:  # ru : boucle qui permet de laisser le menu gameover affiché tant que
            # pas clique sur quit ou main menu ? if not ru (si ru n'est pas True)
            go = gameover(win)
            if go == 0 or go == 1:  # si cliqué sur quit ou main menu
                ru = True
                return go  # go valeur de retour fonction gameover,soit 0, soit 1
        ru = False
 
    if len(aliens) == 0 and len(enemyspaceships) == 0 and len(aliens2) == 0 and len(alien3) == 0:
        # si plus d'enemis , on supprime tous les lasers héros et enemis
        l = True
        while l:
            try:
                lasers.pop()  # lasers du héro
            except:
                l = False
        e = True
        while e:
            try:
                enemylasers.pop()
            except:
                e = False
        f = True
        while f:
            try:
                aliens2_lasers.pop()
            except:
                f = False
        g = True
        while g:
            try:
                aliens2_lasers2.pop()
            except:
                g = False
        h = True
        while h:
            try:
                alien3_lasers.pop()
            except:
 
                h = False
 
        generateLevel(win)
        redrawGameWindow(win)
 
    keys = pygame.key.get_pressed()
    if pausebutton or keys[pygame.K_ESCAPE]:
        pausebutton = False
        pau = True
        while pau:
            g = pause(win)
            if g == 1:
                pau = False
            elif g == 0:
                pau = False
                return 1
 
    org_win.blit(win, next(offset))
    pygame.display.update()