Hoe games op python te programmeren met behulp van de pygame-bibliotheek

Dit artikel is bedoeld voor degenen die al bekend zijn met de Python-programmeertaal en stelt u in staat om de Pygame-bibliotheek voor deze taal te lezen. Als visueel voorbeeld wordt hier een eenvoudig spelprogrammeerproces getoond, waarin de speler moet doneren aan springballen.

Stappen

Deel 1 van 8:
Pygame installeren
een. Download Pygame. Volg de link en zoek de bibliotheekversie die geschikt is voor uw platform: http: // Pygame.Org / download.shtml .
  • 2. Voer het installatieprogramma uit.
  • 3. Zorg ervoor dat de installatie met succes is voltooid. Open de Python-terminal. Voer "Import Pygame". Als foutmeldingen niet verschijnen, is Pygame met succes geïnstalleerd.
    Import pygame
    • Deel 2 van 8:
    Een hoofdspel maken
    een. Maak een nieuw bestand.
  • 2. Import pygame. Pygame is een bibliotheek die de toegang tot Python-programmeertaal grafische functies implementeert. Als u meer wilt weten over hoe deze functies werken, is de informatie beschikbaar op Pygame. HTTPS: // Pygame.Org / docs /
    Importeer Pygamefrom Pygame.Locals Import *
  • 3. Geef de grootte van het game-venster op. Maak een globale variabele voor venstermaten om naar te verwijzen vanuit verschillende delen van het spel. Voor het gemak zijn deze parameters beter om aan het begin van het bestand op te geven, zodat het indien nodig in de toekomst gemakkelijker was. Voor meer complexe projecten verdient het de voorkeur om dergelijke gegevens in een apart bestand te doen.
    Resolutie = (400.300)
  • 4. Bepaal verschillende kleuren. Kleuren in Pygame zijn gedefinieerd in het RGBA-formaat, variërend van 0 tot 255. De waarde van alfa (A) kan worden weggelaten, maar de rest van de kleuren (rood, groen en blauw) zijn vereist voor het vullen.
    Wit = (255,255,255) zwart = (0.0.0) rood = (255.0.0)
  • vijf. Initialiseer het hoofdscherm. Gebruik de eerder gedefinieerde resolutie-variabele.
    Scherm = pygame.Weergave.Set_Mode (resolutie)
  • 6. Maak een cyclus van het spel. Stel de herhaling van bepaalde acties in elk frame van het spel in. Maak een cyclus die consequent al deze acties zal uitvoeren.
    Terwijl TRUE:
  • 7. Bepaal de kleur van het schermvulling.
    Scherm.Vullen (wit)
  • acht. Geef het scherm weer. Als u het programma in deze fase start, wordt het scherm met wit geschilderd en dan stopt het programma de noodsituatie. De oorzaak van het mislukken is dat het besturingssysteem de gebeurtenissen van het programma verzendt en het programma gaat gewoon niet door. Wanneer het programma te veel onbehandelde gebeurtenissen accumuleert, ontstaat het falen.
    Terwijl TRUE:...Pygame.Weergave.Omdraaien ()
  • negen. Implementeer de verwerking van gebeurtenissen. Krijg een lijst met alle evenementen die ontstonden tussen tekenrijtuigen. In ons voorbeeld moet u zich zorgen maken over de verwerking van slechts één uitvoerevenement (stop). Het komt voor wanneer de gebruiker het game-venster sluit. Evenementverwerking zal het programma mislukken van het uiterlijk van te veel evenementen.
    Terwijl TRUE:...Voor evenement in Pygame.Evenement.Krijg (): als evenement.Type == Quit: Pygame.ontslag nemen ()
  • Titel afbeelding PrimampyGamePart1.jpg
    10. Probeer het programma! Nu moet de programmacode er als volgt uitzien:
    Importeer Pygamefrom Pygame.Locals Import * Resolutie = (400.300) wit = (255,255,255) zwart = (0.0.0) rood = (255,0,0) scherm = pygame.Weergave.Set_Mode (resolutie) terwijl TRUE: scherm.Vul (wit) pygame.Weergave.Flip () voor evenement in Pygame.Evenement.Krijg (): als evenement.Type == Quit: Pygame.ontslag nemen ()
    • Deel 3 van 8:
    Game-objecten maken
    een. Maak een nieuwe klasse van objecten en zijn ontwerper. Stel alle eigenschappen van het object in. Definieer ook standaardwaarden voor elk van de eigenschappen.
    KLASSE BAL: DEF __Init __ (Self, XPOS = RESOLUTIE [0] / 2, YPOS = Resolutie [1] / 2, Xvel = 1, Yvel = 1, Rad = 15): Zelf.x = xpossensel.Y = YPosselzelf.DX = Xvelself.dy = yvelself.RADIUS = RADSELF.Type = "Bal"
  • 2. Bepaal de tekening van het object. Gebruik de objecteigenschappen die in de constructor zijn gespecificeerd om de bal te portretteren als een cirkel op het oppervlak dat is verzonden naar de functie naar de functie. Het oppervlak is het scherm dat u eerder hebt gemaakt door de dimensies te definiëren.
    Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, zwart, (zelf.X, zelf.y), zelf.STRAAL)
  • 3. Maak een klasse-instantie en voeg een taak toe aan de game-cyclus om een ​​bal te tekenen bij elke iteratie van de cyclus.
    Bal = bal () terwijl TRUE:...Bal.Teken (scherm)
  • 4. Maak het objectbeweging. Maak een functie die de positie van het object bijwerkt. Bel deze functie in elke iteratie van de cyclus.
    Klasse bal:...Def update (zelf): zelf.X + = zelf.DXSELF.Y + = zelf.Dy
  • vijf. Limiet frequentie. De bal zal heel snel bewegen, omdat de gamecyclus honderden keren per seconde wordt herhaald. Gebruik de PYGAME-timer om het frame van het frame te beperken tot 60 fps.
      • Klok = pygame.Tijd.Klok () terwijl TRUE:...KLOK.TICK (60)
  • Houd een kom op het scherm. Voeg controles toe aan de functie Status Update om de bewegingsrichting van de bal te wijzigen, als het de schermgrenzen bereikt.
      Klasse bal:...DEF UPDATE (ZELF):...Als (zelf.X <= 0 or self.x >= RESOLUTIE [0]): ZELF.DX * = -1IF (Zelf.Y <= 0 or self.y >= RESOLUTIE [1]): ZELF.dy * = -1
  • Probeer het programma! Nu moet de programmacode er als volgt uitzien:
    Titel afbeelding PrimampygamePart2.jpg
      Importeer Pygamefrom Pygame.Locals Import * Resolutie = (400.300) wit = (255,255,255) zwart = (0.0.0) rood = (255,0,0) scherm = pygame.Weergave.SET_MODE (RESOLUTION) KLASSE BAL: DEF __INIT __ (ZELF, XPOS = RESOLUTIE [0] / 2, YPOS = Resolutie [1] / 2, Xvel = 1, Yvel = 1, Rad = 15): Zelf.x = xpossensel.Y = YPosselzelf.DX = Xvelself.dy = yvelself.RADIUS = RADSELF.Type = "Bal"Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, zwart, (zelf.X, zelf.y), zelf.RADIUS) DEF UPDATE: ZELF.X + = zelf.DXSELF.Y + = zelf.Dyif (Self.X <= 0 or self.x >= RESOLUTIE [0]): ZELF.DX * = -1IF (Zelf.Y <= 0 or self.y >= RESOLUTIE [1]): ZELF.dy * = -1ball = bal () klok = pygame.Tijd.Klok () terwijl TRUE: scherm.Vul (witte) bal.Teken (scherm) bal.Update () pygame.Weergave.Flip () klok.Vink (60) voor evenement in Pygame.Evenement.Krijg (): als evenement.Type == Quit: Pygame.ontslag nemen ()
    • Deel 4 van 8:
    Structureren games
    een. Gebruik klassen voor het structureren. In de toekomst zal het spel complexer worden. Gebruik objectgeoriënteerde programmeertechnieken voor het structureren van code.
  • 2. Converteer de game-cyclus naar de klas. Sinds op het moment dat het spel al gegevens bevat, inclusief game-objecten en -functies, is het logisch om de gamecyclus naar de klas te vervangen.
    Klasse game ():
  • 3. Voeg de ontwerper toe. Hiermee weigert u verschillende objecten die in het spel worden gebruikt, een scherm, timer maken en Pygame initialiseren. Pygame moet worden geïnitialiseerd om dergelijke mogelijkheden als tekst of geluid verder te gebruiken.
    Class Game (): Def __init __ (zelf): Pygame.Init () zelf.Scherm = pygame.Weergave.Set_mode (resolutie) zelf.Klok = pygame.Tijd.Klok ()
  • 4. Stel de verwerking van gebeurtenissen in de functie in.
    Klasse game ():...Def handvatten (zelf): voor evenement in Pygame.Evenement.Krijg (): als evenement.Type == Quit: Pygame.ontslag nemen ()
  • vijf. Maak een game-cyclus met een functie. Call-evenementbewerkingsfunctie in elke iteratie van de cyclus.
    Klasse game ():...Def Run (Self): Terwijl TRUE: ZELF.Handvat () zelf.Scherm.Vul (wit) zelf.KLOK.TICK (60) PYGAME.Weergave.Omdraaien ()
  • 6. Stel de verwerking van meerdere game-objecten in. In dit stadium veroorzaakt de gamecode een update en het opnieuw rekken van individuele objecten in elk frame. Met deze aanpak zal de spelcode vrij omvangrijk en ongeordend zijn, vooral als er veel objecten in het spel zijn. Het is wiser om voor het eerst objecten toe te voegen aan een array en vervolgens bijwerken en opnieuw bijwerken van alle objecten in de array bij elke iteratie van de cyclus. Nu kunt u eenvoudig een nieuw object in het spel maken en er een andere startpositie voor bepalen.
    Klasse game (): Def __init __ (zelf):...Zelf.Gamobjects = [] zelf.Gamobjects.APPEND (BAL ()) ZELF.Gamobjects.Toevoegen (bal (100))...Def Run (Self): Terwijl TRUE: ZELF.Omhendelingen () voor Gameobj in Self.GameObjects: Gameobj.Update () zelf.Scherm.Vullen (wit) voor gameobj in zichzelf.GameObjects: Gameobj.Tekenen (zelf.Scherm) zelf.KLOK.TICK (60) PYGAME.Weergave.Omdraaien ()
  • Titel afbeelding PrimampygamePart3.jpg
    7. Probeer het programma! Nu moet de programmacode er als volgt uitzien:
    Importeer Pygamefrom Pygame.Locals Import * Resolutie = (400.300) wit = (255,255,255) zwart = (0.0.0) rood = (255,0,0) scherm = pygame.Weergave.SET_MODE (RESOLUTION) KLASSE BAL: DEF __INIT __ (ZELF, XPOS = RESOLUTIE [0] / 2, YPOS = Resolutie [1] / 2, Xvel = 1, Yvel = 1, Rad = 15): Zelf.x = xpossensel.Y = YPosselzelf.DX = Xvelself.dy = yvelself.RADIUS = RADSELF.Type = "Bal"Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, zwart, (zelf.X, zelf.y), zelf.RADIUS) DEF UPDATE: ZELF.X + = zelf.DXSELF.Y + = zelf.Dyif (Self.X <= 0 or self.x >= RESOLUTIE [0]): ZELF.DX * = -1IF (Zelf.Y <= 0 or self.y >= RESOLUTIE [1]): ZELF.dy * = -1class game (): Def __init __ (self): pygame.Init () zelf.Scherm = pygame.Weergave.Set_mode (resolutie) zelf.Klok = pygame.Tijd.Klok () zelf.Gamobjects = [] zelf.Gamobjects.APPEND (BAL ()) ZELF.Gamobjects.APPEND (BAL (100)) DEF TENHANDVENTEN (ZELF): VOOR EVENEMENT IN PYGAME.Evenement.Krijg (): als evenement.Type == Quit: Pygame.Stop () Def Run (Self): Terwijl TRUE: ZELF.Omhendelingen () voor Gameobj in Self.GameObjects: Gameobj.Update () zelf.Scherm.Vullen (wit) voor gameobj in zichzelf.GameObjects: Gameobj.Tekenen (zelf.Scherm) zelf.KLOK.TICK (60) PYGAME.Weergave.Flip () Game ().LOOP ()
    • Deel 5 van 8:
    Het toevoegen van een "speler" -object
    een. Maak een spelersklasse en zijn ontwerper. U moet een andere cirkel maken die wordt gecontroleerd door de beweging van de muis. Initialiseer de parameters in de ontwerper. De enige belangrijke waarde zal de straal zijn.
    Class Player: Def __init __ (Zelf, Rad = 20): Zelf.x = are.Y = are jezelf.RADIUS = RAD
  • 2. Bepaal de tekening van het object van de speler. Het wordt op dezelfde manier getekend met hoe andere game-objecten werden getrokken.
    Klasse speler:...Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, rood, (zelf.X, zelf.y), zelf.STRAAL)
  • 3. Voeg muisbesturing toe voor spelerobject. In elk frame van het spel moet u de positie van de muisaanwijzer controleren en de positie van het object van de speler met dit punt relateren.
    Klasse speler:...Def update (zelf): snoer = pygame.Muis.GET_POS () ZELF.X = snoer [0] zelf.Y = snoer [1]
  • 4. Voeg het spelerobject toe aan de gamobjects-array. Maak een nieuw exemplaar van het object en voeg deze toe aan de GameObjects-lijst.
    Klasse game (): Def __init __ (zelf):...Zelf.Gamobjects.Appd (Player ())
  • Titel afbeelding ProgrammampygamePart4.jpg
    vijf. Probeer het programma! Nu moet de programmacode er als volgt uitzien:
    Importeer Pygamefrom Pygame.Locals Import * Resolutie = (400.300) wit = (255,255,255) zwart = (0.0.0) rood = (255,0,0) scherm = pygame.Weergave.SET_MODE (RESOLUTION) KLASSE BAL: DEF __INIT __ (ZELF, XPOS = RESOLUTIE [0] / 2, YPOS = Resolutie [1] / 2, Xvel = 1, Yvel = 1, Rad = 15): Zelf.x = xpossensel.Y = YPosselzelf.DX = Xvelself.dy = yvelself.RADIUS = RADSELF.Type = "Bal"Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, zwart, (zelf.X, zelf.y), zelf.RADIUS) DEF UPDATE: ZELF.X + = zelf.DXSELF.Y + = zelf.Dyif (Self.X <= 0 or self.x >= RESOLUTIE [0]): ZELF.DX * = -1IF (Zelf.Y <= 0 or self.y >= RESOLUTIE [1]): ZELF.DY * = -1Class Player: Def __init __ (Zelf, Rad = 20): Zelf.x = are.Y = are jezelf.RADIUS = RADSELF.Type = "Speler"Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, rood, (zelf.X, zelf.y), zelf.Radius) Def update (zelf): snoer = pygame.Muis.GET_POS () ZELF.X = snoer [0] zelf.Y = snoer [1] Klasse game (): Def __init __ (zelf): Pygame.Init () zelf.Scherm = pygame.Weergave.Set_mode (resolutie) zelf.Klok = pygame.Tijd.Klok () zelf.Gamobjects = [] zelf.Gamobjects.Appd (speler ()) zelf.Gamobjects.APPEND (BAL ()) ZELF.Gamobjects.APPEND (BAL (100)) DEF TENHANDVENTEN (ZELF): VOOR EVENEMENT IN PYGAME.Evenement.Krijg (): als evenement.Type == Quit: Pygame.Stop () Def Run (Self): Terwijl TRUE: ZELF.Omhendelingen () voor Gameobj in Self.GameObjects: Gameobj.Update () zelf.Scherm.Vullen (wit) voor gameobj in zichzelf.GameObjects: Gameobj.Tekenen (zelf.Scherm) zelf.KLOK.TICK (60) PYGAME.Weergave.Flip () Game ().LOOP ()
    • Deel 6 van 8:
    Objectinteractie maken
    een. Wijzig positie-update-functies. Om de interactie van objecten te implementeren, is het noodzakelijk om ze toegang te geven tot elkaar eigenschappen. Voeg een nieuwe parameter toe aan de updatefunctie om de GameObjects-lijstgegevens over te dragen. De parameter moet worden toegevoegd aan de spelersklassen en balfuncties. Als u veel klassen heeft, helpt de erfenis de lijst met parameters die hetzelfde opslaan.
    Klasse bal:...Def update (zelf, gamobjecten):...Klasse speler:...Def update (zelf, gamobjecten):
  • 2. Voer spelersbotsingcontroles in met ballen. Bekijk alle objecten en definieer ze onder hen die betrekking hebben op de ballen. Controleer vervolgens de radii van objecten en de formule voor het bepalen van de afstand, of objecten met elkaar botsten. Controleer botsingen tussen cirkels is eenvoudig. Dit is de belangrijkste reden dat als een voorbeeld in dit spel de figuren van een andere vorm niet worden gebruikt.
    Klasse speler:...Def update (zelf, gamobjecten):...Voor Gameobj in GameObjects: If Gameobj.Type == "Bal": if (gameobj.X - zelf.x) ** 2 + (Gameobj.Y - zelf.y) ** 2 <= (gameObj.radius + self.radius)**2:
  • Titel afbeelding ProgrammampygamePart5.jpg
    3. Stel het einde van het spel in wanneer een speler botsing met een bal. Stel in dit stadium gewoon de uitweg uit het spel.
    If (gameobj.X - zelf.x) ** 2 + (Gameobj.Y - zelf.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()
  • 4. Probeer het programma! Nu moet de programmacode er als volgt uitzien:
    Importeer Pygamefrom Pygame.Locals Import * Resolutie = (400, 300) wit = (255,255,255) zwart = (0,0,0) rood = (255,0,0,0) scherm = Pygame.Weergave.SET_MODE (RESOLUTION) KLASSE BAL: DEF __INIT __ (ZELF, XPOS = RESOLUTIE [0] / 2, YPOS = Resolutie [1] / 2, Xvel = 1, Yvel = 1, Rad = 15): Zelf.x = xpossensel.Y = YPosselzelf.DX = Xvelself.dy = yvelself.RADIUS = RADSELF.Type = "Bal"Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, zwart, (zelf.X, zelf.y), zelf.Straal) Def update (zelf, gamobjecten): zelf.X + = zelf.DXSELF.Y + = zelf.Dyif (Self.X <= 0 or self.x >= RESOLUTIE [0]): ZELF.DX * = -1IF (Zelf.Y <= 0 or self.y >= RESOLUTIE [1]): ZELF.DY * = -1CLASS PLAYER: DEF __INIT __ (ZELF, RAD = 20): ZELF.x = are.Y = are jezelf.RADIUS = RADSELF.Type = "Speler"Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, rood, (zelf.X, zelf.y), zelf.Straal) Def update (zelf, gamobjecten): snoer = pygame.Muis.GET_POS () ZELF.X = snoer [0] zelf.Y = snoer [1] voor gameobj in gameobjects: als gameobj.Type == "Bal": if (gameobj.X - zelf.x) ** 2 + (Gameobj.Y - zelf.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()
    • Deel 7 van 8:
    Een gamingcontroller toevoegen om objecten te maken
    een. Maak een gamingcontroller klasse. Spelcontrollers zijn verantwoordelijk voor de loop van het spel. Ze vallen niet samen met de klasse van het spel zelf, wat verantwoordelijk is voor het tekenen en bijwerken van alle game-objecten. De controller zal periodiek een nieuwe bal op het scherm toevoegen en het spel compliceren. Voeg de ontwerper toe en initialiseer enkele startwaarden. Het interval betekent de tijd waardoor een nieuwe bal wordt toegevoegd.
    Class GameController: Def __init __ (Zelf, Interval = 5): Zelf.Inter = intervallen.Volgende = Pygame.Tijd.get_ticks () + (2 * 1000) zelf.Type = "Gamecontroller"
  • 2. Voeg de updatefunctie toe. Het zal controleren hoeveel tijd is verstreken sinds het toevoegen van de vorige bal of vanaf het begin van het spel. Als de tijd het opgegeven interval overschrijdt, wordt de timer gereset en is de nieuwe bal toegevoegd.
    Klasse GameController:...Def update (zelf, gamobjects): als zelf.Volgende < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball())
  • 3. Installeer willekeurige snelheden voor ballen. Om het spel anders te laten gedragen, is het noodzakelijk om het toe te staan ​​willekeurige nummers te gebruiken voor snelheidsparameter. Nu wordt de snelheid van de ballen bepaald door een drijvend decimaal getal, geen geheel getal.
    Klasse GameController:...Def update (zelf, gamobjects): als zelf.Volgende < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball(xVel=random()*2, yVel=random()*2))
  • 4. Corrigeer de functie van de tekening. Draw-functie werkt niet met drijvende puntkomma`s (float). Daarom is het noodzakelijk om de positie van de bal in de gehele getallen uit te drukken voordat het werkt.
    Klasse bal:...Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, zwart, (int (zelf.x), int (zelf.y)), zelf.STRAAL)
  • vijf. Bepaal de methode van tekenen voor de game-controller. Omdat dit ook een spelobject is, zal er in de hoofdgamecyclus een poging zijn om het te tekenen. Daarom is het voor de controller nodig om de functie van tekening te bepalen, wat niets doet om het spelfalen te vermijden.
    Klasse GameController:...Def Draw (Self, Screen): Pass
  • 6. Voeg een gamecontroller toe in GameObjects en verwijder 2 ballen. Het spel moet elke 5 seconden een nieuwe bal toevoegen.
    Klasse game (): Def __init __ (zelf):...Zelf.Gamobjects = [] zelf.Gamobjects.Appendroller (GameController ()).Gamobjects.Appd (Player ())
  • Titel afbeelding ProgrammampygamePart6.jpg
    7. Probeer het programma! Nu moet de programmacode er als volgt uitzien:
    Importeer Pygamefrom willekeurige importeren willekeurrijke pygame.Locals Import * Resolutie = (400.300) wit = (255,255,255) zwart = (0.0.0) rood = (255,0,0) scherm = pygame.Weergave.SET_MODE (RESOLUTION) KLASSE BAL: DEF __INIT __ (ZELF, XPOS = RESOLUTIE [0] / 2, YPOS = Resolutie [1] / 2, Xvel = 1, Yvel = 1, Rad = 15): Zelf.x = xpossensel.Y = YPosselzelf.DX = Xvelself.dy = yvelself.RADIUS = RADSELF.Type = "Bal"Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, zwart, (int (zelf.x), int (zelf.y)), zelf.Straal) Def update (zelf, gamobjects): zelf.X + = zelf.DXSELF.Y + = zelf.Dyif (Self.X <= 0 or self.x >= RESOLUTIE [0]): ZELF.DX * = -1IF (Zelf.Y <= 0 or self.y >= RESOLUTIE [1]): ZELF.DY * = -1Class Player: Def __init __ (Zelf, Rad = 20): Zelf.x = are.Y = are jezelf.RADIUS = RADSELF.Type = "Speler"Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, rood, (zelf.X, zelf.y), zelf.Straal) Def update (zelf, gamobjecten): snoer = pygame.Muis.GET_POS () ZELF.X = snoer [0] zelf.Y = snoer [1] voor gameobj in gameobjects: als gameobj.Type == "Bal": if (gameobj.X - zelf.x) ** 2 + (Gameobj.Y - zelf.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()class GameController:def __init__(self, interval = 5):self.inter = intervalself.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=random()*2))def draw(self, screen):passclass 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(white)for gameObj in self.gameObjects:gameObj.draw(self.screen)self.clock.tick(60)pygame.display.flip()game().run()
    • Deel 8 van 8:
    Een account toevoegen en voltooien van het spel
    een. Voeg een account toe aan de klasse Gaming Controller. Maak een lettertype-klassenobject en scoreer variabele. Het lettertype-object moet in elk frame worden getekend om het huidige account weer te geven en verhoogt deze in elk frame bij het bijwerken.
    Klasse GameController: Def __init __ (Zelf, Interval = 5):...Zelf.Score = are.Scoretext = Pygame.doopvont.Lettertype (geen, 12) Def Update (Self, GameObjects):...Zelf.Score + = 1DEF Tekenen (Zelf, Scherm): scherm.Blit (zelf.Scoretext.Render (str (zelf.Score), True, Black), (5,5))
  • 2. Verander het proces van het voltooien van het spel. Verwijder een eenvoudige uitweg uit het spel wanneer een speler botsing met een bal. Maak in plaats daarvan een variabele in de klasse van de speler, die wordt gecontroleerd door te spelen. Wanneer de variabele GameOver waar wordt, moet u de update van objecten stoppen. Alle objecten zijn op zijn plaats bevroren, dus de speler kan begrijpen wat er is gebeurd en zijn account zal zien. Objecten worden nog steeds op het scherm weergegeven, maar ze stoppen gewoon bijgewerkt.
    Class Player: Def __init __ (Zelf, Rad = 20):...Zelf.Gameover = Falsedef Update (Zelf, GameObjects):...Voor Gameobj in GameObjects: If Gameobj.Type == "Bal": if (gameobj.X - zelf.x) ** 2 + (Gameobj.Y - zelf.y) ** 2 <= (gameObj.radius + self.radius)**2:self.gameOver = Trueclass game():def __init__(self):...self.gameOver = Falsedef 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
  • Titel afbeelding PrimampyGameFinal.jpg
    3. Probeer het programma! De definitieve code van het programma moet er als volgt uitzien:
    Importeer Pygamefrom willekeurige importeren willekeurrijke pygame.Locals Import * Resolutie = (400.300) wit = (255,255,255) zwart = (0.0.0) rood = (255,0,0) scherm = pygame.Weergave.SET_MODE (RESOLUTION) KLASSE BAL: DEF __INIT __ (ZELF, XPOS = RESOLUTIE [0] / 2, YPOS = Resolutie [1] / 2, Xvel = 1, Yvel = 1, Rad = 15): Zelf.x = xpossensel.Y = YPosselzelf.DX = Xvelself.dy = yvelself.RADIUS = RADSELF.Type = "Bal"Def Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, zwart, (int (zelf.x), int (zelf.y)), zelf.Straal) Def update (zelf, gamobjecten): zelf.X + = zelf.DXSELF.Y + = zelf.Dyif (Self.X <= 0 or self.x >= RESOLUTIE [0]): ZELF.DX * = -1IF (Zelf.Y <= 0 or self.y >= RESOLUTIE [1]): ZELF.DY * = -1Class Player: Def __init __ (Zelf, Rad = 20): Zelf.x = are.Y = are jezelf.RADIUS = RADSELF.Type = "Speler"Zelf.GameOver = Falsedef Draw (Self, Surface): Pygame.Tekenen.Cirkel (oppervlak, rood, (zelf.X, zelf.y), zelf.Straal) Def update (zelf, gamobjecten): snoer = pygame.Muis.GET_POS () ZELF.X = snoer [0] zelf.Y = snoer [1] voor gameobj in gameobjects: als gameobj.Type == "Bal": if (gameobj.X - zelf.x) ** 2 + (Gameobj.Y - zelf.y) ** 2 <= (gameObj.radius + self.radius)**2:self.gameOver = Trueclass GameController:def __init__(self, interval = 5):self.inter = intervalself.next = pygame.time.get_ticks() + (2 * 1000)self.type = "game controller"self.score = 0self.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 += 1def 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 = Falsedef handleEvents(self):for event in pygame.event.get():if event.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.gameOverself.screen.fill(white)for gameObj in self.gameObjects:gameObj.draw(self.screen)self.clock.tick(60)pygame.display.flip()game().run()
    • Deel in het sociale netwerk:
    Vergelijkbaar