Pygame -Videospiele

PyGame ist ein Modul in Python, das für Videospieldesign verwendet wird. Diese Videospiele reichen von einem einfachen Tic -Tac -Zeh bis hin zu Weltraumkämpfer. Egal, ob Sie ein einfaches oder ein einfaches Spiel entwerfen möchten, Sie müssen mit den Grundlagen der Funktionsweise von Pygame beginnen. In diesem Tutorial werden wir die Grundlagen von Pygame durch Erstellen eines Videospiels überprüfen.

Installieren Sie Pygame mit:

PIP Pygame installieren

Schritt 1: Erstellen des Anfangsfensters

Der erste Schritt beim Erstellen eines Videospiels ist die Initialisierung des Pygame mithilfe der Init () -Methode. Als nächstes setzen wir die Geometrie des Bildschirms mit Pygame.Anzeige.set_mode (), wo wir die Breite und die Höhe des Bildschirms übergeben (in dieser Reihenfolge). Diese beiden Codezeilen erstellen ein Fenster, das schnell verschwindet. Daher benötigen wir ein Hauptloop, um das Fenster laufen zu lassen. Innerhalb dieses Hauptloops werden wir eine Exit -Strategie hinzufügen. Die Exit -Strategie wird erstellt, indem ein Ereignis aus der Ereignisliste ausgewählt wird (diese Ereignisliste liegt in PyGame.Fall.Get (), der alle verfügbaren Veranstaltungen enthält). Als nächstes geben wir an, dass, wenn das von uns ausgewählte Ereignis Pygame ist.Beenden, dann beenden. Letzteres erstellt eine Hauptfrequenz für das Fenster, mit der das Fenster ausgeführt wird, bis Sie die Schaltfläche zur Beendigung der Beendigung drücken.

Pygame importieren
Importsystem
Pygame.drin()
Größe = Breite, Höhe = 800, 600
Bildschirm = Pygame.Anzeige.set_mode (Größe)
während wahr:
Für die Veranstaltung in Pygame.Fall.erhalten():
Wenn Ereignis.Typ == Pygame.AUFHÖREN:
sys.Ausfahrt()

Schritt 2: Hinzufügen von Titeln, Symbolen, Hintergrundfarben und Bildern

In diesem Abschnitt werden wir dem Fenster Titel, Hintergrundfarben und Bilder sowie Symbole hinzufügen.

(a) Der Titel wird hinzugefügt mit:

# Titel des Fensters setzen
Pygame.Anzeige.set_caption ("Videospiel")

(b) Ich habe mein Logo von https: // icons8 bekommen.com/icon/set/computerhardware/doodle. Wenn Sie Pycharm verwenden, platzieren Sie bitte das Symbol, das Sie im entsprechenden Ordner herunterladen.png). Das Logo wird hinzugefügt mit:

# Setzen Sie das Symbol
Bild = Pygame.Bild.Laden ("Symbol.png ")
Pygame.Anzeige.set_icon (Bild)

(c) Sie können auch die Hintergrundfarbe ändern. Dafür verwenden wir den Bildschirm.fill (), der eine RGB -Farbe nimmt. In meinem Fall habe ich es auf (0,0,0) gesetzt. Sobald Sie die Farbe festgelegt haben, müssen Sie auch den Pygame aktualisieren, damit die Farbänderung wirksam wird.

# Füllen Sie den Hintergrund aus
Bildschirm.füllen ((0, 0, 0))
Pygame.Anzeige.aktualisieren()

(d) Was ist, wenn Sie ein Hintergrundbild auf Ihrem Bildschirm festlegen möchten?? Das ist auch möglich. Da das Bild ständig ausgeführt werden soll, muss es innerhalb der WHOR -Schleife platziert werden. In der Tat muss alles, was ständig laufen muss. Wir verwenden Pygame.Bild.Load (), um ein Bild auszuwählen, das wir laden möchten, und die Blit () -Methode, um es zu platzieren. Hier, Bildschirm.Blit () nimmt zwei Argumente ein - das geladene Bild, das Tupel des Ortes, an dem die obere linke Ecke des Bildes platziert wird. Weitere Pygame.Anzeige.update () muss am Ende platziert werden, um den Bildschirm zu aktualisieren! Bei der Gestaltung von Videospielen ist die Reihenfolge, in der Sie den Code platzieren!!! Zum Beispiel kann das Update nicht vor den Bildern kommen!

# Erstellen Sie das Hintergrundbild
bg_image = pygame.Bild.load ("bg_image.JPG ")
Bildschirm.Blit (bg_image, (-15, -25))
Pygame.Anzeige.aktualisieren()

Alternativ können wir es auch in eine Hintergrundfunktion einleiten (die später nützlich sein wird), sodass wir den Hintergrund wie folgt umschreiben:

# Erstellen Sie das Hintergrundbild
bg_image = pygame.Bild.load ("bg_image_3.JPG ")
Def Hintergrund ():
Bildschirm.Blit (bg_image, (-15, -25))

Bitte beachten Sie, dass wir den Hintergrund in einer Funktion namens Hintergrund () platziert haben, die wir später in der WHOR -Schleife aktivieren werden.

Schritt 3: Hinzufügen von Bildern des Players in das Fenster

Lassen Sie uns als nächstes eine Person erstellen. Dies geschieht, indem zuerst das Bild geladen und dann der Bildschirm verwendet wird.Blit (), um das Bild zu platzieren.

# Person Bild
Image_person = PyGame.Bild.Laden ("Person.png ")
Bildschirm.Blit (Image_Person, (400, 550))

Bitte beachten Sie, dass die Bestellung, in der Sie den Code platzieren! Wenn Sie den Code für den Hintergrund nach dem Code für den Feind platzieren, sind weder die Person noch der Feind sichtbar!

Zum Zweck des gesamten Code werden wir ihn jedoch wieder in eine Funktion einsetzen. Der Code kann also wie folgt neu geschrieben werden:

# Person Bild
Person_x = 400
Person_y = 550
Image_person = PyGame.Bild.Ladung ("Mädchen.png ")
Def Person (x, y):
Bildschirm.Blit (Image_Person, (x, y))

Diese Funktion kann wie folgt in der while -Schleife aktiviert werden:

Person (Person_x, Person_Y)

Schritt 4: Move Person ()

Jetzt wird es schwierig, also achten Sie auf. Wir müssen Schlüssel drücken, um die Person nach rechts zu bewegen, damit wir sie wie folgt in die WHOR -Schleife eingeben:

gedrückt_keys = pygame.Taste.get_pression ()
Wenn gepresst.K_right]:
Person_x += 0.1
Wenn gepresst.K_LEFT]:
Person_x += -0.1

Wir verwenden Pygame.Taste.get_pressed (), um die gedrückte Taste zu erhalten. Wenn die gedrückte Taste die rechte Pfeiltaste ist (Pygame.K_right), dann wird unsere variable Person_x durch einen Wert von 0 erhöht.1. Wenn andererseits die gedrückte Taste der linke Pfeil ist (Pygame.K_left), dann verringern wir um 0.1. Was wir tun, ist die Änderung des Standorts des Bildes auf der Konsole. Wenn der rechte Pfeil gedrückt wird, wird das anfängliche Tupel von (400, 550) (400.1, 550) - und dies ist die Position des Bildes!

Wir müssen auch beide Funktionen aktivieren - Hintergrund () und Person (). Der Funktionshintergrund () löscht den Bildschirm jedes Mal, wenn die Schleife startet, und ohne ihn haben Sie einen "Drag".

Der Code als Ganzes an diesem Punkt würde so aussehen:

Pygame importieren
Importsystem
# initialisieren
Pygame.drin()
# Bildschirmgeometrie festlegen
Größe = Breite, Höhe = 800, 600
Bildschirm = Pygame.Anzeige.set_mode (Größe)
# Titel des Fensters setzen
Pygame.Anzeige.set_caption ("Videospiel")
# Setzen Sie das Symbol
Bild = Pygame.Bild.Laden ("Symbol.png ")
Pygame.Anzeige.set_icon (Bild)
# Erstellen Sie das Hintergrundbild
bg_image = pygame.Bild.load ("bg_image_3.JPG ")
Def Hintergrund ():
Bildschirm.Blit (bg_image, (-15, -25))
# Person Bild
Person_x = 400
Person_y = 550
Image_person = PyGame.Bild.Ladung ("Mädchen.png ")
Def Person (x, y):
Bildschirm.Blit (Image_Person, (x, y))
# Hauptschleife
während wahr:
Für die Veranstaltung in Pygame.Fall.erhalten():
Wenn Ereignis.Typ == Pygame.AUFHÖREN:
sys.Ausfahrt()
# Überprüfen Sie die gedrückten Schlüssel
gedrückt_keys = pygame.Taste.get_pression ()
# Wenn die gedrückte Taste der richtige Pfeil ist,
# Gehen Sie dann nach rechts
Wenn gepresst.K_right]:
Person_x += 0.1
# Wenn die gedrückte Taste der linke Pfeil ist,
# Gehen Sie dann nach links
Wenn gepresst.K_LEFT]:
Person_x += -0.1
# Aktivieren Sie die Hintergrundfunktion
Hintergrund()
# Aktivieren Sie die Personfunktion
Person (Person_x, Person_Y)
# alles aktualisieren
Pygame.Anzeige.aktualisieren()

Schritt 5: Grenzgrenzen festlegen

Wenn wir die rechte oder linke Pfeiltaste drücken, wird die Person (oder die Hauptfigur) in unserem Spiel im Moment auch außerhalb oder außerhalb des Konsolenfensters in Bewegung und Bewegen. Das nächste, was wir tun müssen, ist, die Bewegung Grenzen zu setzen.

Einstellungsgrenzen ist einfach. Wir gehen zu unseren Pressed_Keys [Pygame.K_right] Argument und fügen Sie eine Bedingung hinzu. Wir fügen die Bedingung hinzu, dass X geringer sein muss als unsere Bildschirmbreite - die Breite des Charakters.

In meinem Fall betrug die Breite des Charakters 50 Pixel und die X -Breite meines Bildschirms 800. Also stelle ich meine rechte Seite auf 800 - 50 = 750 Pixel. Was dies tut, ist die Bewegung meines Charakters zu begrenzen. Mein Charakter kann nicht über 750 Pixel hinausgehen und bleiben daher jederzeit auf dem Konsolenbildschirm.

gedrückt_keys = pygame.Taste.get_pression ()
# Wenn die gedrückte Taste der richtige Pfeil ist,
# Gehen Sie dann nach rechts
Wenn gepresst.K_right] und Person_x < 750:
Person_x += 0.1
# Wenn die gedrückte Taste der linke Pfeil ist,
# Gehen Sie dann nach links
Wenn gepresst.K_LEFT] und Person_x> 0:
Person_x += -0.1

Schritt 6: Erstellen des Feindes

Das Erstellen des Feindes ist der einfache Teil. Wir machen es auf die gleiche Weise, in der wir den Hauptcharakter erstellt haben. Hier möchten wir den Ort randomisieren, an dem der Feind erscheint, damit wir das zufällige Modul verwenden, um dies zu tun. Wir verwenden zufällig.Randint (), um einen zufälligen Ort festzulegen.

zufällig importieren
# Feindes Bild
fegey_x = random.Randint (0, 750)
fegeemy_y = random.Randint (0, 300)
Image_enemy = Pygame.Bild.Laden ("Feind.png ")
Def Feind (x, y):
Bildschirm.Blit (Image_enemy, (x, y))

Denken Sie daran, den Feind in der while -Schleife zu aktivieren:

# Aktivieren Sie den Feind
Feind (Enemy_x, Enemy_Y)

Schritt 7: Bewegen Sie den Feind

Das Bewegen des Feindes erfordert ein bisschen Vorstellungskraft. Wir initialisieren die Variablen (außerhalb der while -Schleife):

#Initialisieren Sie Variablen
fegeemy_diff = 0.6
fegey_x = 0

Und innerhalb der while Schleife schreiben wir:

# Bewegen Sie den Feind
fegeemy_x += fegeemy_diff
wenn fegey_x <= 0:
fegey_x = 0
fegeemy_diff = 0.6
Wenn Feind_x> = 730:
fegey_x = 730
fegeemy_diff = -0.6

Was dies tut, ist, dass, wenn das Bild des Feindes innerhalb von Grenzen liegt (in diesem Fall zwischen 0 und 730), die Gleichung Enemy_x = Enemy_x + Enemy_diff berechnet und sie bewegen wird. Wenn andererseits der Ort des Feindes größer als 730 ist, setzen wir den Ort Enemy_x auf 730 und kehren die Geschwindigkeit durch, indem wir -0 schreiben.6 statt 0.6. Wenn der Ort des Feindes weniger als 0 beträgt, setzen wir die Variable Ensemy_x auf 0 und sagen, dass sie um 0 vorwärts gehen sollen.6 Pixel. Da wir uns mit einer Weile zu beschäftigen, werden jedes Mal, wenn die Schleife von vorne beginnt. Am Ende wird dies alles tun, um den Feind für immer nach links und rechts zu bewegen.

Schritt 8: Erstellen und Schießen mehrerer Kugeln

In meinem Fall werde ich Bücher auf den Feuerball werfen. Meine Kugel ist also ein Buch oder mehrere Bücher. Lassen Sie uns zunächst alle Variablen initialisieren, die wir benötigen:

#Initialisieren Sie Variablen
books_diff = 4
books_y = 520
books_x = 420

Books_x und books_y sind ihr ursprünglicher Ort; Ich habe sie in der Nähe des Hauptcharakters platziert. Books_diff ist seine Geschwindigkeit. Als nächstes initialisieren wir seinen Zustand, der sich nicht bewegt, und laden das Bild.

# Bücher Bild
books_state = "nicht bewegend"
Image_Books = PyGame.Bild.Laden ("Bücher.png ")

Wir erstellen dann eine Funktion, die das books_state übernimmt. Wenn wir das Buch in das Netz platzieren, ändern wir seinen Zustand in „Bewegung“. Diese Funktion ist die Hauptfunktion, die die Kugel auf die Karte/Konsole platziert. Darüber hinaus habe ich in den Funktionsbüchern () x+15 und y+1 geschrieben, um das Bild zu zentrieren. Ohne das letztere schauen die Bücher von einer Seite ab.

Def Bücher (x, y):
global books_state
books_state = "bewegend"
Bildschirm.Blit (Image_Books, (x + 15, y + 1))

Und innerhalb der Hauptschleife würden Sie schreiben:

# Bücher Bewegung
Wenn books_y <= 0:
books_y = 420
books_state = "nicht bewegend"
Wenn Books_State "bewegt" ist:
books_x = person_x
books (books_x, books_y)
books_y -= books_diff
# Feuer, wenn der Space -Taste gedrückt wird
Wenn gepresst.K_space]:
books_x = person_x
books (books_x, books_y)

Wir definieren zuerst, was passiert, wenn sich die Kugel/Bücher vom Netz bewegen oder in Position Y sind<0. In this case, we change the state back to “not moving” and place the books back on the y-axis at 420. If, on the other hand, the state of the book is “moving”, we say that we want it to move (books_y -= books_diff where books_diff is its speed). Next, we also state that if the key is pressed, we want the books() function to be activated, placing the books' image onto the console grid.

Der Code als Ganzes würde an diesem Punkt ungefähr so ​​aussehen:

Pygame importieren
Importsystem
# initialisieren
Pygame.drin()
# Initialisieren Sie die Uhr
Uhr = Pygame.Zeit.Uhr()
# Bildschirmgeometrie festlegen
Größe = Breite, Höhe = 800, 600
Bildschirm = Pygame.Anzeige.set_mode (Größe)
# Titel des Fensters setzen
Pygame.Anzeige.set_caption ("Videospiel")
# Setzen Sie das Symbol
Bild = Pygame.Bild.Laden ("Symbol.png ")
Pygame.Anzeige.set_icon (Bild)
# Erstellen Sie das Hintergrundbild
bg_image = pygame.Bild.load ("bg_image_3.JPG ")
Def Hintergrund ():
Bildschirm.Blit (bg_image, (-15, -25))
# Person Bild
Person_x = 400
Person_y = 550
Image_person = PyGame.Bild.Ladung ("Mädchen.png ")
Def Person (x, y):
Bildschirm.Blit (Image_Person, (x, y))
zufällig importieren
# Feindes Bild
fegey_x = random.Randint (0, 750)
fegeemy_y = random.Randint (0, 300)
Image_enemy = Pygame.Bild.Laden ("Feind.png ")
Def Feind (x, y):
Bildschirm.Blit (Image_enemy, (x, y))
#Initialisieren Sie feindliche Variablen
fegeemy_diff = 0.6
fegey_x = 0
#Initialisieren Sie Variablen
books_diff = 4
books_y = 520
books_x = 420
# Bücher Bild
books_state = "nicht bewegend"
Image_Books = PyGame.Bild.Laden ("Bücher.png ")
Def Bücher (x, y):
global books_state
books_state = "bewegend"
Bildschirm.Blit (Image_Books, (x + 15, y + 1))
# Hauptschleife
während wahr:
Für die Veranstaltung in Pygame.Fall.erhalten():
Wenn Ereignis.Typ == Pygame.AUFHÖREN:
sys.Ausfahrt()
# Überprüfen Sie die gedrückten Schlüssel
gedrückt_keys = pygame.Taste.get_pression ()
# Wenn die gedrückte Taste der richtige Pfeil ist,
# Gehen Sie dann nach rechts
Wenn gepresst.K_right] und Person_x < 750:
Person_x += 0.8
# Wenn die gedrückte Taste der linke Pfeil ist,
# Gehen Sie dann nach links
Wenn gepresst.K_LEFT] und Person_x> 0:
Person_x += -0.8
# Aktivieren Sie die Hintergrundfunktion
Hintergrund()
# Aktivieren Sie die Personfunktion
Person (Person_x, Person_Y)
# Bewegen Sie den Feind
fegeemy_x += fegeemy_diff
wenn fegey_x <= 0:
fegey_x = 0
fegeemy_diff = 0.6
Wenn Feind_x> = 730:
fegey_x = 730
fegeemy_diff = -0.6
# Bücher Bewegung
Wenn books_y <= 0:
books_y = 420
books_state = "nicht bewegend"
Wenn Books_State "bewegt" ist:
books_x = person_x
books (books_x, books_y)
books_y -= books_diff
# Feuer, wenn der Space -Taste gedrückt wird
Wenn gepresst.K_space]:
books_x = person_x
books (books_x, books_y)
# Aktivieren Sie den Feind
Feind (Enemy_x, Enemy_Y)
# alles aktualisieren
Pygame.Anzeige.aktualisieren()
Uhr.Zecken (60)

Dieser Code schießt nacheinander mehrere Bücher, wenn die Space -Taste gedrückt wird.

Schritt 9: Kollisionserkennung

Der nächste Schritt besteht darin, eine Kollision zu erkennen, und dies scheint ziemlich einfach zu sein. Sie würden den Pygame verwenden.RECHT (x, y, Breite, Höhe), um ein Rechteck zu definieren. Verwenden Sie dann die Methode Colliderect (), um die Kollision zwischen zwei Rechtecken zu erkennen. Wir sagen auch, dass wir, wenn sie eine Kollision erkennt, die Punktzahl um 1 erhöht, den Feind erneut legt und die Kugel entfernen, indem wir sie zurücksetzen.

# Kollisionserkennung
fegeemy_rect = pygame.RECT (FEHNEMY_X, FEHMEMY_Y, 64, 64)
books_rect = pygame.Rect (books_x, books_y, 64, 64)
Wenn books_rect.colliderect (fegeemy_rect):
fegey_x = random.Randrange (0, 800)
fegeemy_y = random.Randrange (0, 300)
Punktzahl += 1
Bullet_State = "Nicht bewegend"
Feind (Enemy_x, Enemy_Y)
books_y = 0

Schritt 10: Text anzeigen

Außerhalb des Hauptloops würden Sie schreiben:

Punktzahl = 0
#initialisieren Sie Schriftart
Pygame.Schriftart.drin()
myfont = pygame.Schriftart.Sysfont ('Comic sans ms', 50)
Def text_score (x, y):
text_score = myfont.Render ('Punktzahl:'+ str (Punktzahl), true, (0, 0, 0))
Bildschirm.Blit (text_score, (x, y))

In der Hauptschleife würden Sie schreiben:

# Textbewertung aktivieren
text_score (6, 6)

Hier müssen Schriftarten initialisiert werden. Initialisieren Sie es daher mit Pygame.Schriftart.drin(). Dann wählen Sie Ihre Schrift mit Pygame aus.Schriftart.Sysfont (), wo Sie die Schriftart und die Größe bestehen. Lassen Sie uns als nächstes eine Funktion definieren, bei der wir die Render -Methode verwenden, um sie zu rendern. Da die Punktzahl eine Ganzzahl ist, verwenden wir Str (Score). Und dann legen wir sie mit der Blit () -Methode auf den Bildschirm.

Zu diesem Zeitpunkt würde der gesamte Code so aussehen:

Pygame importieren
Importsystem
# initialisieren
Pygame.drin()
# Initialisieren Sie die Uhr
Uhr = Pygame.Zeit.Uhr()
# Bildschirmgeometrie festlegen
Größe = Breite, Höhe = 800, 600
Bildschirm = Pygame.Anzeige.set_mode (Größe)
# Titel des Fensters setzen
Pygame.Anzeige.set_caption ("Videospiel")
# Setzen Sie das Symbol
Bild = Pygame.Bild.Laden ("Symbol.png ")
Pygame.Anzeige.set_icon (Bild)
# Erstellen Sie das Hintergrundbild
bg_image = pygame.Bild.load ("bg_image_3.JPG ")
Def Hintergrund ():
Bildschirm.Blit (bg_image, (-15, -25))
# Person Bild
Person_x = 400
Person_y = 550
Image_person = PyGame.Bild.Ladung ("Mädchen.png ")
Def Person (x, y):
Bildschirm.Blit (Image_Person, (x, y))
zufällig importieren
# Feindes Bild
fegey_x = random.Randint (0, 750)
fegeemy_y = random.Randint (0, 300)
Image_enemy = Pygame.Bild.Laden ("Feind.png ")
Def Feind (x, y):
Bildschirm.Blit (Image_enemy, (x, y))
#Initialisieren Sie feindliche Variablen
fegeemy_diff = 0.6
fegey_x = 0
#Initialisieren Sie Variablen
books_diff = 4
books_y = 520
books_x = 420
# Bücher Bild
books_state = "nicht bewegend"
Image_Books = PyGame.Bild.Laden ("Bücher.png ")
Def Bücher (x, y):
global books_state
books_state = "bewegend"
Bildschirm.Blit (Image_Books, (x + 15, y + 1))
Punktzahl = 0
#initialisieren Sie Schriftart
Pygame.Schriftart.drin()
myfont = pygame.Schriftart.Sysfont ('Comic sans ms', 50)
Def text_score (x, y):
text_score = myfont.Render ('Punktzahl:'+ str (Punktzahl), true, (0, 0, 0))
Bildschirm.Blit (text_score, (x, y))
# Hauptschleife
während wahr:
Für die Veranstaltung in Pygame.Fall.erhalten():
Wenn Ereignis.Typ == Pygame.AUFHÖREN:
sys.Ausfahrt()
# Überprüfen Sie die gedrückten Schlüssel
gedrückt_keys = pygame.Taste.get_pression ()
# Wenn die gedrückte Taste der richtige Pfeil ist,
# Gehen Sie dann nach rechts
Wenn gepresst.K_right] und Person_x < 750:
Person_x += 0.8
# Wenn die gedrückte Taste der linke Pfeil ist,
# Gehen Sie dann nach links
Wenn gepresst.K_LEFT] und Person_x> 0:
Person_x += -0.8
# Aktivieren Sie die Hintergrundfunktion
Hintergrund()
# Aktivieren Sie die Personfunktion
Person (Person_x, Person_Y)
# Bewegen Sie den Feind
fegeemy_x += fegeemy_diff
wenn fegey_x <= 0:
fegey_x = 0
fegeemy_diff = 0.6
Wenn Feind_x> = 730:
fegey_x = 730
fegeemy_diff = -0.6
# Bücher Bewegung
Wenn books_y <= 0:
books_y = 420
books_state = "nicht bewegend"
Wenn Books_State "bewegt" ist:
books_x = person_x
books (books_x, books_y)
books_y -= books_diff
# Feuer, wenn der Space -Taste gedrückt wird
Wenn gepresst.K_space]:
books_x = person_x
books (books_x, books_y)
# Aktivieren Sie den Feind
Feind (Enemy_x, Enemy_Y)
# Kollisionserkennung
fegeemy_rect = pygame.RECT (FEHNEMY_X, FEHMEMY_Y, 64, 64)
books_rect = pygame.Rect (books_x, books_y, 64, 64)
Wenn books_rect.colliderect (fegeemy_rect):
fegey_x = random.Randrange (0, 800)
fegeemy_y = random.Randrange (0, 300)
Punktzahl += 1
Bullet_State = "Nicht bewegend"
Feind (Enemy_x, Enemy_Y)
books_y = 0
# Textbewertung aktivieren
text_score (6, 6)
# alles aktualisieren
Pygame.Anzeige.aktualisieren()
Uhr.Zecken (60)

Schritt 11: Hinzufügen von Geräuschen

Das Hinzufügen von Sounds ist super duper einfach!

Außerhalb der Hauptschleife würden Sie schreiben:

# Sounds initialisieren
Pygame.Rührgerät.drin()
Pygame.Rührgerät.Musik.Laden ("Gun-Cocking-01.WAV ")

Innerhalb des Hauptloops werde ich den Sound aktivieren, wenn es eine Kollision gibt! Hier verwenden wir Pygame.Rührgerät.Musik.spielen().

# Kollisionserkennung
fegeemy_rect = pygame.RECT (FEHNEMY_X, FEHMEMY_Y, 64, 64)
books_rect = pygame.Rect (books_x, books_y, 64, 64)
Wenn books_rect.colliderect (fegeemy_rect):
fegey_x = random.Randrange (0, 800)
fegeemy_y = random.Randrange (0, 300)
Punktzahl += 1
Bullet_State = "Nicht bewegend"
Feind (Enemy_x, Enemy_Y)
books_y = 0
Pygame.Rührgerät.Musik.spielen()

Schritt 12: Beenden Sie das Spiel

Ich werde dieses Spiel auf einen Sieg setzen, wenn die Punktzahl größer als 5 ist. Außerhalb der Hauptschleife schreiben wir den folgenden Code:

text_game_over = pygame.Schriftart.Sysfont ('Comic sans ms', 80)
# Spiel über Funktion
Def Game_over (x, y):
text_game_over_2 = myfont.render ('du gewonnen', wahr, (0, 0, 0))
Bildschirm.Blit (text_game_over_2, (x, y))

Und innerhalb der Hauptschleife würden Sie schreiben:

# Überprüfen Sie den Sieg
Wenn Punktzahl> 5:
Game_over (400, 300)
Pygame.Anzeige.Flip ()
Zeit.Schlaf (5)
brechen
# Textbewertung aktivieren
text_score (6, 6)
Timer (500, 6)

Dies bedeutet, dass der Bildschirm aktualisiert wird, wenn die Punktzahl größer als 5 ist, die Funktion Game_over () aktiviert wird, und dann sagen wir, vor dem Aufhören ein wenig zu schlafen.

Der gesamte Code würde so aussehen:

Pygame importieren
Importsystem
Importzeit
# initialisieren
Pygame.drin()
# Initialisieren Sie die Uhr
Uhr = Pygame.Zeit.Uhr()
# Bildschirmgeometrie festlegen
Größe = Breite, Höhe = 800, 600
Bildschirm = Pygame.Anzeige.set_mode (Größe)
# Titel des Fensters setzen
Pygame.Anzeige.set_caption ("Videospiel")
# Setzen Sie das Symbol
Bild = Pygame.Bild.Laden ("Symbol.png ")
Pygame.Anzeige.set_icon (Bild)
# Erstellen Sie das Hintergrundbild
bg_image = pygame.Bild.load ("bg_image_3.JPG ")
Def Hintergrund ():
Bildschirm.Blit (bg_image, (-15, -25))
# Person Bild
Person_x = 400
Person_y = 550
Image_person = PyGame.Bild.Ladung ("Mädchen.png ")
Def Person (x, y):
Bildschirm.Blit (Image_Person, (x, y))
zufällig importieren
# Feindes Bild
fegey_x = random.Randint (0, 750)
fegeemy_y = random.Randint (0, 300)
Image_enemy = Pygame.Bild.Laden ("Feind.png ")
Def Feind (x, y):
Bildschirm.Blit (Image_enemy, (x, y))
#Initialisieren Sie feindliche Variablen
fegeemy_diff = 0.6
fegey_x = 0
#Initialisieren Sie Variablen
books_diff = 4
books_y = 520
books_x = 420
# Bücher Bild
books_state = "nicht bewegend"
Image_Books = PyGame.Bild.Laden ("Bücher.png ")
Def Bücher (x, y):
global books_state
books_state = "bewegend"
Bildschirm.Blit (Image_Books, (x + 15, y + 1))
Punktzahl = 0
#initialisieren Sie Schriftart
Pygame.Schriftart.drin()
myfont = pygame.Schriftart.Sysfont ('Comic sans ms', 50)
Def text_score (x, y):
text_score = myfont.Render ('Punktzahl:'+ str (Punktzahl), true, (0, 0, 0))
Bildschirm.Blit (text_score, (x, y))
# Sounds initialisieren
Pygame.Rührgerät.drin()
Pygame.Rührgerät.Musik.Laden ("Gun-Cocking-01.WAV ")
text_game_over = pygame.Schriftart.Sysfont ('Comic sans ms', 80)
# Spiel über Funktion
Def Game_over (x, y):
text_game_over_2 = myfont.render ('du gewonnen', wahr, (0, 0, 0))
Bildschirm.Blit (text_game_over_2, (x, y))
Def Timer (x, y):
text_timer = myfont.Render ('Zeit:'+ str (Pygame.Zeit.get_ticks ()), true, (0, 0, 0))
Bildschirm.Blit (text_timer, (x, y))
# Hauptschleife
während wahr:
Für die Veranstaltung in Pygame.Fall.erhalten():
Wenn Ereignis.Typ == Pygame.AUFHÖREN:
sys.Ausfahrt()
# Überprüfen Sie die gedrückten Schlüssel
gedrückt_keys = pygame.Taste.get_pression ()
# Wenn die gedrückte Taste der richtige Pfeil ist,
# Gehen Sie dann nach rechts
Wenn gepresst.K_right] und Person_x < 750:
Person_x += 0.8
# Wenn die gedrückte Taste der linke Pfeil ist,
# Gehen Sie dann nach links
Wenn gepresst.K_LEFT] und Person_x> 0:
Person_x += -0.8
# Aktivieren Sie die Hintergrundfunktion
Hintergrund()
# Aktivieren Sie die Personfunktion
Person (Person_x, Person_Y)
# Bewegen Sie den Feind
fegeemy_x += fegeemy_diff
wenn fegey_x <= 0:
fegey_x = 0
fegeemy_diff = 0.6
Wenn Feind_x> = 730:
fegey_x = 730
fegeemy_diff = -0.6
# Bücher Bewegung
Wenn books_y <= 0:
books_y = 420
books_state = "nicht bewegend"
Wenn Books_State "bewegt" ist:
books_x = person_x
books (books_x, books_y)
books_y -= books_diff
# Feuer, wenn der Space -Taste gedrückt wird
Wenn gepresst.K_space]:
books_x = person_x
books (books_x, books_y)
# Aktivieren Sie den Feind
Feind (Enemy_x, Enemy_Y)
# Kollisionserkennung
fegeemy_rect = pygame.RECT (FEHNEMY_X, FEHMEMY_Y, 64, 64)
books_rect = pygame.Rect (books_x, books_y, 64, 64)
Wenn books_rect.colliderect (fegeemy_rect):
fegey_x = random.Randrange (0, 800)
fegeemy_y = random.Randrange (0, 300)
Punktzahl += 1
Bullet_State = "Nicht bewegend"
Feind (Enemy_x, Enemy_Y)
books_y = 0
Pygame.Rührgerät.Musik.spielen()
# Überprüfen Sie den Sieg
Wenn Punktzahl> 5:
Game_over (400, 300)
Pygame.Anzeige.Flip ()
Zeit.Schlaf (5)
brechen
# Textbewertung aktivieren
text_score (6, 6)
Timer (500, 6)
# alles aktualisieren
Pygame.Anzeige.aktualisieren()
Uhr.Zecken (60)

Dies ist natürlich das einfachste aller Spiele, die Sie möglicherweise erstellen können! Es ist jedoch ein Start für diejenigen, die Pygame lernen und bessere Videospiele entwerfen möchten.

Happy Gaming!