Progettazione e sviluppo di software Major: Pygame Smudge Trails

Question

Prima di tutto, ho cercato online e questo sito per soluzioni e quelli che ho provato non funzionano così ho deciso di pubblicare la mia domanda individuale e il codice. Questo programma è stato creato usando Python 3.2.2 e la corrispondente versione compatibile di pygame. Mi rendo anche conto che un metodo più efficiente sarebbe utilizzare gli sprite, i gruppi sprite e l'aggiornamento "dirty rect", ma non sono in grado di convertire il programma e quindi continuerò senza i vantaggi aggiuntivi di tali funzioni.

Problema: tracce di sbavature in cui si muovono gli asteroidi vengono lasciate indietro.
Ipotesi: lo sfondo viene proiettato sullo schermo, tuttavia gli asteroidi vengono inseriti sullo sfondo.

preghiamo di rispondere - btw io sono un highschooler da AUS: D

import pygame 
import random 
import math 
pygame.init() 

height = 550 
width = 750 
screen = pygame.display.set_mode((width, height)) 
background = pygame.image.load("Planet.jpg") 
Clock = pygame.time.Clock() 


class asteroid(pygame.sprite.Sprite): 
    def __init__(self, x, y, size): 
     pygame.sprite.Sprite.__init__(self) 
     self.x = x 
     self.y = y 
     self.size = 15 
     self.speed = 0.0 
     self.angle = 0 
     self.colour = (171, 130, 255) 
     self.thickness = 0 

def display(self): 
    pygame.draw.circle(background, self.colour, (int(self.x),int(self.y)), self.size, self.thickness) 

    pygame.draw.circle(background, (255, 255, 255), (int(self.x),int(self.y)), self.size, 1) 

def move(self): 
    self.x += math.sin(self.angle) * self.speed 
    self.y -= math.cos(self.angle) * self.speed 

def boundaries(self): 
    if self.x > width - self.size: 
     self.x = 0 + self.size 
    elif self.x < self.size: 
     self.x = width - self.size 
    if self.y > height - self.size: 
     self.y = 0 + self.size 
    elif self.y <self.size: 
     self.y = height - self.size 




num_target = 5 
my_particles = [] 
num_particles = len(my_particles) 
while num_particles < 5: 
    for n in range(num_target): 
     size = 20 
     x = random.randint(size, height - size) 
     y = random.randint(size, width - size) 
     target = asteroid(x, y, size) 
     target.speed = random.uniform(1.0, 1.0) 
     target.angle = random.uniform(0, math.pi*2) 
     my_particles.append(target) 
     num_particles = num_particles + 1 


def main(): 
    pygame.display.set_caption("Anyu's Game") 
    screen.blit(background, (0,0)) 
    pygame.display.update() 
    score = (pygame.time.get_ticks()/1000) 
    print (score) 


while True: 
    pygame.display.update() 
    screen.blit(background, (0,0)) 
    MouseP = pygame.mouse.get_pos() 
    frames = Clock.get_fps 
    pygame.mouse.set_visible 
    score = (pygame.time.get_ticks()/1000) 
    print (score) 
    print (MouseP) 
    for target in my_particles: 
     target.move() 
     target.boundaries() 
     target.display() 
     pygame.display.update() 


    for event in pygame.event.get(): 

     if event.type == pygame.QUIT: 
      pygame.quit(); 

if __name__=='__main__': 
    main() 

Answer 1

In sostanza, hai ragione! I cerchi sono disegnati direttamente sullo sfondo, e ogni volta che vengono disegnati nuovi cerchi, i vecchi cerchi rimangono. Con conseguente macchie/tracce.

È possibile modificare screenscreen nel proprio metodo draw. Questo lo risolverà.

Ma vale davvero la pena utilizzare le classi Sprite come previsto. Ho apportato alcune modifiche al tuo codice per cambiarlo per te. Con queste modifiche si corre senza sentieri :)

Ecco le modifiche e le spiegazioni:

Aggiungi questo vicino alla parte superiore:

#Create a new `pygame.Surface`, and draw a circle on it, then set transparency: 
circle = pygame.Surface((30,30)) 
circle = circle.convert() 
pygame.draw.circle(circle, (171, 130, 255), (int(15),int(15)), 15, 0) 
circle.set_colorkey(circle.get_at((0, 0)), pygame.RLEACCEL) 

Aggiungi questo al metodo asteroid, __init__:

#Sets the asteroid image, and then the asteroids co-ords (these are in `rect`) 
     self.image = circle 
     self.rect = self.image.get_rect() 

Aggiungere questo alla fine di def move(self):

 self.rect[0] = self.x 
     self.rect[1] = self.y 

cambiamento:

my_particles = [] 

a:

#This is a special pygame container class, it has a draw() method that tracks changed areas of the screen. 
my_particles = pygame.sprite.RenderUpdates() 

cambiamento:

my_particles.append(target) 

a:

my_particles.add(target) 

cambiamento:

while True: 
    pygame.display.update() 
    screen.blit(background, (0,0)) 
    MouseP = pygame.mouse.get_pos() 
    frames = Clock.get_fps 
    pygame.mouse.set_visible 
    score = (pygame.time.get_ticks()/1000) 
    print (score) 
    print (MouseP) 
    for target in my_particles: 
     target.move() 
     target.boundaries() 
     target.display() 
     pygame.display.update() 

a:

#initial screen draw: 
screen.blit(background, (0,0)) 
pygame.display.update() 
while True: 
    #remove previous drawn sprites and replaces with background: 
    my_particles.clear(screen, background) 
    MouseP = pygame.mouse.get_pos() 
    frames = Clock.get_fps 
    pygame.mouse.set_visible 
    score = (pygame.time.get_ticks()/1000) 
    print (score) 
    print (MouseP) 
    for target in my_particles: 
     target.move() 
     target.boundaries() 
    #draws changed sprites to the screen: 
    pygame.display.update(my_particles.draw(screen)) 

Rimuovere il metodo display in quanto non è più necessaria.

Questo sarà anche molto più veloce del tuo codice precedente, poiché il tempo necessario per disegnare qualcosa è proporzionale alla dimensione dell'area di disegno, e in precedenza si stava disegnando tutto lo sfondo ogni volta - ora si disegna solo gli sprite e cambia in background!

Spero che questo aiuti :)