Discussion :

[whereisbenito]

Bonjour tous le monde,
pour m'entrainer a utiliser pygame et pyhton en génerale j'ai essailler de recrée le jeu the powder toy.
voici le code 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
import pygame
import pyautogui
 
from particule import Part
 
class Game:
    def __init__(self, screen):
        self.screen = screen
        self.running = True
        self.clock = pygame.time.Clock()
        self.parts = {}
        self.color = "black"
        self.z = 0
 
    def handling_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.running = False
 
        keys = pygame.key.get_pressed()
        if keys[pygame.K_c]:
            x = 5 * round(pyautogui.position()[0] / 5)
            y = 5 * round(pyautogui.position()[1] / 5)
            if {"x":x,"y":y} not in self.parts.values():
                self.parts[self.z] = {"x": x,"y": y,}
                self.z += 1
                print(self.z)
 
 
    def update(self):
 
        for part in self.parts.copy():
            if self.parts[part]["y"] <= 550 and {"x":self.parts[part]["x"],"y":self.parts[part]["y"] + 5,} not in self.parts.values():
                self.parts[part]["y"] += 5
 
 
    def display(self):
        for part in self.parts.copy():
            rect = Part(self.parts[part]["x"], self.parts[part]["y"]-5)
            rect.draw(self.screen, self.color)
            rect1 = Part(self.parts[part]["x"], self.parts[part]["y"])
            rect1.draw(self.screen,"red")
 
 
        pygame.display.flip()
 
    def run(self):
        while self.running:
            self.handling_events()
            self.update()
            self.display()
            self.clock.tick(60)
 
 
pygame.init()
screen = pygame.display.set_mode((900, 600))
game = Game(screen)
game.run()
 
pygame.quit()

et la classe part:

Code :

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

1
2
3
4
5
6
7
8
9
10
import pygame
 
 
class Part:
 
    def __init__(self, x, y):
        self.rect = pygame.Rect(x, y, 5, 5)
 
    def draw(self, screen, color):
        pygame.draw.rect(screen,color,self.rect)

voila mes question:
-comment optimiser mon code pour le rendre plus performent
-la class part est elle utile dans ce genre de jeu
-comment enregistrer chaque rect de l'ecran efficacement

Merci pour vos réponce

[fred1599]

Hello,

comment optimiser mon code pour le rendre plus performent

Quels sont les problèmes de performances ? Avez-vous fait des tests et quels sont les goulots d'étranglement que vous avez perçu ?

la class part est elle utile dans ce genre de jeu

C'est vous qui codez, pas nous, c'est à vous de savoir cela... Ce code a-t-il été développé par vous même ?

comment enregistrer chaque rect de l'ecran efficacement

Il n'y a pas plusieurs manière d'enregistrer, seule la méthode save permet cela.

[whereisbenito]

Hello,



Quels sont les problèmes de performances ? Avez-vous fait des tests et quels sont les goulots d'étranglement que vous avez perçu ?



C'est vous qui codez, pas nous, c'est à vous de savoir cela... Ce code a-t-il été développé par vous même ?



Il n'y a pas plusieurs manière d'enregistrer, seule la méthode save permet cela.

merci pour votre réponse:

je pense que les problème des performance sont liée au nombre de rect car plus il y en a plus les boucles for dure et que même une fois tombé les rect sont toujours dans les boucles for mais comment puis-je faire pour contrer cela.

[wiztricks]

-comment optimiser mon code pour le rendre plus performent

Apprenez à utiliser les outils et évitez les répétitions!
Regardez cet extrait:

Code :

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

1
2
3
4
5
6
7
8
       keys = pygame.key.get_pressed()
        if keys[pygame.K_c]:
            x = 5 * round(pyautogui.position()[0] / 5)
            y = 5 * round(pyautogui.position()[1] / 5)
            if {"x":x,"y":y} not in self.parts.values():
                self.parts[self.z] = {"x": x,"y": y,}
                self.z += 1
                print(self.z)

Déjà pourquoi utilisez-vous pyautogui.position (une autre bibliothèque) alors que pygame dispose de mouse.get_pos. Ces deux fonctions retournent un tuple et stocker le retour d'un appel est plus économique qu e d'appeler 2 fois la fonction.
Inutile d'utiliser "round" puisque ces fonctions retournent de entiers et qu'on dispose de la division entière.
Pour le reste, quel est l'intérêt d'un dictionnaire où on ajoute les nouveaux items à la fin? comparé à une liste de...?
Qui plus est 5*x//5 fabrique des cases de dimension 5. Si la largeur de l'écran est 900, ça fait une liste de 180 cases où l'accès direct sera plus efficace que de comparer un nombre indéfini d'items.

Ce qui fait beaucoup de questions pour quelques lignes de code...

- W

[whereisbenito]

Apprenez à utiliser les outils et évitez les répétitions!
Regardez cet extrait:

Code :

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

1
2
3
4
5
6
7
8
       keys = pygame.key.get_pressed()
        if keys[pygame.K_c]:
            x = 5 * round(pyautogui.position()[0] / 5)
            y = 5 * round(pyautogui.position()[1] / 5)
            if {"x":x,"y":y} not in self.parts.values():
                self.parts[self.z] = {"x": x,"y": y,}
                self.z += 1
                print(self.z)

Déjà pourquoi utilisez-vous pyautogui.position (une autre bibliothèque) alors que pygame dispose de mouse.get_pos. Ces deux fonctions retournent un tuple et stocker le retour d'un appel est plus économique qu e d'appeler 2 fois la fonction.
Inutile d'utiliser "round" puisque ces fonctions retournent de entiers et qu'on dispose de la division entière.
Pour le reste, quel est l'intérêt d'un dictionnaire où on ajoute les nouveaux items à la fin? comparé à une liste de...?
Qui plus est 5*x//5 fabrique des cases de dimension 5. Si la largeur de l'écran est 900, ça fait une liste de 180 cases où l'accès direct sera plus efficace que de comparer un nombre indéfini d'items.

Ce qui fait beaucoup de questions pour quelques lignes de code...

- W

merci pour votre réponse,

j'ai essailler sans la fonction "round" mais ca ne créer pas des cases tout les 5 pixels.

pour la fonction mouse.get_pos je ne la connaissais pas, je vais donc changer cela.

pourrier vous m'expliquer comment mettre ca en place "Pour le reste, quel est l'intérêt d'un dictionnaire où on ajoute les nouveaux items à la fin? comparé à une liste de...?
la largeur de l'écran est 900, ça fait une liste de 180 cases où l'accès direct sera plus efficace que de comparer un nombre indéfini d'items." je ne suis pas sur de comprendre.

[wiztricks]

j'ai essailler sans la fonction "round" mais ca ne créer pas des cases tout les 5 pixels

round ne crée pas de cases... et 5*(x//5) revient à peu près à écrire 5*round(x/5) et fabrique un multiple de 5 (ou des cases de dimension 5).

je ne suis pas sur de comprendre.

Vous créez une liste de 180 items initialisés à None ou à liste vide.
Puis a chaque x multiple de 5 correspond un k (tel que 5*k = x) qui sera un numéro de case. Reste a savoir ce qu'on met dans la case: la valeur de y, un Rect, une liste de...
Mais c'est vous qui programmez... et on ne sait pas trop ce que vous cherchez à coder.

- W

[wiztricks]

Salut,

Voilà a quoi ça pourrait ressembler (au moins ce que j'en ai compris).

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
import pygame
from pygame import event, mouse, Rect, QUIT, K_c, key, draw
from collections import defaultdict
 
SIZE = 5
WIDTH = 900
HEIGHT = 600
 
class Table(defaultdict):
    def __init__(self):
        super().__init__(list)
        self.fence = defaultdict(lambda: HEIGHT - 10*SIZE, {})
        self.columns = defaultdict(list)
 
    def update(self, x, y):
        i = x // SIZE
        x = i * SIZE
        y = SIZE * (y // SIZE)
 
        rects = self[i]
        # insert sorted in sorted list without duplicate.
        for k, r in enumerate(rects):
            if y <= r.y:
                if y != r.y:
                    rects.insert(k, Rect(x, y, SIZE, SIZE))
                break
        else:
            rects.append( Rect(x, y, SIZE, SIZE))
 
    def draw(self, screen):
        for j, rects in self.items():
            # shift red rects down and stack up.
            for k in range(len(rects)-1, -1, -1):
                r = rects[k]
                if r.y > self.fence[j]:
                    rects.pop(-1)
                    self.fence[j] -= SIZE
                else:
                    draw.rect(screen, 'black', r)
                    r.y += SIZE
                draw.rect(screen, 'red', r)
 
if __name__ == '__main__':
 
    pygame.init()
    screen = pygame.display.set_mode(size=(WIDTH, HEIGHT))
    clock = pygame.time.Clock()
 
    table = Table()
 
    done = False
    while not done:
        for e in event.get():
            if e.type == QUIT:
                done = True
                break
            keys = key.get_pressed()
            if keys[K_c]:
                table.update(*mouse.get_pos())
        else: # no break.
            table.draw(screen)
            clock.tick(60)
            pygame.display.flip()
 
    pygame.quit()

- W