Come mai ci sono due istanze della stessa classe che si comportano diversamente? - python, python-2.7, classe, pygame, istanza

Quindi ho una lezione di ballo e due casiclasse. All'interno della classe vi è un metodo per le direzioni che accelera besaicamente la palla verso sinistra o destra, a seconda dei tasti freccia premuti. Ora il mio problema è, solo la palla di prima istanza può essere controllata dai tasti freccia. Com'è possibile che due istanze della stessa classe si comportino diversamente? Cosa dovrei cambiare in modo da poter controllare entrambe le palle? Preferibilmente preferisco mantenere i controlli delle palle all'interno della classe.

ecco il mio codice:

import pygame, sys


pygame.init()

red = (255,0,0)
black = (0,0,0)
white = (255,255,255)
blue = (0,0,255)
green = (0,255,0)

pygame.mouse.set_visible(0)
clock = pygame.time.Clock()

displaySize = (800,600)

screen = pygame.display.set_mode(displaySize)

g = 50
dt = 0.05

Cd = 0.01
m = 5


class ball:
def __init__(self, x, y, vx, vy, r,ax,ay, color):

self.Fx = 0
self.Fy = 0

self.Dx = 0
self.Dy = 0

self.ay = ay
self.ax = ax

self.x = x
self.y = y
self.r = r
self.color = color

self.vx = vx
self.vy = vy


def update(self):

self.x, self.y = self.physics()
pygame.draw.circle(screen, self.color, (int(round(self.x)),int(round(self.y))), self.r)




def directions(self):
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
self.ay +=-1000
if event.key == pygame.K_LEFT:
self.ax += -1000
if event.key == pygame.K_RIGHT:
self.ax += 1000



def physics(self):

self.Dy = Cd*self.vy*abs(self.vy)
self.Dx = Cd*self.vx*abs(self.vx)

self.Fy = m*g - self.Dy
self.Fx = -self.Dx

self.ay = self.Fy/m
self.ax = self.Fx/m

self.directions()

self.vy += self.ay*dt
self.vx += self.ax*dt

self.x +=self.vx*dt
self.y +=self.vy*dt


if self.x <= self.r:
self.x =self.r
self.vx *= -0.7

if self.x >= displaySize[0]- self.r:
self.x = displaySize[0] - self.r
self.vx *= -0.7

if self.y <= self.r:
self.y = self.r
self.vy *= -0.7

if self.y >= displaySize[1] - self.r:
self.y = displaySize[1] - self.r
self.vy *= -0.7


return self.x, self.y




ballOne = ball(100,100,50,-100,30,0,0,red)
ballTwo = ball(500,500,-75,0,45,0,0,green)
while 1:
clock.tick(60)
screen.fill(blue)

ballOne.update()
ballTwo.update()

pygame.display.flip()

for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()

risposte:

Non mi è molto familiare pygame, ma dal documentazione Direi che il problema è che la prima palla svuota la coda degli eventi quando chiami update().

La coda è vuota quando si chiama update() sulla seconda palla, quindi non si muove in quanto non ci sono eventi per dirgli di muoversi.

Lo stesso problema con la condizione di uscita I "d dire, non c'è mai un evento appropriato in coda quando si raggiunge quel punto nel codice.

Una soluzione rapida sarebbe quella di eseguire tutta l'elaborazione degli eventi nel tuo ciclo principale (dove controlli la condizione di uscita) e cambiare le tue palle in modo da informarle semplicemente sull'input del giocatore.

def playerinput(self, key):
if key == pygame.K_UP:
self.ay += -1000
...

Nel tuo ciclo principale, assumendo che tutte le tue palle siano in una lista playerobjects:

for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN:
for player in playerobjects:
player.playerinput(event.key)