Dies ist eine Einführung in Pygame für Leute, die Python bereits kennen. In diesem Artikel erfahren Sie, wie Sie ein einfaches Spiel erstellen, bei dem der Spieler springenden Bällen ausweicht.
Schritte
Teil 1 von 8: Pygame installieren
Schritt 1. Laden Sie Pygame herunter
Finden Sie es für Ihre Plattform unter
Schritt 2. Führen Sie das Installationsprogramm aus
Schritt 3. Überprüfen Sie, ob die Installation funktioniert hat
Öffnen Sie ein Python-Terminal. Geben Sie "pygame importieren" ein. Wenn keine Fehler angezeigt werden, wurde Pygame erfolgreich installiert.
Pygame importieren
Teil 2 von 8: Einrichten eines einfachen Fensters
Schritt 1. Öffnen Sie eine neue Datei
Schritt 2. Pygame importieren
Pygame ist eine Bibliothek, die Zugriff auf Grafikfunktionen bietet. Wenn Sie mehr über die Funktionsweise dieser Funktionen erfahren möchten, können Sie sie auf der Pygame-Website nachschlagen.
pygame von pygame.locals importieren importieren *
Schritt 3. Stellen Sie die Fensterauflösung ein
Sie werden eine globale Variable für die Bildschirmauflösung erstellen, auf die in mehreren Teilen des Spiels verwiesen werden kann. Es ist auch leicht am Anfang der Datei zu finden, damit es später geändert werden kann. Für fortgeschrittene Projekte wäre es besser, diese Informationen in einer separaten Datei abzulegen.
Auflösung = (400, 300)
Schritt 4. Definieren Sie einige Farben
Farben in Pygame sind (RBGA mit Werten zwischen 0 und 255. Der Alpha-Wert (A) ist optional, aber die anderen Farben (Rot, Blau und Grün sind obligatorisch).
weiß = (255, 255, 255) schwarz = (0, 0, 0) rot = (255, 0, 0)
Schritt 5. Initialisieren Sie den Bildschirm
Verwenden Sie die zuvor definierte Auflösungsvariable.
screen = pygame.display.set_mode (Auflösung)
Schritt 6. Erstellen Sie eine Spielschleife
Wiederholen Sie bestimmte Aktionen in jedem Frame unseres Spiels. Erstellen Sie eine Schleife, die sich immer wiederholt, um alle diese Aktionen zu durchlaufen.
während Wahr:
Schritt 7. Färben Sie den Bildschirm
screen.fill (weiß)
Schritt 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, stürzt es ab.
while True: … pygame.display.flip()
Schritt 9. Behandeln Sie Ereignisse
Rufen Sie eine Liste aller Ereignisse ab, die in jedem Frame aufgetreten sind. Sie werden sich nur um ein Ereignis kümmern, das quit-Ereignis. Dies tritt auf, wenn der Benutzer das Spielfenster schließt. Dadurch wird auch verhindert, dass unser Programm aufgrund zu vieler Ereignisse abstürzt.
while True: … für Event in pygame.event.get(): if event.type == QUIT: pygame.quit()
Schritt 10. Probieren Sie es aus
So sollte der Code jetzt aussehen:
import pygame from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame.display.set_mode(Auflösung) während True: screen.fill(white) pygame.display.flip() für Event in pygame.event.get(): if event.type == QUIT: pygame.quit()
Teil 3 von 8: Ein Spielobjekt erstellen
Schritt 1. Erstellen Sie eine neue Klasse und einen Konstruktor
Legen Sie alle Eigenschaften des Objekts fest. Sie stellen auch Standardwerte für alle Eigenschaften bereit.
class Ball: def _init_(self, xPos = Auflösung[0] / 2, yPos = Auflösung[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 = "ball"
Schritt 2. Definieren Sie, wie das Objekt gezeichnet werden soll
Verwenden Sie die im Konstruktor definierten Eigenschaften, um die Kugel als Kreis zu zeichnen sowie eine Fläche an die Funktion zu übergeben, auf der das Objekt gezeichnet werden soll. Die Oberfläche ist das Bildschirmobjekt, das mit der vorherigen Auflösung erstellt wurde.
def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius)
Schritt 3. Erstellen Sie eine Instanz der Klasse und weisen Sie die Spielschleife an, den Ball in jeder Schleife zu ziehen
ball = Ball() während True: … ball.draw(screen)
Schritt 4. Bewegen Sie das Objekt
Erstellen Sie eine Funktion, die die Position des Objekts aktualisiert. Rufen Sie diese Funktion in jeder Spielschleife auf.
class Ball: … def update(self): self.x += self.dx self.y += self.dy
Schritt 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.
clock = pygame.time. Clock() während True: … clock.tick(60)
Schritt 6. Halten Sie den Ball auf dem Bildschirm
Fügen Sie Checks in der Update-Funktion hinzu, um die Richtung des Balls umzukehren, wenn er einen der Bildschirmränder trifft.
class Ball: … def update(self): … if (self.x <= 0 oder self.x >= Resolution[0]): self.dx *= -1 if (self.y <= 0 oder self.y >= Auflösung[1]): self.dy *= -1
Schritt 7. Probieren Sie es aus
So sollte der Code jetzt aussehen:
import pygame from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame.display.set_mode(Auflösung) Klasse Ball: def _init_(self, xPos = Auflösung[0] / 2, yPos = Auflösung[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 = "ball" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 oder self.x >= Auflösung[0]): self.dx *= -1 if (self.y <= 0 or self.y >= Resolution[1]): self.dy *= -1 ball = Ball() clock = pygame.time. Clock() while True: screen. fill(white) ball.draw(screen) ball.update() pygame.display.flip() clock.tick(60) für Event in pygame.event.get(): if event.type == QUIT: pygame.quit ()
Teil 4 von 8: Das Spiel organisieren
Schritt 1. Verwenden Sie Klassen, um alles zu organisieren
Das Spiel wird komplizierter. Verwenden Sie objektorientierte Techniken, um Ihren Code zu organisieren.
Schritt 2. Machen Sie die Spielschleife zu einer Klasse
Da unser Spiel jetzt Daten enthält, einschließlich Ihrer Spielobjekte und -funktionen, ist es sinnvoll, Ihre Spielschleife in eine Klasse zu verwandeln.
Klassenspiel():
Schritt 3. Fügen Sie einen Konstruktor hinzu
Hier werden Sie einige Spielobjekte instanziieren, unseren Bildschirm und unsere Uhr erstellen und Pygame initialisieren. Pygame muss initialisiert werden, um bestimmte Funktionen wie Text oder Sound verwenden zu können.
class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock()
Schritt 4. Behandeln Sie Ereignisse in einer Funktion
class game(): … def handleEvents(self): für Event in pygame.event.get(): if event.type == QUIT: pygame.quit()
Schritt 5. Machen Sie die Spielschleife zu einer Funktion
Rufen Sie die Ereignisbehandlungsfunktion in jeder Schleife auf.
class game(): … def run(self): while True: self.handleEvents() self.screen.fill(white) self.clock.tick(60) pygame.display.flip()
Schritt 6. Behandeln Sie mehrere Spielobjekte
Im Moment muss dieser Code in jedem Frame draw und update für unser Objekt aufrufen. Dies würde unordentlich werden, wenn Sie viele Objekte hätten. Lassen Sie uns unser Objekt zu einem Array hinzufügen und dann alle Objekte im Array in jeder Schleife aktualisieren und zeichnen. Jetzt können Sie ganz einfach ein weiteres Objekt hinzufügen und ihm eine andere Startposition geben.
class game(): def _init_(self): … self.gameObjects = self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) … def run(self): while True: self.handleEvents() für gameObj in self.gameObjects: gameObj.update() self.screen.fill(white) für gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip()
Schritt 7. Probieren Sie es aus
So sollte der Code jetzt aussehen:
import pygame from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame.display.set_mode(Auflösung) Klasse Ball: def _init_(self, xPos = Auflösung[0] / 2, yPos = Auflösung[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 = "ball" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 oder self.x >= Auflösung[0]): self.dx *= -1 if (self.y <= 0 or self.y >= Resolution[1]): self.dy *= -1 class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(Auflösung) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(self): für Ereignis in pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvent s() für gameObj in self.gameObjects: gameObj.update() self.screen.fill(white) für gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display. flip() game().run()
Teil 5 von 8: Spielerobjekt hinzufügen
Schritt 1. Erstellen Sie eine Spielerklasse und einen Konstruktor
Sie werden einen weiteren Kreis erstellen, der mit der Maus gesteuert wird. Initialisieren Sie die Werte im Konstruktor. Der Radius ist der einzige wichtige Wert.
class Player: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Schritt 2. Definieren Sie, wie das Spielerobjekt gezeichnet werden soll
Es wird genauso sein, wie Sie die anderen Spielobjekte gezeichnet haben.
class Player: … def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius)
Schritt 3. Fügen Sie die Maussteuerung für das Player-Objekt hinzu
Überprüfen Sie in jedem Frame die Position der Maus und stellen Sie die Position der Spielerobjekte auf diesen Punkt ein.
class Player: … def update(self): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1]
Schritt 4. Fügen Sie ein Spielerobjekt zu gameObjects hinzu
Erstellen Sie eine neue Player-Instanz und fügen Sie sie der Liste hinzu.
Klasse game(): def _init_(self): … self.gameObjects.append(Player())
Schritt 5. Probieren Sie es aus
So sollte der Code jetzt aussehen:
import pygame from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame.display.set_mode(Auflösung) Klasse Ball: def _init_(self, xPos = Auflösung[0] / 2, yPos = Auflösung[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 = "ball" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 oder self.x >= Auflösung[0]): self.dx *= -1 if (self.y <= 0 or self.y >= Resolution[1]): self.dy *= -1 Klasse Spieler: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update (self): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_ mode(Auflösung) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Player()) self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100.))) def handleEvents(self): für Event in pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() für gameObj in self.gameObjects: gameObj.update() self.screen.fill(white) für gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game(). Lauf()
Teil 6 von 8: Objekte mit dem Spieler interagieren lassen
Schritt 1. Ändern Sie die Update-Funktionen
Damit Objekte interagieren können, müssen sie aufeinander zugreifen können. Lassen Sie uns einen weiteren Parameter zu Update hinzufügen, um die Liste gameObjects zu übergeben. Sie müssen es sowohl dem Spielerobjekt als auch den Ballobjekten hinzufügen. Wenn Sie viele Spielobjekte haben, kann die Vererbung Ihnen helfen, alle Ihre Methodensignaturen gleich zu halten.
class Ball: … def update(self, gameObjects): … class Player: … def update(self, gameObjects):
Schritt 2. Auf Kollisionen zwischen Spieler und Bällen prüfen
Gehen Sie alle Spielobjekte durch und prüfen Sie, ob der Typ der Objekte Kugel ist. Verwenden Sie dann die Radien der beiden Objekte und die Abstandsformel, um zu überprüfen, ob sie kollidieren. Kreise sind wirklich einfach, Kollisionen zu überprüfen. Dies ist der Hauptgrund dafür, dass Sie für dieses Spiel keine andere Form verwendet haben.
class Player: … def update(self, gameObjects): … für gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2:
Schritt 3. Beende das Spiel, wenn der Spieler "geschlagen" wird
Beenden wir das Spiel erst einmal.
if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit()
Schritt 4. Probieren Sie es aus
So sollte der Code jetzt aussehen:
import pygame from pygame.locals import * resolution = (400, 300) white = (255, 255, 255) black = (0, 0, 0) red = (255, 0, 0) screen = pygame.display.set_mode(Auflösung) Klasse Ball: def _init_(self, xPos = Auflösung[0] / 2, yPos = Auflösung[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 = "ball" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 oder self.x >= Auflösung[0]): self.dx *= -1 if (self.y <= 0 or self.y >= Auflösung[1]): self.dy *= -1 Klasse Spieler: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] für gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit() class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(Auflösung) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Player()) self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(self): für Event in pygame.event.get(): if event.type == QUIT: pygame.quit () def run(self): while True: self.handleEvents() für gameObj in self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill(white) für gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
Teil 7 von 8: Hinzufügen eines Gamecontrollers zum Erstellen von Objekten
Schritt 1. Erstellen Sie eine Gamecontroller-Klasse
Gamecontroller sind für das "Laufen" des Spiels verantwortlich. Es unterscheidet sich von unserer Spielklasse, die für das Zeichnen und Aktualisieren aller unserer Objekte verantwortlich ist. Der Controller fügt dem Bildschirm regelmäßig einen weiteren Ball hinzu, um das Spiel zu erschweren. Fügen Sie einen Konstruktor hinzu und initialisieren Sie einige grundlegende Werte. Das Intervall ist die Zeit, bevor ein weiterer Ball hinzugefügt wird.
Klasse GameController: def _init_(self, interval = 5): self.inter = Intervall self.next = pygame.time.get_ticks() + (2 * 1000) self.type = "Gamecontroller"
Schritt 2. Fügen Sie die Update-Funktion hinzu
Dadurch wird überprüft, wie viel Zeit seit dem Hinzufügen eines Balls oder seit dem Beginn des Spiels vergangen ist. Wenn die Zeit länger als das Intervall ist, setzen Sie die Zeit zurück und fügen einen Ball hinzu.
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())
Schritt 3. Geben Sie den Kugeln zufällige Geschwindigkeiten
Sie müssen Zufallszahlen verwenden, um das Spiel jedes Mal anders zu gestalten. Die Geschwindigkeiten der Kugeln sind jetzt jedoch eine Gleitkommazahl statt einer ganzen Zahl.
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=zufällig()*2, yVel=zufällig()*2))
Schritt 4. Korrigieren Sie die Zeichenfunktion
Die Draw-Funktion akzeptiert keine Floats. Lassen Sie uns die Position der Kugel in ganze Zahlen umwandeln, bevor die Kugeln gezeichnet werden.
class Ball: … def draw(self, surface): pygame.draw.circle(surface, black, (int(self.x), int(self.y)), self.radius)
Schritt 5. Definieren Sie eine Draw-Methode für den Gamecontroller
Da es sich um ein Spielobjekt handelt, wird die Hauptschleife versuchen, es zu zeichnen. Sie müssen eine Draw-Funktion definieren, die nichts tut, damit das Spiel nicht abstürzt.
Klasse GameController: … def draw(self, screen): pass
Schritt 6. Fügen Sie den Gamecontroller zu gameObjects hinzu und entfernen Sie die 2 Kugeln
Das Spiel sollte jetzt alle fünf Sekunden einen Ball spawnen.
class game(): def _init_(self): … self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player())
Schritt 7. Probieren Sie es aus
So sollte der Code jetzt aussehen:
Import von Pygame von Random Import von Pygame.locals Import * Auflösung = (400, 300) Weiß = (255, 255, 255) Schwarz = (0, 0, 0) Rot = (255, 0, 0) Bildschirm = Pygame. display.set_mode(resolution) class Ball: def _init_(self, xPos = Resolution[0] / 2, yPos = Resolution[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 = "ball" def draw(self, surface): pygame.draw.circle(surface, black, (int(self. x), int(self.y)), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 or self. x >= Auflösung[0]): self.dx *= -1 if (self.y <= 0 oder self.y >= Auflösung[1]): self.dy *= -1 Klasse Spieler: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] für gameObj im Spiel Objekte: if gameObj.type == "ball": 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 = Intervall self.next = pygame.time.get_ticks() + (2 * 1000) self.type = "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=random ()*2, yVel=random()*2)) def draw(self, screen): pass class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution.)) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player()) def handleEvents(self): für Ereignis in pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() für gameObj in self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill(weiß) für gameObj in self.gameO Objekte: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
Teil 8 von 8: Punktzahl hinzufügen und Game Over
Schritt 1. Fügen Sie der Gamecontroller-Klasse eine Punktzahl hinzu
Erstellen Sie ein Font-Objekt und eine Score-Variable. Sie zeichnen die Schriftart in jedem Frame, um die Punktzahl anzuzeigen, und erhöhen die Punktzahl in jedem Frame im Update.
class GameController: def _init_(self, interval = 5): … self.score = 0 self.scoreText = pygame.font. Font(None, 12) def update(self, gameObjects): … self.score += 1 def draw (self, screen): screen.blit(self.scoreText.render(str(self.score), True, black), (5, 5))
Schritt 2. Ändern Sie, wie das Spiel endet
Lassen Sie uns das Quit loswerden, wenn der Spieler eine Kollision erkennt. Stattdessen legen Sie im Player eine Variable fest, die das Spiel überprüfen kann. Wenn gameOver eingestellt ist, beenden Sie die Aktualisierung von Objekten. Dadurch wird alles an Ort und Stelle eingefroren, sodass der Spieler sehen kann, was passiert ist und seine Punktzahl überprüfen kann. Beachten Sie, dass die Objekte noch gezeichnet, nur nicht aktualisiert werden.
class Player: def _init_(self, rad = 20): … self.gameOver = False def update(self, gameObjects): … für gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: self.gameOver = True class game(): def _init_(self): … self.gameOver = False def run(self): while True: self.handleEvents() wenn nicht self.gameOver: für gameObj in self.gameObjects: gameObj.update(self.gameObjects) if gameObj.type == "player": self.gameOver = gameObj.gameOver
Schritt 3. Probieren Sie es aus
So sollte der fertige Code jetzt aussehen:
Import von Pygame von Random Import von Pygame.locals Import * Auflösung = (400, 300) Weiß = (255, 255, 255) Schwarz = (0, 0, 0) Rot = (255, 0, 0) Bildschirm = Pygame. display.set_mode(resolution) class Ball: def _init_(self, xPos = Resolution[0] / 2, yPos = Resolution[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 = "ball" def draw(self, surface): pygame.draw.circle(surface, black, (int(self. x), int(self.y)), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 or self. x >= Auflösung[0]): self.dx *= -1 if (self.y <= 0 oder self.y >= Auflösung[1]): self.dy *= -1 Klasse Spieler: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" self.gameOver = False def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] für gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: self.gameOver = True class GameController: def _init_(self, interval = 5): self.inter = Intervall self.next = pygame.time.get_ticks() + (2 * 1000) self. type = "Gamecontroller" self.score = 0 self.scoreText = pygame.font. Font(None, 12) def update(self, gameObjects): if self.next < pygame.time.get_ticks(): self.next = pygame.time.get_ticks() + (self.inter * 1000) gameObjects.append(Ball(xVel=random()*2, yVel=random()*2)) self.score += 1 def draw(self, screen): screen.blit(self.scoreText.render(str(self.score), True, black), (5, 5)) class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(Auflösung) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player()) self.gameOver = False def handleEvents(self): für Ereignis in pygame.event.get(): if ev ent.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() falls nicht self.gameOver: für gameObj in self.gameObjects: gameObj.update(self.gameObjects) if gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill(white) für gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip () Spiel().run()
