Dit is een inleiding tot Pygame voor mensen die Python al kennen. In dit artikel leer je de stappen om een ​​eenvoudig spel te maken waarbij de speler stuiterende ballen ontwijkt.

Deel een van de acht:
Pygame installeren

  1. 1 Pygame downloaden. Zoek het voor uw platform op http://www.pygame.org/download.shtml.
  2. 2Voer het installatieprogramma uit.
  3. 3 Controleer of de installatie werkte. Open een Python-terminal. Typ 'pygame importeren'. Als u geen fouten ziet, is Pygame met succes geïnstalleerd. 
     importeren pygame

Tweede deel van Eight:
Een basisvenster instellen

  1. 1Open een nieuw bestand.
  2. 2 Pygame importeren. Pygame is een bibliotheek die toegang biedt tot grafische functies. Als je meer informatie wilt over hoe deze functies werken, kun je ze opzoeken op de Pygame-website. https://www.pygame.org/docs/ 
     importeren pygame van pygame.lokale bevolking importeren *
  3. 3 Stel de raamresolutie in. U maakt een globale variabele voor de schermresolutie, waarnaar in verschillende delen van het spel kan worden verwezen. Het is ook gemakkelijk te vinden aan de bovenkant van het bestand, zodat het later kan worden gewijzigd. Voor geavanceerde projecten zou het een beter idee zijn om deze informatie in een apart bestand te plaatsen. 
     resolutie = (400,300)
  4. 4 Definieer enkele kleuren. De kleuren in pygame zijn (RBGA die waarden tussen 0 en 255 hebben. De alpha-waarde (A) is optioneel, maar de andere kleuren (rood, blauw en groen zijn verplicht). 
     wit = (255,255,255) zwart = (0,0,0) rood = (255,0,0)
  5. 5 Initialiseer het scherm. Gebruik de resolutievariabele die eerder is gedefinieerd. 
     scherm = pygame.tonen.set_mode(resolutie)
  6. 6 Maak een spelloop. Herhaal bepaalde acties in elk frame van onze game. Maak een lus die je altijd herhaalt om door al deze acties te fietsen. 
     terwijl waar:
  7. 7 Kleur het scherm. 
     scherm.vullen(wit)
  8. 8 Toon het scherm. Als u het programma uitvoert, wordt het scherm wit en loopt het programma vast. Dit komt omdat het besturingssysteem gebeurtenissen naar het spel verzendt en het spel niets met ze doet. Zodra de game te veel onverwerkte evenementen ontvangt, crasht deze. 
     terwijl waar:… pygame.tonen.omdraaien()
  9. 9 Omgaan met gebeurtenissen. Krijg een lijst met alle gebeurtenissen die in elk frame hebben plaatsgevonden. Je gaat alleen maar om één gebeurtenis geven, de stop gebeurtenis. Dit gebeurt wanneer de gebruiker het spelvenster sluit. Dit zal ook voorkomen dat ons programma crasht als gevolg van te veel evenementen. 
     terwijl waar:… voor evenement in pygame.evenement.krijgen(): als evenement.type == QUIT: pygame.ophouden()
  10. 10 Probeer het! Hier is hoe de code er nu uit zou moeten zien: 
     importeren pygame van pygame.lokale bevolking importeren * resolutie = (400,300) wit = (255,255,255) zwart = (0,0,0) rood = (255,0,0) scherm = pygame.tonen.set_mode(resolutie) terwijl waar: scherm.vullen(wit) pygame.tonen.omdraaien() voor evenement in pygame.evenement.krijgen(): als evenement.type == QUIT: pygame.ophouden()

Derde deel van Eight:
Een spelobject maken

  1. 1 Maak een nieuwe klasse en constructor. Stel alle eigenschappen van het object in. Je levert ook standaardwaarden voor alle eigenschappen. 
     klasse Bal: def __in het__(zelf, xpos = resolutie[0] / 2, YPOS = resolutie[1] / 2, xVel = 1, Yvel = 1, rad = 15): zelf.X = xpos zelf.Y = YPOS zelf.dx = xVel zelf.dy = Yvel zelf.radius = rad zelf.type = "bal"
  2. 2 Bepaal hoe u het object tekent. Gebruik de eigenschappen die in de constructor zijn gedefinieerd om de bal als een cirkel te tekenen en om een ​​oppervlak in de functie te laten komen om het object op te tekenen. Het oppervlak wordt het schermobject dat eerder met de resolutie is gemaakt. 
     def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, zwart, (zelf.X, zelf.Y), zelf.radius)
  3. 3 Maak een instantie van de klas en vertel de lus van het spel om de bal in elke lus te tekenen. 
     bal = Bal() terwijl waar:… bal.trek(scherm)
  4. 4 Laat het object bewegen. Maak een functie die de positie van het object zal bijwerken. Roep deze functie in elke spellus. 
     klasse Bal:… def bijwerken(zelf): zelf.X += zelf.dx zelf.Y += zelf.dy
  5. 5 Beperk de framesnelheid. De bal zal heel snel bewegen omdat de spellus honderden keren per seconde loopt. Gebruik Pygame's klok om de framesnelheid te beperken tot 60 fps. 
     klok = pygame.tijd.Klok() terwijl waar:… klok.Kruis aan(60)
  6. 6 Houd de bal op het scherm. Voeg cheques toe in de updatefunctie om de richting van de bal om te keren als deze een van de schermranden raakt. 
     klasse Bal:… def bijwerken(zelf):… als (zelf.X <= 0 of zelf.X >= resolutie[0]): zelf.dx *= -1 als (zelf.Y <= 0 of zelf.Y >= resolutie[1]): zelf.dy *= -1
  7. 7 Probeer het! Hier is hoe de code er nu uit zou moeten zien: 
     importeren pygame van pygame.lokale bevolking importeren * resolutie = (400,300) wit = (255,255,255) zwart = (0,0,0) rood = (255,0,0) scherm = pygame.tonen.set_mode(resolutie) klasse Bal: def __in het__(zelf, xpos = resolutie[0] / 2, YPOS = resolutie[1] / 2, xVel = 1, Yvel = 1, rad = 15): zelf.X = xpos zelf.Y = YPOS zelf.dx = xVel zelf.dy = Yvel zelf.radius = rad zelf.type = "bal" def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, zwart, (zelf.X, zelf.Y), zelf.radius) def bijwerken(zelf): zelf.X += zelf.dx zelf.Y += zelf.dy als (zelf.X <= 0 of zelf.X >= resolutie[0]): zelf.dx *= -1 als (zelf.Y <= 0 of zelf.Y >= resolutie[1]): zelf.dy *= -1 bal = Bal() klok = pygame.tijd.Klok() terwijl waar: scherm.vullen(wit) bal.trek(scherm) bal.bijwerken() pygame.tonen.omdraaien() klok.Kruis aan(60) voor evenement in pygame.evenement.krijgen(): als evenement.type == QUIT: pygame.ophouden()

Deel vier van de acht:
Het spel organiseren

  1. 1 Gebruik klassen om alles te organiseren. Het spel wordt ingewikkelder. Gebruik object-georiënteerde technieken om uw code te ordenen.
  2. 2 Maak van de game loop een klasse. Omdat ons spel nu gegevens bevat, inclusief je game-objecten en -functies, is het logisch om van je game-loop een klasse te maken. 
     klasse spel():
  3. 3 Voeg een constructor toe. Hier zul je een aantal game-objecten instantiëren, ons scherm en onze klok maken en Pygame initialiseren. Pygame moet worden geïnitialiseerd om bepaalde functies zoals tekst of geluid te gebruiken. 
     klasse spel(): def __in het__(zelf): pygame.in het() zelf.scherm = pygame.tonen.set_mode(resolutie) zelf.klok = pygame.tijd.Klok()
  4. 4 Bewerk gebeurtenissen in een functie. 
     klasse spel():… def handleEvents(zelf): voor evenement in pygame.evenement.krijgen(): als evenement.type == QUIT: pygame.ophouden()
  5. 5 Maak van de spellus een functie. Roep de eventafhandelingsfunctie elke keer op. 
     klasse spel():… def rennen(zelf): terwijl waar: zelf.handleEvents() zelf.scherm.vullen(wit) zelf.klok.Kruis aan(60) pygame.tonen.omdraaien()
  6. 6 Behandel meerdere game-objecten. Op dit moment moet deze code elk frame oproepen en ons object bijwerken. Dit zou rommelig worden als je veel objecten had. Laten we ons object toevoegen aan een array en vervolgens alle objecten in de array elke keer bijwerken en tekenen. Nu kunt u gemakkelijk een ander object toevoegen en het een andere startpositie geven. 
     klasse spel(): def __in het__(zelf):… zelf.gameObjects = [] zelf.gameObjects.toevoegen(Bal()) zelf.gameObjects.toevoegen(Bal(100))… def rennen(zelf): terwijl waar: zelf.handleEvents() voor gameObj in zelf.gameObjects: gameObj.bijwerken() zelf.scherm.vullen(wit) voor gameObj in zelf.gameObjects: gameObj.trek(zelf.scherm) zelf.klok.Kruis aan(60) pygame.tonen.omdraaien()
  7. 7 Probeer het! Hier is hoe de code er nu uit zou moeten zien: 
     importeren pygame van pygame.lokale bevolking importeren * resolutie = (400,300) wit = (255,255,255) zwart = (0,0,0) rood = (255,0,0) scherm = pygame.tonen.set_mode(resolutie) klasse Bal: def __in het__(zelf, xpos = resolutie[0] / 2, YPOS = resolutie[1] / 2, xVel = 1, Yvel = 1, rad = 15): zelf.X = xpos zelf.Y = YPOS zelf.dx = xVel zelf.dy = Yvel zelf.radius = rad zelf.type = "bal" def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, zwart, (zelf.X, zelf.Y), zelf.radius) def bijwerken(zelf): zelf.X += zelf.dx zelf.Y += zelf.dy als (zelf.X <= 0 of zelf.X >= resolutie[0]): zelf.dx *= -1 als (zelf.Y <= 0 of zelf.Y >= resolutie[1]): zelf.dy *= -1 klasse spel(): def __in het__(zelf): pygame.in het() zelf.scherm = pygame.tonen.set_mode(resolutie) zelf.klok = pygame.tijd.Klok() zelf.gameObjects = [] zelf.gameObjects.toevoegen(Bal()) zelf.gameObjects.toevoegen(Bal(100)) def handleEvents(zelf): voor evenement in pygame.evenement.krijgen(): als evenement.type == QUIT: pygame.ophouden() def rennen(zelf): terwijl waar: zelf.handleEvents() voor gameObj in zelf.gameObjects: gameObj.bijwerken() zelf.scherm.vullen(wit) voor gameObj in zelf.gameObjects: gameObj.trek(zelf.scherm) zelf.klok.Kruis aan(60) pygame.tonen.omdraaien() spel().rennen()

Vijfde deel van Eight:
Een speler-object toevoegen

  1. 1 Maak een spelersklasse en constructor. Je gaat een nieuwe cirkel maken die wordt bestuurd door de muis. Initialiseer de waarden in de constructor. De straal is de enige belangrijke waarde. 
     klasse Speler: def __in het__(zelf, rad = 20): zelf.X = 0 zelf.Y = 0 zelf.radius = rad
  2. 2 Definieer hoe u het spelerobject tekent. Het zal dezelfde manier zijn als waarop je de andere game-objecten tekende. 
     klasse Speler:… def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, rood, (zelf.X, zelf.Y), zelf.radius)
  3. 3 Muisbesturing toevoegen voor het spelerobject. Controleer in elk frame de locatie van de muis en stel de locatie van de objecten van de speler op dat punt in. 
     klasse Speler:… def bijwerken(zelf): koord = pygame.muis.get_pos() zelf.X = koord[0] zelf.Y = koord[1]
  4. 4 Voeg een spelerobject toe aan gameObjects. Maak een nieuwe spelerinstantie en voeg deze toe aan de lijst. 
     klasse spel(): def __in het__(zelf):… zelf.gameObjects.toevoegen(Speler())
  5. 5 Probeer het! Hier is hoe de code er nu uit zou moeten zien: 
     importeren pygame van pygame.lokale bevolking importeren * resolutie = (400,300) wit = (255,255,255) zwart = (0,0,0) rood = (255,0,0) scherm = pygame.tonen.set_mode(resolutie) klasse Bal: def __in het__(zelf, xpos = resolutie[0] / 2, YPOS = resolutie[1] / 2, xVel = 1, Yvel = 1, rad = 15): zelf.X = xpos zelf.Y = YPOS zelf.dx = xVel zelf.dy = Yvel zelf.radius = rad zelf.type = "bal" def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, zwart, (zelf.X, zelf.Y), zelf.radius) def bijwerken(zelf): zelf.X += zelf.dx zelf.Y += zelf.dy als (zelf.X <= 0 of zelf.X >= resolutie[0]): zelf.dx *= -1 als (zelf.Y <= 0 of zelf.Y >= resolutie[1]): zelf.dy *= -1 klasse Speler: def __in het__(zelf, rad = 20): zelf.X = 0 zelf.Y = 0 zelf.radius = rad zelf.type = "speler" def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, rood, (zelf.X, zelf.Y), zelf.radius) def bijwerken(zelf): koord = pygame.muis.get_pos() zelf.X = koord[0] zelf.Y = koord[1] klasse spel(): def __in het__(zelf): pygame.in het() zelf.scherm = pygame.tonen.set_mode(resolutie) zelf.klok = pygame.tijd.Klok() zelf.gameObjects = [] zelf.gameObjects.toevoegen(Speler()) zelf.gameObjects.toevoegen(Bal()) zelf.gameObjects.toevoegen(Bal(100)) def handleEvents(zelf): voor evenement in pygame.evenement.krijgen(): als evenement.type == QUIT: pygame.ophouden() def rennen(zelf): terwijl waar: zelf.handleEvents() voor gameObj in zelf.gameObjects: gameObj.bijwerken() zelf.scherm.vullen(wit) voor gameObj in zelf.gameObjects: gameObj.trek(zelf.scherm) zelf.klok.Kruis aan(60) pygame.tonen.omdraaien() spel().rennen()

Deel Zes van Acht:
Objecten maken Interactie met de speler

  1. 1 Wijzig de Update-functies. Om objecten te laten interacteren, moeten ze toegang tot elkaar hebben. Laten we nog een parameter toevoegen aan Update om de gameObjects-lijst door te geven. Je moet het toevoegen aan zowel het spelerobject als de Ball-objecten. Als je veel game-objecten hebt, kan overerving je helpen om alle methodeshandtekeningen hetzelfde te houden. 
     klasse Bal:… def bijwerken(zelf, gameObjects):… klasse Speler:… def bijwerken(zelf, gameObjects):
  2. 2 Controleer op botsingen tussen de speler en de ballen. Doorloop alle game-objecten en controleer of het type van de bal een bal is. Gebruik vervolgens de radii van de twee objecten en de afstandsformule om te controleren of ze botsen. Cirkels zijn heel eenvoudig om botsingen te controleren. Dit is de grootste reden dat je geen andere vorm hebt gebruikt voor deze game. 
     klasse Speler:… def bijwerken(zelf, gameObjects):… voor gameObj in gameObjects: als gameObj.type == "bal": als (gameObj.X - zelf.X)**2 + (gameObj.Y - zelf.Y)**2 <= (gameObj.radius + zelf.radius)**2:
  3. 3 Beëindig het spel als de speler wordt "geraakt". Laten we gewoon stoppen met het spel voor nu. 
     als (gameObj.X - zelf.X)**2 + (gameObj.Y - zelf.Y)**2 <= (gameObj.radius + zelf.radius)**2: pygame.ophouden()
  4. 4 Probeer het! Hier is hoe de code er nu zou moeten uitzien: 
     importeren pygame van pygame.lokale bevolking importeren * resolutie = (400, 300) wit = (255,255,255) zwart = (0,0,0) rood = (255,0,0) scherm = pygame.tonen.set_mode(resolutie) klasse Bal: def __in het__(zelf, xpos = resolutie[0] / 2, YPOS = resolutie[1] / 2, xVel = 1, Yvel = 1, rad = 15): zelf.X = xpos zelf.Y = YPOS zelf.dx = xVel zelf.dy = Yvel zelf.radius = rad zelf.type = "bal" def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, zwart, (zelf.X, zelf.Y), zelf.radius) def bijwerken(zelf, gameObjects): zelf.X += zelf.dx zelf.Y += zelf.dy als (zelf.X <= 0 of zelf.X >= resolutie[0]): zelf.dx *= -1 als (zelf.Y <= 0 of zelf.Y >= resolutie[1]): zelf.dy *= -1 klasse Speler: def __in het__(zelf, rad = 20): zelf.X = 0 zelf.Y = 0 zelf.radius = rad zelf.type = "speler" def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, rood, (zelf.X, zelf.Y), zelf.radius) def bijwerken(zelf, gameObjects): koord = pygame.muis.get_pos() zelf.X = koord[0] zelf.Y = koord[1] voor gameObj in gameObjects: als gameObj.type == "bal": als (gameObj.X - zelf.X)**2 + (gameObj.Y - zelf.Y)**2 <= (gameObj.radius + zelf.radius)**2: pygame.ophouden() klasse spel(): def __in het__(zelf): pygame.in het() zelf.scherm = pygame.tonen.set_mode(resolutie) zelf.klok = pygame.tijd.Klok() zelf.gameObjects = [] zelf.gameObjects.toevoegen(Speler()) zelf.gameObjects.toevoegen(Bal()) zelf.gameObjects.toevoegen(Bal(100)) def handleEvents(zelf): voor evenement in pygame.evenement.krijgen(): als evenement.type == QUIT: pygame.ophouden() def rennen(zelf): terwijl waar: zelf.handleEvents() voor gameObj in zelf.gameObjects: gameObj.bijwerken(zelf.gameObjects) zelf.scherm.vullen(wit) voor gameObj in zelf.gameObjects: gameObj.trek(zelf.scherm) zelf.klok.Kruis aan(60) pygame.tonen.omdraaien() spel().rennen()

Deel Zeven van Acht:
Een gamecontroller toevoegen om objecten te maken

  1. 1 Creëer een klasse voor gamecontrollers. Spelbesturingen zijn verantwoordelijk voor het "uitvoeren" van het spel. Het is anders dan onze gameklasse die verantwoordelijk is voor het tekenen en updaten van al onze objecten. De controller voegt periodiek een nieuwe bal toe aan het scherm om het spel moeilijker te maken. Voeg een constructor toe en initialiseer enkele basiswaarden. Het interval is de tijd voordat een nieuwe bal wordt toegevoegd. 
     klasse gamecontroller: def __in het__(zelf, interval = 5): zelf.onder = interval zelf.volgende = pygame.tijd.get_ticks() + (2 * 1000) zelf.type = "game controller"
  2. 2 Voeg de update-functie toe. Hiermee wordt gecontroleerd hoeveel tijd is verstreken sinds het moment waarop een bal is toegevoegd of vanaf het begin van het spel. Als de tijd meer is dan het interval, stelt u de tijd opnieuw in en voegt u een bal toe. 
     klasse Gamecontroller: ... def bijwerken(zelf, gameObjects): als zelf.volgende < pygame.tijd.get_ticks(): zelf.volgende = pygame.tijd.get_ticks() + (zelf.onder * 1000) gameObjects.toevoegen(Bal())
  3. 3 Geef de ballen willekeurige snelheden. Je moet willekeurige getallen gebruiken om de game elke keer anders te maken. De snelheden van de ballen zijn nu echter een getal met een drijvend aantal in plaats van een geheel getal. 
     klasse Gamecontroller: ... def bijwerken(zelf, gameObjects): als zelf.volgende < pygame.tijd.get_ticks(): zelf.volgende = pygame.tijd.get_ticks() + (zelf.onder * 1000) gameObjects.toevoegen(Bal(xVel=willekeurig()*2, Yvel=willekeurig()*2))
  4. 4 Bevestig de draw-functie. De trekkrachtfunctie accepteert geen drijvers. Laten we de positie van de bal omzetten in gehele getallen voordat de ballen worden getrokken. 
     klasse Bal:… def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, zwart, (int(zelf.X), int(zelf.Y)), zelf.radius)
  5. 5 Definieer een tekenmethode voor de spelbesturing. Omdat het een spelobject is, probeert de hoofdlus het te tekenen. Je moet een draw-functie definiëren die niets doet, zodat de game niet crasht. 
     klasse Gamecontroller: ... def trek(zelf, scherm): slagen voor
  6. 6 Voeg de gamecontroller toe aan gameObjects en verwijder de 2 ballen. Het spel zou nu om de vijf seconden een bal moeten maken. 
     klasse spel(): def __in het__(zelf):… zelf.gameObjects = [] zelf.gameObjects.toevoegen(gamecontroller()) zelf.gameObjects.toevoegen(Speler())
  7. 7 Probeer het! Hier is hoe de code er nu uit zou moeten zien: 
     importeren pygame van willekeurig importeren willekeurig van pygame.lokale bevolking importeren * resolutie = (400,300) wit = (255,255,255) zwart = (0,0,0) rood = (255,0,0) scherm = pygame.tonen.set_mode(resolutie) klasse Bal: def __in het__(zelf, xpos = resolutie[0] / 2, YPOS = resolutie[1] / 2, xVel = 1, Yvel = 1, rad = 15): zelf.X = xpos zelf.Y = YPOS zelf.dx = xVel zelf.dy = Yvel zelf.radius = rad zelf.type = "bal" def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, zwart, (int(zelf.X), int(zelf.Y)), zelf.radius) def bijwerken(zelf, gameObjects): zelf.X += zelf.dx zelf.Y += zelf.dy als (zelf.X <= 0 of zelf.X >= resolutie[0]): zelf.dx *= -1 als (zelf.Y <= 0 of zelf.Y >= resolutie[1]): zelf.dy *= -1 klasse Speler: def __in het__(zelf, rad = 20): zelf.X = 0 zelf.Y = 0 zelf.radius = rad zelf.type = "speler" def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, rood, (zelf.X, zelf.Y), zelf.radius) def bijwerken(zelf, gameObjects): koord = pygame.muis.get_pos() zelf.X = koord[0] zelf.Y = koord[1] voor gameObj in gameObjects: als gameObj.type == "bal": als (gameObj.X - zelf.X)**2 + (gameObj.Y - zelf.Y)**2 <= (gameObj.radius + zelf.radius)**2: pygame.ophouden() klasse gamecontroller: def __in het__(zelf, interval = 5): zelf.onder = interval zelf.volgende = pygame.tijd.get_ticks() + (2 * 1000) zelf.type = "game controller" def bijwerken(zelf, gameObjects): als zelf.volgende < pygame.tijd.get_ticks(): zelf.volgende = pygame.tijd.get_ticks() + (zelf.onder * 1000) gameObjects.toevoegen(Bal(xVel=willekeurig()*2, Yvel=willekeurig()*2)) def trek(zelf, scherm): slagen voor klasse spel(): def __in het__(zelf): pygame.in het() zelf.scherm = pygame.tonen.set_mode(resolutie) zelf.klok = pygame.tijd.Klok() zelf.gameObjects = [] zelf.gameObjects.toevoegen(gamecontroller()) zelf.gameObjects.toevoegen(Speler()) def handleEvents(zelf): voor evenement in pygame.evenement.krijgen(): als evenement.type == QUIT: pygame.ophouden() def rennen(zelf): terwijl waar: zelf.handleEvents() voor gameObj in zelf.gameObjects: gameObj.bijwerken(zelf.gameObjects) zelf.scherm.vullen(wit) voor gameObj in zelf.gameObjects: gameObj.trek(zelf.scherm) zelf.klok.Kruis aan(60) pygame.tonen.omdraaien() spel().rennen()

Deel Acht van Acht:
Een score en spel toevoegen

  1. 1 Voeg een score toe aan de klasse van de spelcontroller. Maak een font-object en een scorevariabele. Je tekent het lettertype in elk frame om de score weer te geven en de score elk frame in update te verhogen. 
     klasse gamecontroller: def __in het__(zelf, interval = 5):… zelf.partituur = 0 zelf.scoreText = pygame.doopvont.doopvont(Geen, 12) def bijwerken(zelf, gameObjects):… zelf.partituur += 1 def trek(zelf, scherm): scherm.BLIT(zelf.scoreText.geven(str(zelf.partituur), waar, zwart), (5,5))
  2. 2 Wijzig hoe het spel eindigt. Laten we van de stop af wanneer de speler een botsing detecteert. In plaats daarvan stel je een variabele in op de speler die het spel kan controleren. Wanneer gameOver is ingesteld, stopt u met het bijwerken van objecten. Hierdoor wordt alles op zijn plaats bevroren, zodat de speler kan zien wat er is gebeurd en hun score kan controleren. Merk op dat de objecten nog steeds worden getekend, gewoon niet bijgewerkt. 
     klasse Speler: def __in het__(zelf, rad = 20):… zelf.spel is over = vals def bijwerken(zelf, gameObjects):… voor gameObj in gameObjects: als gameObj.type == "bal": als (gameObj.X - zelf.X)**2 + (gameObj.Y - zelf.Y)**2 <= (gameObj.radius + zelf.radius)**2: zelf.spel is over = waar klasse spel(): def __in het__(zelf):… zelf.spel is over = vals def rennen(zelf): terwijl waar: zelf.handleEvents() als niet zelf.spel is over: voor gameObj in zelf.gameObjects: gameObj.bijwerken(zelf.gameObjects) als gameObj.type == "speler": zelf.spel is over = gameObj.spel is over
  3. 3 Probeer het! Hier is hoe de voltooide code er nu uit zou moeten zien: 
     importeren pygame van willekeurig importeren willekeurig van pygame.lokale bevolking importeren * resolutie = (400,300) wit = (255,255,255) zwart = (0,0,0) rood = (255,0,0) scherm = pygame.tonen.set_mode(resolutie) klasse Bal: def __in het__(zelf, xpos = resolutie[0] / 2, YPOS = resolutie[1] / 2, xVel = 1, Yvel = 1, rad = 15): zelf.X = xpos zelf.Y = YPOS zelf.dx = xVel zelf.dy = Yvel zelf.radius = rad zelf.type = "bal" def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, zwart, (int(zelf.X), int(zelf.Y)), zelf.radius) def bijwerken(zelf, gameObjects): zelf.X += zelf.dx zelf.Y += zelf.dy als (zelf.X <= 0 of zelf.X >= resolutie[0]): zelf.dx *= -1 als (zelf.Y <= 0 of zelf.Y >= resolutie[1]): zelf.dy *= -1 klasse Speler: def __in het__(zelf, rad = 20): zelf.X = 0 zelf.Y = 0 zelf.radius = rad zelf.type = "speler" zelf.spel is over = vals def trek(zelf, oppervlakte): pygame.trek.cirkel(oppervlakte, rood, (zelf.X, zelf.Y), zelf.radius) def bijwerken(zelf, gameObjects): koord = pygame.muis.get_pos() zelf.X = koord[0] zelf.Y = koord[1] voor gameObj in gameObjects: als gameObj.type == "bal": als (gameObj.X - zelf.X)**2 + (gameObj.Y - zelf.Y)**2 <= (gameObj.radius + zelf.radius)**2: zelf.spel is over = waar klasse gamecontroller: def __in het__(zelf, interval = 5): zelf.onder = interval zelf.volgende = pygame.tijd.get_ticks() + (2 * 1000) zelf.type = "game controller" zelf.partituur = 0 zelf.scoreText = pygame.doopvont.doopvont(Geen, 12) def bijwerken(zelf, gameObjects): als zelf.volgende < pygame.tijd.get_ticks(): zelf.volgende = pygame.tijd.get_ticks() + (zelf.onder * 1000) gameObjects.toevoegen(Bal(xVel=willekeurig()*2, Yvel=willekeurig()*2)) zelf.partituur += 1 def trek(zelf, scherm): scherm.BLIT(zelf.scoreText.geven(str(zelf.partituur), waar, zwart), (5,5)) klasse spel(): def __in het__(zelf): pygame.in het() zelf.scherm = pygame.tonen.set_mode(resolutie) zelf.klok = pygame.tijd.Klok() zelf.gameObjects = [] zelf.gameObjects.toevoegen(gamecontroller()) zelf.gameObjects.toevoegen(Speler()) zelf.spel is over = vals def handleEvents(zelf): voor evenement in pygame.evenement.krijgen(): als evenement.type == QUIT: pygame.ophouden() def rennen(zelf): terwijl waar: zelf.handleEvents() als niet zelf.spel is over: voor gameObj in zelf.gameObjects: gameObj.bijwerken(zelf.gameObjects) als gameObj.type == "speler": zelf.spel is over = gameObj.spel is over zelf.scherm.vullen(wit) voor gameObj in zelf.gameObjects: gameObj.trek(zelf.scherm) zelf.klok.Kruis aan(60) pygame.tonen.omdraaien() spel().rennen()