Jeu saccadé: Timer ? Thread? sous python.

Version imprimable

Bonjour,
Je débute sous python.
J'essaie de créer un jeu Space Invader pour apprendre à utiliser Pygame.
J'utilise une main loop pour détecter toutes les touches tapées par l'utilisateur, mais je l'utilise aussi pour faire bouger les vaisseaux spatiaux ennemis.

Problème: à chaque fois que le joueur bouge, que les ennemis bougent ou que le tir d'un deux bouge, je doit rafraichir le fond d'écran et tous les vaisseaux. Forcément sa saccade, au bout de deux tirs les vaisseaux ennemis ne bougent plus.

D'où ma question:
Existe -t- il une possibilité de timer ou thread sous Python qui permettrait d'exécuter des taches en arrière plan (faire bouger les ennemis) sans ralentir mon jeux.
Ou bien, est ce que je n'optimise pas suffisamment mon programme ?

Merci.

Main loop:

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
 
while inGame:
 
        count = count +1
 
#------ displaying player ship
        move(clavier()) # détection des controles
#--------- end
 
#----- displaying computers ships
        if(Computer.loose == False):
 
            if (count%170)==0:
                Computer.moveAll(width)
                screen.blit(background,backgroundRect)
                for x in Computer.ships:
                    screen.blit(x.image, x.rect )
                screen.blit(Comica.image, Comica.rect)
                count = 1
#-------- end
 
#---- shooting display
            if shooted == 1:
                for x2 in shoots:
                    screen.blit(x2.image,x2.rect)
                    if ((x2.test == True) & ((count%25)==0)):
                        screen.blit(background, backgroundRect )
                        for x in Computer.ships:
                            screen.blit(x.image, x.rect )
                        screen.blit(Comica.image, Comica.rect)
                        x2.Continue(Computer)
                    elif(x2.test == False):
                        shoots.remove(x2)
#----------end    
        else:
        #---- lost...
            inGame = False
            screen.blit(Computer.image, Computer.rect )
 
        pygame.display.update()

15/04/2010, 22h56
josmiley

tu optimises surement pas assez, ou plutot, le code doit pas etre bien construit ...
je code quasiment qu'avec pygame, et avant de le faire ralentir il faut vraiment beaucoup blitter de grosses images.
poste le code complet, ou s'il est trop long un lien pour le downloader.
je t'aiderai volontier.

Mon image la plus grosse (le fond d'écran) fait entre 3,5 Ko et 5 ko, je doit la charger a chaque fois que les vaisseaux bougent ou qu'un tire bouge.
Voici le code entier de mon main:

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
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
 
def SpaceInvader():
 
    pygame.init()
    #size=width,height=600,500
    #screen = pygame.display.set_mode(size)
 
 
 
    global width, screen, background, backgroundRect
    pygame.display.set_caption("Boolean Space Invader")
 
    background = pygame.image.load("background.gif")
    backgroundRect = background.get_rect()
 
    size = (width, height) = background.get_size()
    screen = pygame.display.set_mode(size)
 
 
 
    white=255,255,255,255
    global shooted
    global shoots
    shoots =[]
    shooted = 0
 
    #--- creating player AND computers ships
    global Comica
    Comica = PlayerShip()
 
    global Computer
    Computer = Wave(5)
    Computer.MyInit()
#---- end
 
    pygame.key.set_repeat(500,30)
 
 
    count = 0
    inGame =  True
 
    screen.blit(background,backgroundRect)
    screen.blit(Comica.image, Comica.rect)
    for x in Computer.ships:
        screen.blit(x.image, x.rect )
 
    while inGame:
 
        count = count +1
 
#------ displaying player ship
 
        move(clavier()) 
#--------- end
 
#----- displaying computers ships
        if(Computer.loose == False):
 
            if (count%170)==0:
                Computer.moveAll(width)
                screen.blit(background,backgroundRect)
                for x in Computer.ships:
                    screen.blit(x.image, x.rect )
                screen.blit(Comica.image, Comica.rect)
                count = 1
#-------- end
 
#---- shooting display
            if shooted == 1:
                   for x2 in shoots:
                    screen.blit(x2.image,x2.rect)
                    if ((x2.test == True) & ((count%25)==0)):
                        screen.blit(background, backgroundRect )
                        for x in Computer.ships:
                            screen.blit(x.image, x.rect )
                        screen.blit(Comica.image, Comica.rect)
                        x2.Continue(Computer)
                    elif(x2.test == False):
                        shoots.remove(x2)
 
#----------end    
        else:
        #---- lost...
            inGame = False
            screen.blit(Computer.image, Computer.rect )
 
        pygame.display.update()
 
 
 
 
def clavier():
        # inputs from player
        for event in pygame.event.get():
 
            while event.type==pygame.KEYDOWN:
 
                if event.key==pygame.K_UP:                 
                    return("up")
                if event.key==pygame.K_DOWN:
                    return("down")
                if event.key==pygame.K_LEFT:
                    return("left")
                if event.key==pygame.K_RIGHT:
                    return("right")
                if event.key==pygame.K_q:
                    sys.exit()
 
            if event.type==pygame.QUIT:
                sys.exit()
 
 
 
 
 
 
 
 
 
def move(direction):
    # direction depending of clavier() function
    X = 20
    global shooted
 
 
 
 
 
    if direction=="left":
        newpos=[-X,0]
        essai= Comica.rect.move(newpos)
        if essai[0]>=-10:
            Comica.move(-X)
            screen.blit(background,backgroundRect)
            screen.blit(Comica.image, Comica.rect)
            for x in Computer.ships:
                screen.blit(x.image, x.rect )
 
    if direction=="right":
        newpos=[X,0]
        essai= Comica.rect.move(newpos)
        if essai[0]<width:
           Comica.move(X)
           screen.blit(background,backgroundRect)
           screen.blit(Comica.image, Comica.rect)
           for x in Computer.ships:
                screen.blit(x.image, x.rect )
 
    if direction=="down":
        print "ok"
    if direction == "up":
        shooted = 1
        shoots.append( Shoot(Comica.X, Comica.Y))

Salut !

Je rejoins josmiley, il me semble que c'est plus au niveau de la structure du code que ça se joue.

Pour commencer, ce qui me frappe c'est que tu dessines (blit) plusieurs fois l'image de fond, en entier. Evidemment, c'est un peu lourd au final. La première optimisation serait de ne dessiner l'image de fond qu'une seule fois avant de peindre les autres objets du jeu (vaisseaux, projectiles, etc.). C'est souvent suffisant lorsque l'image de fond n'est pas trop grosse.
Sinon, le top du top c'est de redessiner uniquement la portion d'écran où se trouve l'objet qui se déplace. La fonction blit possède un paramètre pour ne redessiner qu'une partie de la surface.

Ensuite, il y a la question du timing du jeu comme tu le relèves dans ton post. Les calculs du jeu sont placés dans une boucle sans fin mais il n'y a rien pour réguler leur exécution au cours du temps. Cela pose deux petits problèmes. Le premier c'est que ton programme va tourner à des vitesses différentes suivants les machines ^^ Normal, le système va exécuter aussi vite que possible le code et recommencer, ad eternam. C'est assez ennuyeux pour régler la difficulté des jeux.
Mais il y a une autre chose, ce genre de code à tendance à freezer le système parce que ton jeu va accaparer toutes les ressources, il ne laisse pas le temps aux autres tâches de s'exécuter.

La solution la plus simple, c'est d'ajouter un temps d'arrêt à la fin de ta boucle principale avec pygame.time.wait(50) ou même avec un temps plus court pygame.time.wait(10).
Là encore, la meilleure solution à mon avis, c'est de séparer dans deux méthodes la partie affichage de la partie calcul et de les cadencer précisément. De cette façon, tu peux régler à quelle vitesse ton jeu dois tout recalculer et afficher les éléments du jeu le reste du temps.

Perso, j'utilise la structure suivante :
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 01 import pygame 02 03 class Jeu: 04 """ Gestion de la logique du jeu et de son affichage. """ 05 def __init__(self): 06 self.dureeRound = 50 # Durée d'un round en ms. 07 self.jeuActif = True 08 self.tLogique = 0 # Durée des calculs de logique. 09 10 def maj (self): 11 """ Mise à jour du jeu. """ 12 t0 = pygame.time.get_ticks() 13 while(self.jeuActif): 14 t1 = pygame.time.get_ticks() 15 # Logique 16 if( (t1-t0) > self.dureeRound ): 17 self.majLogique() 18 t0 += self.dureeRound 19 # Calcul du temps pris par la logique. 20 if ( (t1-t0) > self.dureeRound ): 21 t0 = t1 - self.dureeRound 22 self.tLogique = t1-t0 23 # Affichage 24 self.pourcentTemps = float (t1-t0)/float(self.dureeRound) 25 self.majAffichage() 26 27 def majLogique(self): 28 """ Mise à jour . """ 29 ... 30 31 def majAffichage(self): 32 """ Mise à jour. """ 33 ...
La méthode majLogique contient les calculs du comportement du jeu, les tests, les décisions, etc. Elle se lance à intervalle de temps régulier (la valeur de self.dureeRound en millisecondes).
La méthode majAffichage mets à jour l'affichage des éléments du jeu dès que possible, entre les appels de la méthode majLogique.

Bien sur ce dispositif est un peu superflu pour un jeu comme space invaders, mais ça fonctionnes très bien et permet des jeux plus complexes au niveau des calculs ou du nombre d'éléments affichés.

bien, au vu du nombre de global que tu utilises, je pense qu'il va falloir tout reprendre du debut ^^
1.structurer le code
2.reflechir sur la routine d'affichage
3.identifier les sprites
3.1.que font les sprites, a quoi il repondent et quelles sonr leurs interactions

pour un jeu de ce type je propose la structure suivante:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
LES CLASS
une class pour ma navette
    repond au clavier
    interagit avec les bullets,moi
une class pour les ennemis
    autogéré
    interagit avec les ennemis(collisions)
une class pour les bullets
    autogéré
    interagit avec les ennemis(collisions)
 
LES VARIABLES
moi
ennemis=[...]
bullets=[...]
 
LES ROUTINES
une routine d affichage simple(peu de sprites)
une pour initialiser le jeu
un loop

le loop peut se presenter ainsi:

Code:

1
2
3
4
5
6
7
while jeu:
    moi.update()
    #insérer ici par exemple la creation de nouvelle navettes ennemies
    #en fonction de celles detruites et du level
    for ennemi in ennemis : ennemi.update()
    for bullet in bullets : bullet.update()
    refresh() #la routine affichage

l'affichage:

Code:

1
2
3
4
def refresh():
    screen.blit(background,(0,0))
    for sprite in [moi]+ennemis+bullets:
        screen.blit(sprite.image,sprite.position)

l'initialisation pour creer les navettes:

Code:

1
2
3
4
5
6
7
8
9
10
import pygame
pygame.init()
screen = pygame.display.set_mode(size)
screen_rect = screen.get_rect()
background = pygame.image.load('background.png')
#etc ...
moi = Moi()
ennemis  = [Ennemi() for x in range(10)]
bullets = []
refresh()

un exemple de class:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Moi:
    ''
    def __init__(self):
        self.image = pygame.image.load('me.png')
        self.rect = slef.image.get_rect() #plus simple que de rentrer les valeurs a la main
        self.rect.y = screen_rect.h-self.rect-h #place la navette en bas et
        self.rect.centerx = screen_rect.centerx #au centre du display
        self.impact = 10
        # d'une facon un peu barbare mais ça permet de modifier les constantes
        # genre 'size' sans se retaper tout le code
 
    def update(self):
        e = pygame.event.poll() # lit un evenement ce qui permet la lecture du clavier
        key = pygame.key.get_pressed() #lit le clavier
        if key[pygame.K_LEFT] : # si la fleche gauche est enfoncé
            if screen_rect.contains(self.rect.move(0,-2)):self.x -=2 # on teste que la navette va pas 
#sortir de l'ecran; si c'est bon on la déplace
        elif  key[pygame.K_RIGHT] :
            #etc ....

voilà pour commencer.
ceux sont des exemples, je ne sais pas ce que fait ton jeu en fait, j'imagine un truc à la 'chicken invaders'.
hésite pas à poser des questions ...

18/04/2010, 12h44
pagugu

Ok, merci pour toutes ces réponses, avec pygame.time.wait(50) ca marche très bien. Je vais restructurer un peut le code pour que ce soit au moins plus lisible pour la suite.
Merci tout le monde.
18/04/2010, 16h50
pagugu

Ok maintenant j'ai un autre soucis.
J'ai besoin d'une Base de Données très simple dans mon projet.
J'ai crée ma base de donnée sous MySQL et j'aimerais maintenant l'utiliser avec python.

Apparemment Gadfly correspond à mon besoin, le problème c'est que je ne trouve aucun site qui me permettrait de le télécharger... :aie:

Sinon j'ai essayé MySQLdb pas de problème pour le télécharger par contre je sais pas trop ou l'installer. Apparemment c'est créé pour Linux donc un peut plus dur à installer pour moi sous XP.
Avec MySQLdb je devrais recréer une nouvelle Base de Données si j'ai bien compris ?

PS: C'est bon j'ai réussi à télécharger GadFly et á l'installer en lançant le setup.py avec la fenêtre DOS