Wie programmiere ich ein Spiel in Python mit Pygame?

Dies ist eine Einführung in Pygame für Leute, die Python bereits kennen. Dieser Artikel wird Ihnen die Schritte zum Aufbau eines einfachen Spiels beibringen, in dem der Spieler springenden Bällen ausweicht.

Teil eins von acht:
Installieren von Pygame

1. 1 Lade Pygame herunter. Finden Sie es für Ihre Plattform von http://www.pygame.org/download.shtml.
2. 2Führen Sie das Installationsprogramm aus.
3. 3 Stellen Sie sicher, dass die Installation funktioniert hat. Öffne ein Python-Terminal. Geben Sie "Importpygame" ein. Wenn Sie keine Fehler sehen, wurde Pygame erfolgreich installiert.

    einführen Pygame 

Teil Zwei von Acht:
Einrichten eines Basisfensters

1. 1Öffnen Sie eine neue Datei.
2. 2 Importieren Sie Pygame. Pygame ist eine Bibliothek, die Zugriff auf Grafikfunktionen bietet. Wenn Sie weitere Informationen zur Funktionsweise dieser Funktionen benötigen, können Sie sie auf der Pygame-Website nachschlagen. https://www.pygame.org/docs/

    einführen Pygame von Pygame.Einheimische einführen * 

3. 3 Stellen Sie die Fensterauflösung ein. Sie werden eine globale Variable für die Bildschirmauflösung erstellen, so dass in mehreren Teilen des Spiels darauf verwiesen werden kann. Es ist auch leicht zu finden am Anfang der Datei, so dass es später geändert werden kann. Bei fortgeschrittenen Projekten wäre es besser, diese Informationen in einer separaten Datei zu speichern.

    Auflösung = (400,300) 

4. 4 Definieren Sie einige Farben. Farben in Pygame sind (RBGA, die in Werten zwischen 0 und 255 liegen. Der Alpha-Wert (A) ist optional, aber die anderen Farben (Rot, Blau und Grün sind Pflichtfelder).

    Weiß = (255,255,255) schwarz = (0,0,0) rot = (255,0,0) 

5. 5 Initialisiere den Bildschirm. Verwenden Sie die Auflösungsvariable, die zuvor definiert wurde.

    Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) 

6. 6 Mach eine Spieleschleife. Wiederhole bestimmte Aktionen in jedem Frame unseres Spiels. Machen Sie eine Schleife, die immer wiederholt wird, um alle diese Aktionen zu durchlaufen.

    während Wahr: 

7. 7 Farbe den Bildschirm.

    Bildschirm.füllen(Weiß) 

8. 8 Zeigen Sie den Bildschirm an. Wenn Sie das Programm ausführen, wird der Bildschirm weiß und das Programm stürzt ab. Dies liegt daran, dass das Betriebssystem Ereignisse an das Spiel sendet und das Spiel nichts mit ihnen macht. Sobald das Spiel zu viele unbehandelte Ereignisse empfängt, wird es abstürzen.

    während Wahr:… Pygame.Anzeige.umdrehen() 

9. 9 Ereignisse behandeln Erhalte eine Liste aller Ereignisse, die in jedem Frame aufgetreten sind. Sie werden sich nur um ein Event kümmern, das quit Event. Dies geschieht, wenn der Benutzer das Spielfenster schließt. Dies verhindert auch, dass unser Programm aufgrund zu vieler Ereignisse abstürzt.

    während Wahr:… zum Veranstaltung im Pygame.Veranstaltung.bekommen(): ob Veranstaltung.Art == Beenden: Pygame.Verlassen() 

10. 10 Versuch es! So sollte der Code jetzt aussehen:

     einführen Pygame von Pygame.Einheimische einführen * Auflösung = (400,300) Weiß = (255,255,255) schwarz = (0,0,0) rot = (255,0,0) Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) während Wahr: Bildschirm.füllen(Weiß) Pygame.Anzeige.umdrehen() zum Veranstaltung im Pygame.Veranstaltung.bekommen(): ob Veranstaltung.Art == Beenden: Pygame.Verlassen() 

Teil Drei von Acht:
Ein Spielobjekt erstellen

1. 1 Erstellen Sie eine neue Klasse und einen neuen Konstruktor. Legen Sie alle Eigenschaften des Objekts fest. Sie stellen auch Standardwerte für alle Eigenschaften bereit.

    Klasse Ball: def __drin__(selbst, xPos = Auflösung[0] / 2, yPos = Auflösung[1] / 2, xVel = 1, yVel = 1, rad = 15): selbst.x = xPos selbst.y = yPos selbst.dx = xVel selbst.dy = yVel selbst.Radius = rad selbst.Art = "Ball" 

2. 2 Definieren Sie, wie das Objekt gezeichnet wird. Verwenden Sie die Eigenschaften, die im Konstruktor definiert wurden, um den Ball als Kreis zu zeichnen und eine Oberfläche in die Funktion zum Zeichnen des Objekts zu übergeben. Die Oberfläche ist das Bildschirmobjekt, das mit der früheren Auflösung erstellt wurde.

    def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, schwarz, (selbst.x, selbst.y), selbst.Radius) 

3. 3 Machen Sie eine Instanz der Klasse und sagen Sie der Spieleschleife, dass sie den Ball in jeder Runde ziehen soll.

    Ball = Ball() während Wahr:… Ball.zeichnen(Bildschirm) 

4. 4 Bewegen Sie das Objekt. Erstellen Sie eine Funktion, die die Position des Objekts aktualisiert. Rufen Sie diese Funktion in jeder Spielschleife auf.

    Klasse Ball:… def aktualisieren(selbst): selbst.x += selbst.dx selbst.y += selbst.dy 

5. 5 Begrenzen Sie die Bildrate. Der Ball wird sich sehr schnell bewegen, da die Spielschleife hunderte Male pro Sekunde läuft. Verwenden Sie die Uhr von Pygame, um die Bildrate auf 60 fps zu begrenzen.

    Uhr = Pygame.Zeit.Uhr() während Wahr:… Uhr.Tick(60) 

6. 6 Halte den Ball auf dem Bildschirm. Fügen Sie Überprüfungen in der Update-Funktion hinzu, um die Ballrichtung umzukehren, wenn sie eine der Bildschirmkanten erreicht.

    Klasse Ball:… def aktualisieren(selbst):… ob (selbst.x <= 0 oder selbst.x >= Auflösung[0]): selbst.dx *= -1 ob (selbst.y <= 0 oder selbst.y >= Auflösung[1]): selbst.dy *= -1 

7. 7 Versuch es! So sollte der Code jetzt aussehen:

    einführen Pygame von Pygame.Einheimische einführen * Auflösung = (400,300) Weiß = (255,255,255) schwarz = (0,0,0) rot = (255,0,0) Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) Klasse Ball: def __drin__(selbst, xPos = Auflösung[0] / 2, yPos = Auflösung[1] / 2, xVel = 1, yVel = 1, rad = 15): selbst.x = xPos selbst.y = yPos selbst.dx = xVel selbst.dy = yVel selbst.Radius = rad selbst.Art = "Ball" def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, schwarz, (selbst.x, selbst.y), selbst.Radius) def aktualisieren(selbst): selbst.x += selbst.dx selbst.y += selbst.dy ob (selbst.x <= 0 oder selbst.x >= Auflösung[0]): selbst.dx *= -1 ob (selbst.y <= 0 oder selbst.y >= Auflösung[1]): selbst.dy *= -1 Ball = Ball() Uhr = Pygame.Zeit.Uhr() während Wahr: Bildschirm.füllen(Weiß) Ball.zeichnen(Bildschirm) Ball.aktualisieren() Pygame.Anzeige.umdrehen() Uhr.Tick(60) zum Veranstaltung im Pygame.Veranstaltung.bekommen(): ob Veranstaltung.Art == Beenden: Pygame.Verlassen() 

Teil Vier von Acht:
Organisieren des Spiels

1. 1 Verwenden Sie Klassen, um alles zu organisieren. Das Spiel wird komplizierter. Verwenden Sie objektorientierte Techniken, um Ihren Code zu organisieren.
2. 2 Machen Sie das Spiel zu einer Klasse. Da unser Spiel jetzt Daten einschließlich Ihrer Spielobjekte und Funktionen enthält, macht es Sinn, Ihre Spielschleife in eine Klasse zu verwandeln.

    Klasse Spiel(): 

3. 3 Fügen Sie einen Konstruktor hinzu. Hier werden einige Spielobjekte instanziiert, unser Bildschirm und Uhr erstellt und Pygame initialisiert. Pygame muss initialisiert werden, um bestimmte Funktionen wie Text oder Sound zu verwenden.

    Klasse Spiel(): def __drin__(selbst): Pygame.drin() selbst.Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) selbst.Uhr = Pygame.Zeit.Uhr() 

4. 4 Behandeln Sie Ereignisse in einer Funktion.

    Klasse Spiel():… def handleEvents(selbst): zum Veranstaltung im Pygame.Veranstaltung.bekommen(): ob Veranstaltung.Art == Beenden: Pygame.Verlassen() 

5. 5 Machen Sie die Spieleschleife zu einer Funktion. Rufen Sie die Ereignisbehandlungsfunktion für jede Schleife auf.

    Klasse Spiel():… def Lauf(selbst): während Wahr: selbst.handleEvents() selbst.Bildschirm.füllen(Weiß) selbst.Uhr.Tick(60) Pygame.Anzeige.umdrehen() 

6. 6 Behandle mehrere Spielobjekte. Gerade jetzt muss dieser Code zeichnen und aktualisieren jedes Objekt auf unserem Objekt. Dies würde chaotisch werden, wenn Sie viele Objekte hätten. Lassen Sie uns unser Objekt zu einem Array hinzufügen und dann alle Objekte im Array für jede Schleife aktualisieren und zeichnen. Jetzt können Sie einfach ein anderes Objekt hinzufügen und ihm eine andere Startposition geben.

    Klasse Spiel(): def __drin__(selbst):… selbst.SpielObjekte = [] selbst.SpielObjekte.anhängen(Ball()) selbst.SpielObjekte.anhängen(Ball(100))… def Lauf(selbst): während Wahr: selbst.handleEvents() zum SpielObj im selbst.SpielObjekte: gameObj.aktualisieren() selbst.Bildschirm.füllen(Weiß) zum SpielObj im selbst.SpielObjekte: gameObj.zeichnen(selbst.Bildschirm) selbst.Uhr.Tick(60) Pygame.Anzeige.umdrehen() 

7. 7 Versuch es! So sollte der Code jetzt aussehen:

    einführen Pygame von Pygame.Einheimische einführen * Auflösung = (400,300) Weiß = (255,255,255) schwarz = (0,0,0) rot = (255,0,0) Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) Klasse Ball: def __drin__(selbst, xPos = Auflösung[0] / 2, yPos = Auflösung[1] / 2, xVel = 1, yVel = 1, rad = 15): selbst.x = xPos selbst.y = yPos selbst.dx = xVel selbst.dy = yVel selbst.Radius = rad selbst.Art = "Ball" def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, schwarz, (selbst.x, selbst.y), selbst.Radius) def aktualisieren(selbst): selbst.x += selbst.dx selbst.y += selbst.dy ob (selbst.x <= 0 oder selbst.x >= Auflösung[0]): selbst.dx *= -1 ob (selbst.y <= 0 oder selbst.y >= Auflösung[1]): selbst.dy *= -1 Klasse Spiel(): def __drin__(selbst): Pygame.drin() selbst.Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) selbst.Uhr = Pygame.Zeit.Uhr() selbst.SpielObjekte = [] selbst.SpielObjekte.anhängen(Ball()) selbst.SpielObjekte.anhängen(Ball(100)) def handleEvents(selbst): zum Veranstaltung im Pygame.Veranstaltung.bekommen(): ob Veranstaltung.Art == Beenden: Pygame.Verlassen() def Lauf(selbst): während Wahr: selbst.handleEvents() zum SpielObj im selbst.SpielObjekte: gameObj.aktualisieren() selbst.Bildschirm.füllen(Weiß) zum SpielObj im selbst.SpielObjekte: gameObj.zeichnen(selbst.Bildschirm) selbst.Uhr.Tick(60) Pygame.Anzeige.umdrehen() Spiel().Lauf() 

Teil Fünf von Acht:
Hinzufügen eines Player-Objekts

1. 1 Erstelle eine Spielerklasse und einen Konstruktor. Du machst einen weiteren Kreis, der von der Maus gesteuert wird. Initialisieren Sie die Werte im Konstruktor. Der Radius ist der einzige wichtige Wert.

    Klasse Spieler: def __drin__(selbst, rad = 20): selbst.x = 0 selbst.y = 0 selbst.Radius = rad 

2. 2 Definieren Sie, wie das Player-Objekt gezeichnet wird. Es wird genau so sein, wie du die anderen Spielobjekte gezeichnet hast.

    Klasse Spieler:… def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, rot, (selbst.x, selbst.y), selbst.Radius) 

3. 3 Fügen Sie die Maussteuerung für das Player-Objekt hinzu. Überprüfe in jedem Bild die Position der Maus und setze den Standort der Spielerobjekte auf diesen Punkt.

    Klasse Spieler:… def aktualisieren(selbst): Schnur = Pygame.Maus.get_pos() selbst.x = Kabel[0] selbst.y = Kabel[1] 

4. 4 Fügen Sie ein Spielerobjekt zu gameObjects hinzu. Erstellen Sie eine neue Player-Instanz und fügen Sie sie zur Liste hinzu.

    Klasse Spiel(): def __drin__(selbst):… selbst.SpielObjekte.anhängen(Spieler()) 

5. 5 Versuch es! So sollte der Code jetzt aussehen:

    einführen Pygame von Pygame.Einheimische einführen * Auflösung = (400,300) Weiß = (255,255,255) schwarz = (0,0,0) rot = (255,0,0) Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) Klasse Ball: def __drin__(selbst, xPos = Auflösung[0] / 2, yPos = Auflösung[1] / 2, xVel = 1, yVel = 1, rad = 15): selbst.x = xPos selbst.y = yPos selbst.dx = xVel selbst.dy = yVel selbst.Radius = rad selbst.Art = "Ball" def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, schwarz, (selbst.x, selbst.y), selbst.Radius) def aktualisieren(selbst): selbst.x += selbst.dx selbst.y += selbst.dy ob (selbst.x <= 0 oder selbst.x >= Auflösung[0]): selbst.dx *= -1 ob (selbst.y <= 0 oder selbst.y >= Auflösung[1]): selbst.dy *= -1 Klasse Spieler: def __drin__(selbst, rad = 20): selbst.x = 0 selbst.y = 0 selbst.Radius = rad selbst.Art = "Spieler" def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, rot, (selbst.x, selbst.y), selbst.Radius) def aktualisieren(selbst): Schnur = Pygame.Maus.get_pos() selbst.x = Kabel[0] selbst.y = Kabel[1] Klasse Spiel(): def __drin__(selbst): Pygame.drin() selbst.Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) selbst.Uhr = Pygame.Zeit.Uhr() selbst.SpielObjekte = [] selbst.SpielObjekte.anhängen(Spieler()) selbst.SpielObjekte.anhängen(Ball()) selbst.SpielObjekte.anhängen(Ball(100)) def handleEvents(selbst): zum Veranstaltung im Pygame.Veranstaltung.bekommen(): ob Veranstaltung.Art == Beenden: Pygame.Verlassen() def Lauf(selbst): während Wahr: selbst.handleEvents() zum SpielObj im selbst.SpielObjekte: gameObj.aktualisieren() selbst.Bildschirm.füllen(Weiß) zum SpielObj im selbst.SpielObjekte: gameObj.zeichnen(selbst.Bildschirm) selbst.Uhr.Tick(60) Pygame.Anzeige.umdrehen() Spiel().Lauf() 

Teil Sechs von Acht:
Objekte mit dem Player interagieren lassen

1. 1 Ändern Sie die Update-Funktionen. Damit Objekte interagieren können, müssen sie Zugriff aufeinander haben. Fügen wir einen weiteren Parameter zu Update hinzu, um die gameObjects-Liste zu übergeben. Sie müssen es sowohl dem Player-Objekt als auch den Ball-Objekten hinzufügen. Wenn Sie viele Spielobjekte haben, könnte die Vererbung helfen, alle Ihre Methodensignaturen gleich zu halten.

    Klasse Ball:… def aktualisieren(selbst, SpielObjekte):… Klasse Spieler:… def aktualisieren(selbst, SpielObjekte): 

2. 2 Prüfe auf Kollisionen zwischen dem Spieler und den Bällen. Gehe durch alle Spielobjekte und überprüfe ob der Typ der Objekte Ball ist. Verwenden Sie dann die Radien der beiden Objekte und die Abstandsformel, um zu prüfen, ob sie kollidieren. Kreise lassen sich sehr einfach auf Kollisionen überprüfen. Dies ist der Hauptgrund, dass du keine andere Form für dieses Spiel benutzt hast.

    Klasse Spieler:… def aktualisieren(selbst, SpielObjekte):… zum SpielObj im SpielObjekte: ob SpielObj.Art == "Ball": ob (SpielObj.x - selbst.x)**2 + (SpielObj.y - selbst.y)**2 <= (SpielObj.Radius + selbst.Radius)**2: 

3. 3 Beende das Spiel, wenn der Spieler "getroffen" wird. Lass uns das Spiel jetzt einfach beenden.

    ob (SpielObj.x - selbst.x)**2 + (SpielObj.y - selbst.y)**2 <= (SpielObj.Radius + selbst.Radius)**2: Pygame.Verlassen() 

4. 4 Versuch es! So sieht der Code jetzt aus:

    einführen Pygame von Pygame.Einheimische einführen * Auflösung = (400, 300) Weiß = (255,255,255) schwarz = (0,0,0) rot = (255,0,0) Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) Klasse Ball: def __drin__(selbst, xPos = Auflösung[0] / 2, yPos = Auflösung[1] / 2, xVel = 1, yVel = 1, rad = 15): selbst.x = xPos selbst.y = yPos selbst.dx = xVel selbst.dy = yVel selbst.Radius = rad selbst.Art = "Ball" def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, schwarz, (selbst.x, selbst.y), selbst.Radius) def aktualisieren(selbst, SpielObjekte): selbst.x += selbst.dx selbst.y += selbst.dy ob (selbst.x <= 0 oder selbst.x >= Auflösung[0]): selbst.dx *= -1 ob (selbst.y <= 0 oder selbst.y >= Auflösung[1]): selbst.dy *= -1 Klasse Spieler: def __drin__(selbst, rad = 20): selbst.x = 0 selbst.y = 0 selbst.Radius = rad selbst.Art = "Spieler" def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, rot, (selbst.x, selbst.y), selbst.Radius) def aktualisieren(selbst, SpielObjekte): Schnur = Pygame.Maus.get_pos() selbst.x = Kabel[0] selbst.y = Kabel[1] zum SpielObj im SpielObjekte: ob SpielObj.Art == "Ball": ob (SpielObj.x - selbst.x)**2 + (SpielObj.y - selbst.y)**2 <= (SpielObj.Radius + selbst.Radius)**2: Pygame.Verlassen() Klasse Spiel(): def __drin__(selbst): Pygame.drin() selbst.Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) selbst.Uhr = Pygame.Zeit.Uhr() selbst.SpielObjekte = [] selbst.SpielObjekte.anhängen(Spieler()) selbst.SpielObjekte.anhängen(Ball()) selbst.SpielObjekte.anhängen(Ball(100)) def handleEvents(selbst): zum Veranstaltung im Pygame.Veranstaltung.bekommen(): ob Veranstaltung.Art == Beenden: Pygame.Verlassen() def Lauf(selbst): während Wahr: selbst.handleEvents() zum SpielObj im selbst.SpielObjekte: gameObj.aktualisieren(selbst.SpielObjekte) selbst.Bildschirm.füllen(Weiß) zum SpielObj im selbst.SpielObjekte: gameObj.zeichnen(selbst.Bildschirm) selbst.Uhr.Tick(60) Pygame.Anzeige.umdrehen() Spiel().Lauf() 

Teil Sieben von Acht:
Hinzufügen eines Game Controllers zum Erstellen von Objekten

1. 1 Erstelle eine Game-Controller-Klasse. Game-Controller sind dafür verantwortlich, das Spiel zu "laufen". Es unterscheidet sich von unserer Spielklasse, die für das Zeichnen und Aktualisieren all unserer Objekte verantwortlich ist. Der Controller fügt regelmäßig einen weiteren Ball zum Bildschirm hinzu, um das Spiel zu erschweren. Fügen Sie einen Konstruktor hinzu und initialisieren Sie einige Grundwerte. Das Intervall ist die Zeit bevor ein weiterer Ball hinzugefügt wird.

    Klasse Spielcontroller: def __drin__(selbst, Intervall = 5): selbst.inter = Intervall selbst.Nächster = Pygame.Zeit.get_ticks() + (2 * 1000) selbst.Art = "spielcontroller" 

2. 2 Fügen Sie die Update-Funktion hinzu. Dadurch wird überprüft, wie viel Zeit seit dem Zeitpunkt, zu dem ein Ball hinzugefügt wurde, oder seit Beginn des Spiels verstrichen ist. Wenn die Zeit länger ist als das Intervall, wird die Zeit zurückgesetzt und ein Ball hinzugefügt.

    Klasse Spielcontroller:… def aktualisieren(selbst, SpielObjekte): ob selbst.Nächster < Pygame.Zeit.get_ticks(): selbst.Nächster = Pygame.Zeit.get_ticks() + (selbst.inter * 1000) SpielObjekte.anhängen(Ball()) 

3. 3 Gib den Kugeln zufällige Geschwindigkeiten. Sie müssen Zufallszahlen verwenden, um das Spiel jedes Mal anders zu machen. Die Geschwindigkeiten der Kugeln sind jetzt jedoch eine Gleitkommazahl anstelle einer Ganzzahl.

    Klasse Spielcontroller:… def aktualisieren(selbst, SpielObjekte): ob selbst.Nächster < Pygame.Zeit.get_ticks(): selbst.Nächster = Pygame.Zeit.get_ticks() + (selbst.inter * 1000) SpielObjekte.anhängen(Ball(xVel=zufällig()*2, yVel=zufällig()*2)) 

4. 4 Beheben Sie die Zeichenfunktion. Die Zeichenfunktion akzeptiert keine Floats. Lassen Sie uns die Position des Balls in ganze Zahlen umwandeln, bevor die Bälle gezogen werden.

    Klasse Ball:… def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, schwarz, (int(selbst.x), int(selbst.y)), selbst.Radius) 

5. 5 Definieren Sie eine Zeichenmethode für den Gamecontroller. Da es sich um ein Spielobjekt handelt, versucht die Hauptschleife, es zu zeichnen. Sie müssen eine Zeichenfunktion definieren, die nichts bewirkt, damit das Spiel nicht abstürzt.

    Klasse Spielcontroller:… def zeichnen(selbst, Bildschirm): bestehen 

6. 6 Fügen Sie GameObjects den Gamecontroller hinzu und entfernen Sie die 2 Bälle. Das Spiel sollte nun alle fünf Sekunden einen Ball spawnen.

    Klasse Spiel(): def __drin__(selbst):… selbst.SpielObjekte = [] selbst.SpielObjekte.anhängen(Spielcontroller()) selbst.SpielObjekte.anhängen(Spieler()) 

7. 7 Versuch es! So sollte der Code jetzt aussehen:

    einführen Pygame von zufällig einführen zufällig von Pygame.Einheimische einführen * Auflösung = (400,300) Weiß = (255,255,255) schwarz = (0,0,0) rot = (255,0,0) Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) Klasse Ball: def __drin__(selbst, xPos = Auflösung[0] / 2, yPos = Auflösung[1] / 2, xVel = 1, yVel = 1, rad = 15): selbst.x = xPos selbst.y = yPos selbst.dx = xVel selbst.dy = yVel selbst.Radius = rad selbst.Art = "Ball" def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, schwarz, (int(selbst.x), int(selbst.y)), selbst.Radius) def aktualisieren(selbst, SpielObjekte): selbst.x += selbst.dx selbst.y += selbst.dy ob (selbst.x <= 0 oder selbst.x >= Auflösung[0]): selbst.dx *= -1 ob (selbst.y <= 0 oder selbst.y >= Auflösung[1]): selbst.dy *= -1 Klasse Spieler: def __drin__(selbst, rad = 20): selbst.x = 0 selbst.y = 0 selbst.Radius = rad selbst.Art = "Spieler" def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, rot, (selbst.x, selbst.y), selbst.Radius) def aktualisieren(selbst, SpielObjekte): Schnur = Pygame.Maus.get_pos() selbst.x = Kabel[0] selbst.y = Kabel[1] zum SpielObj im SpielObjekte: ob SpielObj.Art == "Ball": ob (SpielObj.x - selbst.x)**2 + (SpielObj.y - selbst.y)**2 <= (SpielObj.Radius + selbst.Radius)**2: Pygame.Verlassen() Klasse Spielcontroller: def __drin__(selbst, Intervall = 5): selbst.inter = Intervall selbst.Nächster = Pygame.Zeit.get_ticks() + (2 * 1000) selbst.Art = "spielcontroller" def aktualisieren(selbst, SpielObjekte): ob selbst.Nächster < Pygame.Zeit.get_ticks(): selbst.Nächster = Pygame.Zeit.get_ticks() + (selbst.inter * 1000) SpielObjekte.anhängen(Ball(xVel=zufällig()*2, yVel=zufällig()*2)) def zeichnen(selbst, Bildschirm): bestehen Klasse Spiel(): def __drin__(selbst): Pygame.drin() selbst.Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) selbst.Uhr = Pygame.Zeit.Uhr() selbst.SpielObjekte = [] selbst.SpielObjekte.anhängen(Spielcontroller()) selbst.SpielObjekte.anhängen(Spieler()) def handleEvents(selbst): zum Veranstaltung im Pygame.Veranstaltung.bekommen(): ob Veranstaltung.Art == Beenden: Pygame.Verlassen() def Lauf(selbst): während Wahr: selbst.handleEvents() zum SpielObj im selbst.SpielObjekte: gameObj.aktualisieren(selbst.SpielObjekte) selbst.Bildschirm.füllen(Weiß) zum SpielObj im selbst.SpielObjekte: gameObj.zeichnen(selbst.Bildschirm) selbst.Uhr.Tick(60) Pygame.Anzeige.umdrehen() Spiel().Lauf() 

Teil Acht von Acht:
Hinzufügen eines Punktes und Spielüberg

1. 1 Fügen Sie der Game-Controller-Klasse eine Punktzahl hinzu. Erstellen Sie ein Schriftartenobjekt und eine Bewertungsvariable. Sie zeichnen die Schriftart in jedem Frame, um die Punktzahl anzuzeigen und die Punktzahl bei jedem Update zu erhöhen.

    Klasse Spielcontroller: def __drin__(selbst, Intervall = 5):… selbst.Ergebnis = 0 selbst.PunktzahlText = Pygame.Schriftart.Schriftart(Keiner, 12) def aktualisieren(selbst, SpielObjekte):… selbst.Ergebnis += 1 def zeichnen(selbst, Bildschirm): Bildschirm.Blit(selbst.PunktzahlText.machen(str(selbst.Ergebnis), Wahr, schwarz), (5,5)) 

2. 2 Ändern Sie, wie das Spiel endet. Lassen Sie uns den Abbruch loswerden, wenn der Spieler eine Kollision erkennt. Stattdessen legen Sie eine Variable im Player fest, die das Spiel überprüfen kann. Wenn gameOver eingestellt ist, stoppen Sie das Aktualisieren von Objekten. Dadurch wird alles an der richtigen Stelle eingefroren, so dass der Spieler sehen kann, was passiert ist und seine Punktzahl überprüfen. Beachten Sie, dass die Objekte immer noch gezeichnet werden, nur nicht aktualisiert.

    Klasse Spieler: def __drin__(selbst, rad = 20):… selbst.Spiel ist aus = Falsch def aktualisieren(selbst, SpielObjekte):… zum SpielObj im SpielObjekte: ob SpielObj.Art == "Ball": ob (SpielObj.x - selbst.x)**2 + (SpielObj.y - selbst.y)**2 <= (SpielObj.Radius + selbst.Radius)**2: selbst.Spiel ist aus = Wahr Klasse Spiel(): def __drin__(selbst):… selbst.Spiel ist aus = Falsch def Lauf(selbst): während Wahr: selbst.handleEvents() ob nicht selbst.Spiel ist aus: zum SpielObj im selbst.SpielObjekte: gameObj.aktualisieren(selbst.SpielObjekte) ob SpielObj.Art == "Spieler": selbst.Spiel ist aus = SpielObj.Spiel ist aus 

3. 3 Versuch es! So sollte der fertige Code jetzt aussehen:

    einführen Pygame von zufällig einführen zufällig von Pygame.Einheimische einführen * Auflösung = (400,300) Weiß = (255,255,255) schwarz = (0,0,0) rot = (255,0,0) Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) Klasse Ball: def __drin__(selbst, xPos = Auflösung[0] / 2, yPos = Auflösung[1] / 2, xVel = 1, yVel = 1, rad = 15): selbst.x = xPos selbst.y = yPos selbst.dx = xVel selbst.dy = yVel selbst.Radius = rad selbst.Art = "Ball" def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, schwarz, (int(selbst.x), int(selbst.y)), selbst.Radius) def aktualisieren(selbst, SpielObjekte): selbst.x += selbst.dx selbst.y += selbst.dy ob (selbst.x <= 0 oder selbst.x >= Auflösung[0]): selbst.dx *= -1 ob (selbst.y <= 0 oder selbst.y >= Auflösung[1]): selbst.dy *= -1 Klasse Spieler: def __drin__(selbst, rad = 20): selbst.x = 0 selbst.y = 0 selbst.Radius = rad selbst.Art = "Spieler" selbst.Spiel ist aus = Falsch def zeichnen(selbst, Oberfläche): Pygame.zeichnen.Kreis(Oberfläche, rot, (selbst.x, selbst.y), selbst.Radius) def aktualisieren(selbst, SpielObjekte): Schnur = Pygame.Maus.get_pos() selbst.x = Kabel[0] selbst.y = Kabel[1] zum SpielObj im SpielObjekte: ob SpielObj.Art == "Ball": ob (SpielObj.x - selbst.x)**2 + (SpielObj.y - selbst.y)**2 <= (SpielObj.Radius + selbst.Radius)**2: selbst.Spiel ist aus = Wahr Klasse Spielcontroller: def __drin__(selbst, Intervall = 5): selbst.inter = Intervall selbst.Nächster = Pygame.Zeit.get_ticks() + (2 * 1000) selbst.Art = "spielcontroller" selbst.Ergebnis = 0 selbst.PunktzahlText = Pygame.Schriftart.Schriftart(Keiner, 12) def aktualisieren(selbst, SpielObjekte): ob selbst.Nächster < Pygame.Zeit.get_ticks(): selbst.Nächster = Pygame.Zeit.get_ticks() + (selbst.inter * 1000) SpielObjekte.anhängen(Ball(xVel=zufällig()*2, yVel=zufällig()*2)) selbst.Ergebnis += 1 def zeichnen(selbst, Bildschirm): Bildschirm.Blit(selbst.PunktzahlText.machen(str(selbst.Ergebnis), Wahr, schwarz), (5,5)) Klasse Spiel(): def __drin__(selbst): Pygame.drin() selbst.Bildschirm = Pygame.Anzeige.Wähle den Modus(Auflösung) selbst.Uhr = Pygame.Zeit.Uhr() selbst.SpielObjekte = [] selbst.SpielObjekte.anhängen(Spielcontroller()) selbst.SpielObjekte.anhängen(Spieler()) selbst.Spiel ist aus = Falsch def handleEvents(selbst): zum Veranstaltung im Pygame.Veranstaltung.bekommen(): ob Veranstaltung.Art == Beenden: Pygame.Verlassen() def Lauf(selbst): während Wahr: selbst.handleEvents() ob nicht selbst.Spiel ist aus: zum SpielObj im selbst.SpielObjekte: gameObj.aktualisieren(selbst.SpielObjekte) ob SpielObj.Art == "Spieler": selbst.Spiel ist aus = SpielObj.Spiel ist aus selbst.Bildschirm.füllen(Weiß) zum SpielObj im selbst.SpielObjekte: gameObj.zeichnen(selbst.Bildschirm) selbst.Uhr.Tick(60) Pygame.Anzeige.umdrehen() Spiel().Lauf()