Questa è un'introduzione a Pygame per le persone che già conoscono Python. Questo articolo ti insegnerà i passaggi per costruire un gioco semplice in cui il giocatore schiva le palle che rimbalzano.
Passi
Parte 1 di 8: installazione di Pygame
Passaggio 1. Scarica Pygame
Trovalo per la tua piattaforma da
Passaggio 2. Eseguire il programma di installazione
Passaggio 3. Verificare che l'installazione abbia funzionato
Apri un terminale Python. Digita "import pygame". Se non vedi errori, Pygame è stato installato con successo.
importa pygame
Parte 2 di 8: Impostazione di una finestra di base
Passaggio 1. Aprire un nuovo file
Passaggio 2. Importa Pygame
Pygame è una libreria che fornisce l'accesso alle funzioni grafiche. Se desideri maggiori informazioni su come funzionano queste funzioni, puoi cercarle sul sito Web di Pygame.
import pygame da pygame.locals import *
Passaggio 3. Imposta la risoluzione della finestra
Creerai una variabile globale per la risoluzione dello schermo in modo che possa essere referenziata in diverse parti del gioco. È anche facile da trovare nella parte superiore del file in modo che possa essere modificato in seguito. Per i progetti avanzati, mettere queste informazioni in un file separato sarebbe un'idea migliore.
risoluzione = (400, 300)
Passaggio 4. Definisci alcuni colori
I colori in pygame sono (RBGA che hanno valori compresi tra 0 e 255. Il valore alfa (A) è facoltativo ma gli altri colori (rosso, blu e verde sono obbligatori).
bianco = (255, 255, 255) nero = (0, 0, 0) rosso = (255, 0, 0)
Passaggio 5. Inizializzare lo schermo
Utilizzare la variabile di risoluzione definita in precedenza.
schermo = pygame.display.set_mode (risoluzione)
Passaggio 6. Crea un ciclo di gioco
Ripeti determinate azioni in ogni fotogramma del nostro gioco. Crea un ciclo che si ripeterà sempre per scorrere tutte queste azioni.
mentre vero:
Passaggio 7. Colora lo schermo
screen.fill (bianco)
Passaggio 8. Visualizzare lo schermo
Se esegui il programma, lo schermo diventerà bianco e quindi il programma si bloccherà. Questo perché il sistema operativo sta inviando eventi al gioco e il gioco non sta facendo nulla con loro. Una volta che il gioco riceve troppi eventi non gestiti, si blocca.
mentre True: … pygame.display.flip()
Passaggio 9. Gestire gli eventi
Ottieni un elenco di tutti gli eventi che si sono verificati in ciascun frame. Ti interesserà solo un evento, l'evento quit. Ciò si verifica quando l'utente chiude la finestra di gioco. Ciò impedirà anche al nostro programma di bloccarsi a causa di troppi eventi.
while True: … for event in pygame.event.get(): if event.type == QUIT: pygame.quit()
Passaggio 10. Provalo
Ecco come dovrebbe apparire il codice ora:
import pygame da pygame.locals import * risoluzione = (400, 300) bianco = (255, 255, 255) nero = (0, 0, 0) rosso = (255, 0, 0) schermo = pygame.display.set_mode(risoluzione) mentre True: screen.fill(white) pygame.display.flip() for event in pygame.event.get(): if event.type == QUIT: pygame.quit()
Parte 3 di 8: Creazione di un oggetto di gioco
Passaggio 1. Crea una nuova classe e un nuovo costruttore
Imposta tutte le proprietà dell'oggetto. Stai anche fornendo valori predefiniti per tutte le proprietà.
class Ball: def _init_(self, xPos = risoluzione[0] / 2, yPos = risoluzione[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "palla"
Passaggio 2. Definire come disegnare l'oggetto
Utilizzare le proprietà definite nel costruttore per disegnare la palla come un cerchio e per passare una superficie nella funzione su cui disegnare l'oggetto. La superficie sarà l'oggetto dello schermo che è stato creato utilizzando la risoluzione precedente.
def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius)
Passaggio 3. Creare un'istanza della classe e dire al ciclo di gioco di disegnare la pallina in ogni ciclo
ball = Ball() mentre True: … ball.draw(screen)
Passaggio 4. Fai muovere l'oggetto
Crea una funzione che aggiornerà la posizione dell'oggetto. Chiama questa funzione in ogni ciclo di gioco.
class Ball: … def update(self): self.x += self.dx self.y += self.dy
Passaggio 5. Limitare la frequenza dei fotogrammi
La palla si muoverà molto velocemente perché il ciclo di gioco viene eseguito centinaia di volte al secondo. Usa l'orologio di Pygame per limitare la frequenza dei fotogrammi a 60 fps.
clock = pygame.time. Clock() mentre True: … clock.tick(60)
Passaggio 6. Tieni la palla sullo schermo
Aggiungi controlli nella funzione di aggiornamento per invertire la direzione della palla se colpisce uno dei bordi dello schermo.
class Ball: … def update(self): … if (self.x <= 0 o self.x >= risoluzione[0]): self.dx *= -1 if (self.y <= 0 o self.y >= risoluzione[1]): self.dy *= -1
Passaggio 7. Provalo
Ecco come dovrebbe apparire il codice ora:
import pygame da pygame.locals import * risoluzione = (400, 300) bianco = (255, 255, 255) nero = (0, 0, 0) rosso = (255, 0, 0) schermo = pygame.display.set_mode(risoluzione) class Ball: def _init_(self, xPos = risoluzione[0] / 2, yPos = risoluzione[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "palla" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 o self.x >= risoluzione[0]): self.dx *= -1 if (self.y <= 0 o self.y >= risoluzione[1]): self.dy *= -1 ball = Ball() clock = pygame.time. Clock() while True: screen. fill(white) ball.draw(screen) ball.update() pygame.display.flip() clock.tick(60) for event in pygame.event.get(): if event.type == QUIT: pygame.quit ()
Parte 4 di 8: Organizzazione del gioco
Passaggio 1. Usa le classi per organizzare tutto
Il gioco sta per diventare più complicato. Usa tecniche orientate agli oggetti per organizzare il tuo codice.
Passaggio 2. Trasforma il ciclo di gioco in una classe
Poiché il nostro gioco ora ha dati che includono i tuoi oggetti e funzioni di gioco, ha senso trasformare il tuo ciclo di gioco in una classe.
gioco di classe():
Passaggio 3. Aggiungi un costruttore
Qui creerai un'istanza di alcuni oggetti di gioco, creerai il nostro schermo e l'orologio e inizializzerai Pygame. Pygame deve essere inizializzato per utilizzare determinate funzionalità come testo o suoni.
class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock()
Passaggio 4. Gestire gli eventi in una funzione
class game(): … def handleEvents(self): for event in pygame.event.get(): if event.type == QUIT: pygame.quit()
Passaggio 5. Rendi il ciclo di gioco una funzione
Chiama la funzione di gestione degli eventi ad ogni ciclo.
class game(): … def run(self): while True: self.handleEvents() self.screen.fill(white) self.clock.tick(60) pygame.display.flip()
Passaggio 6. Gestisci più oggetti di gioco
In questo momento questo codice deve chiamare draw e aggiornare sul nostro oggetto ogni frame. Questo diventerebbe disordinato se avessi molti oggetti. Aggiungiamo il nostro oggetto a un array e quindi aggiorniamo e disegniamo tutti gli oggetti nell'array ad ogni ciclo. Ora puoi facilmente aggiungere un altro oggetto e dargli una posizione di partenza diversa.
class game(): def _init_(self): … self.gameObjects = self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) … def run(self): while True: self.handleEvents() per gameObj in self.gameObjects: gameObj.update() self.screen.fill(bianco) per gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display. Flip()
Passaggio 7. Provalo
Ecco come dovrebbe apparire il codice ora:
import pygame da pygame.locals import * risoluzione = (400, 300) bianco = (255, 255, 255) nero = (0, 0, 0) rosso = (255, 0, 0) schermo = pygame.display.set_mode(risoluzione) class Ball: def _init_(self, xPos = risoluzione[0] / 2, yPos = risoluzione[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "palla" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 o self.x >= risoluzione[0]): self.dx *= -1 if (self.y <= 0 o self.y >= risoluzione[1]): self.dy *= -1 class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(self): for event in pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvent s() per gameObj in self.gameObjects: gameObj.update() self.screen.fill(bianco) per gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display. flip() gioco().run()
Parte 5 di 8: aggiunta di un oggetto giocatore
Passaggio 1. Crea una classe giocatore e un costruttore
Stai per creare un altro cerchio controllato dal mouse. Inizializzare i valori nel costruttore. Il raggio è l'unico valore importante.
class Player: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Passaggio 2. Definire come disegnare l'oggetto giocatore
Sarà lo stesso modo in cui hai disegnato gli altri oggetti del gioco.
class Player: … def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius)
Passaggio 3. Aggiungi il controllo del mouse per l'oggetto giocatore
In ogni fotogramma, controlla la posizione del mouse e imposta la posizione degli oggetti dei giocatori su quel punto.
class Player: … def update(self): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1]
Passaggio 4. Aggiungi un oggetto giocatore a gameObjects
Crea una nuova istanza giocatore e aggiungila all'elenco.
class game(): def _init_(self): … self.gameObjects.append(Player())
Passaggio 5. Provalo
Ecco come dovrebbe apparire il codice ora:
import pygame da pygame.locals import * risoluzione = (400, 300) bianco = (255, 255, 255) nero = (0, 0, 0) rosso = (255, 0, 0) schermo = pygame.display.set_mode(risoluzione) class Ball: def _init_(self, xPos = risoluzione[0] / 2, yPos = risoluzione[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "palla" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 o self.x >= risoluzione[0]): self.dx *= -1 if (self.y <= 0 o self.y >= risoluzione[1]): self.dy *= -1 classe Player: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "giocatore" def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update (self): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_ mode(resolution) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Player()) self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(self): for event in pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() for gameObj in self.gameObjects: gameObj.update() self.screen.fill(white) per gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game(). correre()
Parte 6 di 8: Far interagire gli oggetti con il giocatore
Passaggio 1. Modificare le funzioni di aggiornamento
Affinché gli oggetti possano interagire, dovranno avere accesso l'uno all'altro. Aggiungiamo un altro parametro ad Update per passare nell'elenco gameObjects. Dovrai aggiungerlo sia all'oggetto giocatore che agli oggetti Palla. Se hai molti oggetti di gioco, l'ereditarietà potrebbe aiutarti a mantenere tutte le firme dei tuoi metodi uguali.
class Ball: … def update(self, gameObjects): … class Player: … def update(self, gameObjects):
Passaggio 2. Verificare la presenza di collisioni tra il giocatore e le palle
Passa attraverso tutti gli oggetti del gioco e controlla se il tipo di oggetti è palla. Quindi usa i raggi dei due oggetti e la formula della distanza per verificare se si scontrano. I cerchi sono davvero facili da controllare sulle collisioni. Questa è la ragione principale per cui non hai usato un'altra forma per questo gioco.
class Player: … def update(self, gameObjects): … for gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2:
Passaggio 3. Termina il gioco se il giocatore viene "colpito"
Lasciamo perdere il gioco per ora.
if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit()
Passaggio 4. Provalo
Ecco come dovrebbe apparire il codice ora:
import pygame da pygame.locals import * risoluzione = (400, 300) bianco = (255, 255, 255) nero = (0, 0, 0) rosso = (255, 0, 0) schermo = pygame.display.set_mode(risoluzione) class Ball: def _init_(self, xPos = risoluzione[0] / 2, yPos = risoluzione[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "palla" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 o self.x >= risoluzione[0]): self.dx *= -1 if (self.y <= 0 o self.y >= risoluzione[1]): self.dy *= -1 classe Player: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "giocatore" def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] per gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit() class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Player()) self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(self): for event in pygame.event.get(): if event.type == QUIT: pygame.quit () def run(self): while True: self.handleEvents() for gameObj in self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill(white) for gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
Parte 7 di 8: aggiunta di un controller di gioco per creare oggetti
Passaggio 1. Creare una classe di controller di gioco
I controller di gioco sono responsabili dell'"esecuzione" del gioco. È diverso dalla nostra classe di gioco che è responsabile del disegno e dell'aggiornamento di tutti i nostri oggetti. Il controller aggiungerà periodicamente un'altra palla allo schermo per rendere il gioco più difficile. Aggiungi un costruttore e inizializza alcuni valori di base. L'intervallo sarà il tempo prima che venga aggiunta un'altra palla.
class GameController: def _init_(self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks() + (2 * 1000) self.type = "controller di gioco"
Passaggio 2. Aggiungi la funzione di aggiornamento
Questo controllerà quanto tempo è passato dal momento in cui è stata aggiunta una palla o dall'inizio del gioco. Se il tempo è superiore all'intervallo, azzerare il tempo e aggiungere una palla.
class GameController: … def update(self, gameObjects): if self.next < pygame.time.get_ticks(): self.next = pygame.time.get_ticks() + (self.inter * 1000) gameObjects.append(Ball())
Passaggio 3. Assegna alle palline velocità casuali
Dovrai usare numeri casuali per rendere il gioco diverso ogni volta. Tuttavia, le velocità delle sfere ora sono un numero in virgola mobile anziché un intero.
class GameController: … def update(self, gameObjects): if self.next < pygame.time.get_ticks(): self.next = pygame.time.get_ticks() + (self.inter * 1000) gameObjects.append(Ball(xVel=casuale()*2, yVel=casuale()*2))
Passaggio 4. Correggi la funzione di disegno
La funzione di disegno non accetterà float. Convertiamo la posizione della pallina in numeri interi prima che le palline vengano estratte.
class Ball: … def draw(self, surface): pygame.draw.circle(surface, black, (int(self.x), int(self.y)), self.radius)
Passaggio 5. Definire un metodo di estrazione per il controller di gioco
Poiché è un oggetto di gioco, il ciclo principale proverà a disegnarlo. Dovrai definire una funzione di disegno che non faccia nulla in modo che il gioco non vada in crash.
class GameController: … def draw(self, screen): pass
Passaggio 6. Aggiungi il controller di gioco a gameObjects e rimuovi le 2 palline
Il gioco dovrebbe ora generare una palla ogni cinque secondi.
class game(): def _init_(self): … self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player())
Passaggio 7. Provalo
Ecco come dovrebbe apparire il codice ora:
import pygame from random import random from pygame.locals import * risoluzione = (400, 300) bianco = (255, 255, 255) nero = (0, 0, 0) rosso = (255, 0, 0) schermo = pygame. display.set_mode(resolution) class Ball: def _init_(self, xPos = risoluzione[0] / 2, yPos = risoluzione[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "palla" def draw(self, surface): pygame.draw.circle(surface, black, (int(self. x), int(self.y)), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 o self. x >= risoluzione[0]): self.dx *= -1 if (self.y <= 0 o self.y >= risoluzione[1]): self.dy *= -1 class Player: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "giocatore" def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] per gameObj in game Oggetti: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)* *2: pygame.quit() class GameController: def _init_(self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks() + (2 * 1000) self.type = "controller di gioco " def update(self, gameObjects): if self.next < pygame.time.get_ticks(): self.next = pygame.time.get_ticks() + (self.inter * 1000) gameObjects.append(Ball(xVel=random ()*2, yVel=random()*2)) def draw(self, screen): pass class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player()) def handleEvents(self): for event in pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() for gameObj in self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill(bianco) per gameObj in self.gameO oggetti: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
Parte 8 di 8: aggiunta di un punteggio e fine partita
Passaggio 1. Aggiungi un punteggio alla classe del controller di gioco
Crea un oggetto font e una variabile punteggio. Disegnerai il carattere in ogni fotogramma per visualizzare il punteggio e aumentare il punteggio ogni fotogramma in aggiornamento.
class GameController: def _init_(self, interval = 5): … self.score = 0 self.scoreText = pygame.font. Font(None, 12) def update(self, gameObjects): … self.score += 1 def draw (self, screen): screen.blit(self.scoreText.render(str(self.score), True, black), (5, 5))
Passaggio 2. Modifica la modalità di fine del gioco
Eliminiamo l'uscita quando il giocatore rileva una collisione. Invece imposterai una variabile nel giocatore che il gioco può controllare. Quando gameOver è impostato, smetti di aggiornare gli oggetti. Questo bloccherà tutto in posizione in modo che il giocatore possa vedere cosa è successo e controllare il proprio punteggio. Nota che gli oggetti vengono ancora disegnati, ma non aggiornati.
class Player: def _init_(self, rad = 20): … self.gameOver = False def update(self, gameObjects): … for gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: self.gameOver = True class game(): def _init_(self): … self.gameOver = False def run(self): while True: self.handleEvents() if not self.gameOver: for gameObj in self.gameObjects: gameObj.update(self.gameObjects) if gameObj.type == "player": self.gameOver = gameObj.gameOver
Passaggio 3. Provalo
Ecco come dovrebbe apparire ora il codice finito:
import pygame from random import random from pygame.locals import * risoluzione = (400, 300) bianco = (255, 255, 255) nero = (0, 0, 0) rosso = (255, 0, 0) schermo = pygame. display.set_mode(resolution) class Ball: def _init_(self, xPos = risoluzione[0] / 2, yPos = risoluzione[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "palla" def draw(self, surface): pygame.draw.circle(surface, black, (int(self. x), int(self.y)), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 o self. x >= risoluzione[0]): self.dx *= -1 if (self.y <= 0 o self.y >= risoluzione[1]): self.dy *= -1 class Player: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "giocatore" self.gameOver = False def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] for gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: self.gameOver = True class GameController: def _init_(self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks() + (2 * 1000) self. type = "controller di gioco" self.score = 0 self.scoreText = pygame.font. Font(None, 12) def update(self, gameObjects): if self.next < pygame.time.get_ticks(): self.next = pygame.time.get_ticks() + (self.inter * 1000) gameObjects.append(Ball(xVel=random()*2, yVel=random()*2)) self.score += 1 def draw(self, screen): screen.blit(self.scoreText.render(str(self.score), True, black), (5, 5)) class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player()) self.gameOver = False def handleEvents(self): for event in pygame.event.get(): if ev ent.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() if not self.gameOver: for gameObj in self.gameObjects: gameObj.update(self.gameObjects) if gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill(bianco) per gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip () gioco().run()
