Dette er en introduktion til Pygame for folk, der allerede kender Python. Denne artikel vil lære dig trinene til at bygge et simpelt spil, hvor spilleren undviger hoppende bolde.
Trin
Del 1 af 8: Installation af Pygame
Trin 1. Download Pygame
Find den til din platform fra
Trin 2. Kør installationsprogrammet
Trin 3. Kontroller, at installationen fungerede
Åbn en Python -terminal. Skriv "import pygame". Hvis du ikke kan se nogen fejl, blev Pygame installeret.
importer pygame
Del 2 af 8: Opsætning af et grundlæggende vindue
Trin 1. Åbn en ny fil
Trin 2. Importer Pygame
Pygame er et bibliotek, der giver adgang til grafikfunktioner. Hvis du vil have mere information om, hvordan disse funktioner fungerer, kan du slå dem op på Pygame -webstedet.
import pygame fra pygame.locals import *
Trin 3. Indstil vinduesopløsningen
Du laver en global variabel for skærmopløsningen, så der kan refereres til i flere dele af spillet. Det er også let at finde øverst i filen, så den kan ændres senere. For avancerede projekter ville det være en bedre idé at lægge disse oplysninger i en separat fil.
opløsning = (400, 300)
Trin 4. Definer nogle farver
Farver i pygame er (RBGA, der ligger i værdier mellem 0 og 255. Alfa -værdien (A) er valgfri, men de andre farver (rød, blå og grøn er obligatoriske).
hvid = (255, 255, 255) sort = (0, 0, 0) rød = (255, 0, 0)
Trin 5. Initialiser skærmen
Brug den opløsningsvariabel, der blev defineret tidligere.
skærm = pygame.display.set_mode (opløsning)
Trin 6. Lav en spil loop
Gentag visse handlinger i alle rammer i vores spil. Lav en loop, der altid vil gentages for at gennemgå alle disse handlinger.
mens det er sandt:
Trin 7. Farv skærmen
skærm. udfyldning (hvid)
Trin 8. Vis skærmen
Hvis du kører programmet, bliver skærmen hvid, og derefter går programmet ned. Dette skyldes, at operativsystemet sender begivenheder til spillet, og spillet ikke gør noget med dem. Når spillet modtager for mange uhåndterede begivenheder, vil det gå ned.
mens det er sandt: … pygame.display.flip ()
Trin 9. Håndter begivenheder
Få en liste over alle hændelser, der er sket i hver ramme. Du vil kun bekymre dig om en begivenhed, den afslutte begivenhed. Dette sker, når brugeren lukker spilvinduet. Dette forhindrer også, at vores program går ned på grund af for mange begivenheder.
mens True: … for begivenhed i pygame.event.get (): hvis event.type == QUIT: pygame.quit ()
Trin 10. Prøv det
Sådan skal koden se ud nu:
import pygame fra pygame.locals import * opløsning = (400, 300) hvid = (255, 255, 255) sort = (0, 0, 0) rød = (255, 0, 0) skærm = pygame.display.set_mode (opløsning) mens True: screen.fill (hvid) pygame.display.flip () for hændelse i pygame.event.get (): hvis event.type == QUIT: pygame.quit ()
Del 3 af 8: Making a Game Object
Trin 1. Lav en ny klasse og konstruktør
Angiv alle egenskaberne for objektet. Du angiver også standardværdier for alle ejendomme.
klasse Bold: def _init _ (self, xPos = opløsning [0] / 2, yPos = opløsning [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 = "bold"
Trin 2. Definer, hvordan objektet skal tegnes
Brug de egenskaber, der var defineret i konstruktøren, til at tegne bolden som en cirkel samt til at føre en overflade ind i funktionen for at tegne objektet på. Overfladen er det skærmobjekt, der blev oprettet ved hjælp af opløsningen tidligere.
def draw (selv, overflade): pygame.draw.circle (overflade, sort, (self.x, self.y), self.radius)
Trin 3. Lav en forekomst af klassen samt fortæl spillegangen om at trække bolden i hver løkke
bold = Ball () mens True: … ball.draw (skærm)
Trin 4. Få objektet til at bevæge sig
Opret en funktion, der opdaterer objektets position. Kald denne funktion i hver spil loop.
klasse Bold: … def opdatering (self): self.x += self.dx self.y += self.dy
Trin 5. Begræns billedfrekvensen
Bolden bevæger sig virkelig hurtigt, fordi spilløkken kører hundredvis af gange i sekundet. Brug Pygames ur til at begrænse billedhastigheden til 60 fps.
ur = pygame.time. Clock () mens True: … clock.tick (60)
Trin 6. Hold bolden på skærmen
Tilføj checks i opdateringsfunktionen for at vende boldens retning, hvis den rammer en af skærmens kanter.
klasse Bold:… def opdatering (self):… if (self.x <= 0 eller self.x> = opløsning [0]): self.dx *= -1 if (self.y <= 0 eller self.y > = opløsning [1]): self.dy *= -1
Trin 7. Prøv det
Sådan skal koden se ud nu:
import pygame fra pygame.locals import * opløsning = (400, 300) hvid = (255, 255, 255) sort = (0, 0, 0) rød = (255, 0, 0) skærm = pygame.display.set_mode (opløsning) klasse Bold: def _init _ (selv, xPos = opløsning [0] / 2, yPos = opløsning [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 = "bold" def draw (self, overflade): pygame.draw.circle (overflade, sort, (self.x, self.y), self.radius) def opdatering (self): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self.x> = opløsning [0]): self.dx *= -1 hvis (self.y <= 0 eller self.y> = opløsning [1]): self.dy *= -1 bold = Ball () ur = pygame.time. Clock () mens True: skærm. udfyld (hvid) ball.draw (skærm) ball.update () pygame.display.flip () clock.tick (60) for begivenhed i pygame.event.get (): hvis event.type == QUIT: pygame.quit ()
Del 4 af 8: Organisering af spillet
Trin 1. Brug klasser til at organisere alt
Spillet bliver mere kompliceret. Brug objektorienterede teknikker til at organisere din kode.
Trin 2. Gør spilløkken til en klasse
Da vores spil nu har data, herunder dine spilobjekter og funktioner, er det fornuftigt at omdanne dit spil til en klasse.
klassespil ():
Trin 3. Tilføj en konstruktør
Her vil du instantiere nogle spilobjekter, oprette vores skærm og ur og initialisere Pygame. Pygame skal initialiseres for at bruge bestemte funktioner som tekst eller lyd.
klassespil (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (opløsning) self.clock = pygame.time. Clock ()
Trin 4. Håndter begivenheder i en funktion
klassespil (): … def handleEvents (self): for begivenhed i pygame.event.get (): if event.type == QUIT: pygame.quit ()
Trin 5. Gør game loop til en funktion
Ring til eventhåndteringsfunktionen hver loop.
klassespil (): … def run (self): mens True: self.handleEvents () self.screen.fill (hvid) self.clock.tick (60) pygame.display.flip ()
Trin 6. Håndter flere spilobjekter
Lige nu skal denne kode kalde draw og opdatere på vores objekt hver ramme. Dette ville blive rodet, hvis du havde mange objekter. Lad os tilføje vores objekt til et array og derefter opdatere og tegne alle objekter i arrayet hver loop. Nu kan du nemt tilføje et andet objekt og give det en anden startposition.
klassespil (): def _init _ (self): … self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) … def run (self): mens True: self.handleEvents () til gameObj i self.gameObjects: gameObj.update () self.screen.fill (hvid) til gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip ()
Trin 7. Prøv det
Sådan skal koden se ud nu:
import pygame fra pygame.locals import * opløsning = (400, 300) hvid = (255, 255, 255) sort = (0, 0, 0) rød = (255, 0, 0) skærm = pygame.display.set_mode (opløsning) klasse Bold: def _init _ (selv, xPos = opløsning [0] / 2, yPos = opløsning [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 = "bold" def draw (self, overflade): pygame.draw.circle (overflade, sort, (self.x, self.y), self.radius) def opdatering (self): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self.x> = opløsning [0]): self.dx *= -1 hvis (self.y <= 0 eller self.y> = opløsning [1]): self.dy *= -1 klassespil (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (opløsning) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): for hændelse i pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvent s () for gameObj i self.gameObjects: gameObj.update () self.screen.fill (hvid) til gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. flip () game (). run ()
Del 5 af 8: Tilføjelse af et spillerobjekt
Trin 1. Lav en spillerklasse og konstruktør
Du kommer til at lave en anden cirkel, der styres af musen. Initialiser værdierne i konstruktøren. Radius er den eneste vigtige værdi.
klasse Spiller: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Trin 2. Definer, hvordan du tegner spillerobjektet
Det bliver på samme måde som du tegnede de andre spilobjekter.
klasse Spiller: … def draw (self, surface): pygame.draw.circle (overflade, rød, (self.x, self.y), self.radius)
Trin 3. Tilføj musekontrol til afspillerobjektet
I hver ramme skal du kontrollere musens placering og indstille spillerens objekters placering til det punkt.
class Player:… def opdatering (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
Trin 4. Føj et spillerobjekt til gameObjects
Opret en ny spillerinstans, og tilføj den til listen.
klassespil (): def _init _ (self): … self.gameObjects.append (Player ())
Trin 5. Prøv det
Sådan skal koden se ud nu:
import pygame fra pygame.locals import * opløsning = (400, 300) hvid = (255, 255, 255) sort = (0, 0, 0) rød = (255, 0, 0) skærm = pygame.display.set_mode (opløsning) klasse Bold: def _init _ (selv, xPos = opløsning [0] / 2, yPos = opløsning [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 = "bold" def draw (self, overflade): pygame.draw.circle (overflade, sort, (self.x, self.y), self.radius) def opdatering (self): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self.x> = opløsning [0]): self.dx *= -1 hvis (self.y <= 0 eller self.y> = opløsning [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, surface): pygame.draw.circle (overflade, rød, (self.x, self.y), self.radius) def opdatering (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 (opløsning) 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 (hvid) til gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). løb()
Del 6 af 8: Gør objekter i interaktion med afspilleren
Trin 1. Skift opdateringsfunktionerne
For at objekter kan interagere, skal de have adgang til hinanden. Lad os tilføje en anden parameter til Opdatering for at videregive i gameObjects -listen. Du skal tilføje den til både spillerobjektet og Ball -objekterne. Hvis du har mange spilobjekter, kan arv hjælpe dig med at holde alle dine metodesignaturer de samme.
klasse Bold: … def opdatering (self, gameObjects): … class Player: … def update (self, gameObjects):
Trin 2. Kontroller for kollisioner mellem spilleren og bolde
Gå gennem alle spilobjekterne, og kontroller, om objekternes type er bold. Brug derefter de to objekters radier og afstandsformlen til at kontrollere, om de kolliderer. Cirkler er virkelig lette at kontrollere kollisioner på. Dette er den største grund til, at du ikke brugte en anden form til dette spil.
klasse Spiller:… def opdatering (selv, gameObjects):… til gameObj i gameObjects: hvis gameObj.type == "bold": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Trin 3. Afslut spillet, hvis spilleren får "hit"
Lad os bare afslutte spillet for nu.
hvis (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Trin 4. Prøv det
Sådan skal koden se ud nu:
import pygame fra pygame.locals import * opløsning = (400, 300) hvid = (255, 255, 255) sort = (0, 0, 0) rød = (255, 0, 0) skærm = pygame.display.set_mode (opløsning) klasse Bold: def _init _ (selv, xPos = opløsning [0] / 2, yPos = opløsning [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 = "bold" def draw (self, overflade): pygame.draw.circle (overflade, sort, (self.x, self.y), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 hvis (self.y <= 0 eller self.y> = opløsning [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, surface): pygame.draw.circle (overflade, rød, (self.x, self.y), self.radius) def opdatering (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] til gameObj i gameObjects: if gameObj.type == "bold": hvis (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () klassespil (): 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 i self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (hvid) til gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Del 7 af 8: Tilføjelse af en spilcontroller til oprettelse af objekter
Trin 1. Opret en spilcontroller klasse
Spilcontrollere er ansvarlige for at "køre" spillet. Det er forskelligt fra vores spilklasse, der er ansvarlig for at tegne og opdatere alle vores objekter. Controlleren tilføjer med jævne mellemrum en anden bold til skærmen for at gøre spillet sværere. Tilføj en konstruktør og initialiser nogle grundlæggende værdier. Intervallet er tiden før der tilføjes endnu en bold.
klasse GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "game controller"
Trin 2. Tilføj opdateringsfunktionen
Dette vil kontrollere, hvor lang tid der er gået siden det tidspunkt, hvor en bold blev tilføjet eller fra starten af spillet. Hvis tiden er mere end intervallet, nulstiller du tiden og tilføjer en bold.
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 ())
Trin 3. Giv kuglerne tilfældige hastigheder
Du skal bruge tilfældige tal for at gøre spillet anderledes hver gang. Boldens hastigheder er imidlertid nu et flydende tal i stedet for et helt tal.
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 = tilfældig ()*2, yVel = tilfældig ()*2))
Trin 4. Fix tegnefunktionen
Tegnefunktionen accepterer ikke floats. Lad os konvertere boldens position til heltal, før boldene trækkes.
klasse Bold: … def draw (selv, overflade): pygame.draw.cirkel (overflade, sort, (int (self.x), int (self.y)), self.radius)
Trin 5. Definer en uafgjort metode til spilcontrolleren
Da det er et spilobjekt, vil hovedsløjfen forsøge at tegne det. Du bliver nødt til at definere en tegnefunktion, der ikke gør noget, så spillet ikke går ned.
klasse GameController: … def draw (self, screen): pass
Trin 6. Tilføj spilcontrolleren til gameObjects, og fjern de 2 bolde
Spillet skal nu gyde en bold hvert femte sekund.
klassespil (): def _init _ (self): … self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
Trin 7. Prøv det
Sådan skal koden se ud nu:
import pygame fra tilfældig import tilfældig fra pygame.locals import * opløsning = (400, 300) hvid = (255, 255, 255) sort = (0, 0, 0) rød = (255, 0, 0) skærm = pygame. display.set_mode (opløsning) klasse Bold: def _init _ (selv, xPos = opløsning [0] / 2, yPos = opløsning [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 = "bold" def draw (self, overflade): pygame.draw.circle (overflade, sort, (int (self. x), int (self.y)), self.radius) def opdatering (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self. x> = opløsning [0]): self.dx *= -1 hvis (self.y <= 0 eller self.y> = resolution [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, surface): pygame.draw.circle (overflade, rød, (self.x), self.y), self.radius) def opdatering (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] til gameObj i spil Objekter: hvis gameObj.type == "bold": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () klasse GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "game controller "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 = tilfældig ()*2)) def draw (selv, skærm): passklasse spil (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (opløsning) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): til begivenhed i pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () for gameObj i self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (hvid) til gameObj i self.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Del 8 af 8: Tilføjelse af en score og spil over
Trin 1. Tilføj en score til spillet controller klasse
Opret et skrifttypeobjekt og en scorevariabel. Du tegner skrifttypen i hver ramme for at vise partituret og øger scoren for hver ramme i opdateringen.
klasse 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))
Trin 2. Rediger, hvordan spillet ender
Lad os slippe af med afslutningen, når spilleren opdager en kollision. I stedet vil du angive en variabel i spilleren, som spillet kan kontrollere. Når gameOver er indstillet, skal du stoppe med at opdatere objekter. Dette vil fryse alt på plads, så spilleren kan se, hvad der skete og kontrollere deres score. Bemærk, at objekterne stadig trækkes, bare ikke opdateres.
class Player: def _init _ (self, rad = 20):… self.gameOver = Falsk def update (self, gameObjects):… for gameObj i 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 = Falsk def run (self): mens True: self.handleEvents () hvis ikke self.gameOver: for gameObj i self.gameObjects: gameObj.update (self.gameObjects) hvis gameObj.type == "player": self.gameOver = gameObj.gameOver
Trin 3. Prøv det
Sådan skal den færdige kode se ud nu:
import pygame fra tilfældig import tilfældig fra pygame.locals import * opløsning = (400, 300) hvid = (255, 255, 255) sort = (0, 0, 0) rød = (255, 0, 0) skærm = pygame. display.set_mode (opløsning) klasse Bold: def _init _ (selv, xPos = opløsning [0] / 2, yPos = opløsning [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 = "bold" def draw (self, overflade): pygame.draw.circle (overflade, sort, (int (self. x), int (self.y)), self.radius) def opdatering (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self. x> = opløsning [0]): self.dx *= -1 hvis (self.y <= 0 eller self.y> = resolution [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" self.gameOver = Falsk def draw (selv, overflade): pygame.draw.cirkel (overflade, rød, (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 i gameObjects: if gameObj.type == "bold": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = TrueClass GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2*1000) self. type = "game controller" 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)) klassespil (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (opløsning) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = False def handleEvents (self): til begivenhed i pygame.event.get (): hvis ev ent.type == QUIT: pygame.quit () def run (self): mens True: self.handleEvents () hvis ikke self.gameOver: for gameObj i self.gameObjects: gameObj.update (self.gameObjects) hvis gameObj. type == "spiller": self.gameOver = gameObj.gameOver self.screen.fill (hvid) til gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () spil (). løb ()
