Software de diseño y desarrollo Principal: Pygame Smudge Trails

Question

En primer lugar, he buscado en línea y este sitio web para las soluciones y los que he probado no funcionan, así que decidí publicar mi pregunta y código individual. Este programa fue creado usando Python 3.2.2 y la versión compatible correspondiente de pygame. También me doy cuenta de que un método más eficiente sería usar sprites, grupos de sprites y actualización 'dirty rect', pero no puedo convertir el programa y continuaré sin los beneficios adicionales de tales funciones.

Problema: Los rastros de borrones donde se mueven los 'asteroides' se quedan atrás.
Hipótesis: El fondo se ve bliteado en la pantalla, pero los asteroides se rompen en el fondo.

favor Responder - por cierto yo soy un highschooler desde 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

Básicamente, usted tiene razón! Los círculos se dibujan directamente en el fondo, y cada vez que se dibujan círculos nuevos, los círculos antiguos permanecen. Resultando en las manchas/senderos.

Puede simplemente cambiar background a screen en su método draw. Esto lo arreglará.

Pero realmente vale la pena utilizar las clases Sprite según lo previsto. He hecho algunos cambios en su código para cambiarlo por usted. Con estos cambios se ejecuta sin rastros :)

Estos son los cambios y las explicaciones sobre los defectos:

Añadir esta cerca de la cima:

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

Esto, unido al método 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() 

Añadir esto al final de def move(self):

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

cambio:

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

cambio:

my_particles.append(target) 

a:

my_particles.add(target) 

cambio:

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

Retirar el método display ya que ya no es necesaria.

Esto también se ejecutará mucho más rápido que el código anterior, ya que el tiempo necesario para dibujar algo es proporcional al tamaño del área de dibujo, y anteriormente dibujaba todo el fondo cada vez; ahora solo dibuja los sprites y cambios en el fondo!

Espero que esto ayude :)