Zephyrnet-Logo

Generative Datenintelligenz

Big Data

Erstellen Sie Ihr erstes Spiel mit Python: Snake Game

Neuauflage von Plato
Neuauflage von Plato

Datum:

Views: 97

Python macht Spaß und ist einfach zu bedienen. Mit einer großen Auswahl an verfügbaren Bibliotheken, Python macht unser Leben einfacher, indem es die Erstellung von Spielen und Anwendungen vereinfacht. In diesem Artikel erstellen wir ein klassisches Spiel, das viele von uns wahrscheinlich schon einmal in ihrem Leben gespielt haben – das Schlangenspiel. Wenn Sie dieses Spiel noch nicht kennen, haben Sie jetzt die Chance, Ihre ganz eigene Version zu erkunden und zu erstellen, ohne umfangreiche Bibliotheken auf Ihrem System installieren zu müssen. Alles, was Sie brauchen, um mit der Erstellung dieses nostalgischen Schlangenspiels zu beginnen, sind grundlegende Kenntnisse von Python und ein Online-Programmiereditor wie repl.it.

Das Schlangenspiel ist ein zeitloser Arcade-Klassiker, bei dem der Spieler eine Schlange steuert, die durch die Nahrungsaufnahme immer länger wird. Lassen Sie uns in dieser Implementierung den Code aufschlüsseln, um zu verstehen, wie das Spiel strukturiert ist und wie die Turtle-Bibliothek für Grafiken und Benutzerinteraktion verwendet wird.

Inhaltsverzeichnis

Verwendung von Turtle Graphics für die einfache Spieleentwicklung

Die Turtle-Grafiken Bibliothek in Python bietet eine unterhaltsame und interaktive Möglichkeit, Formen zu erstellen, auf dem Bildschirm zu zeichnen und auf Benutzereingaben zu reagieren. Es wird häufig zu Bildungszwecken verwendet, um Programmierkonzepte durch visuelles Feedback zu vermitteln. Dieser Code verwendet Turtle, um die Spielelemente wie die Schlange, das Essen und die Punkteanzeige zu erstellen.

Online-Coding-Editor: Repl.it

Mit einer Web-Coding-Plattform namens Repl.it können Sie Code direkt in Ihrem Webbrowser entwickeln, ausführen und gemeinsam daran arbeiten. Es unterstützt viele verschiedene Programmiersprachen und verfügt über integrierte Compiler und Interpreter sowie Funktionen wie Code-Sharing, Versionskontrolle und Teamarbeit. Entwickler nutzen es häufig zum Lernen, zum schnellen Prototyping und zum Teilen von Code, da es einfach zu verwenden ist und keine Einrichtung erfordert.

Algorithmus

Beginnen wir mit der Entwicklung unseres ersten Spiels mit Python. Dazu müssen wir die folgenden Schritte ausführen:

Erstellen Sie eine Repl-Datei

Schritt 1: Installieren der erforderlichen Bibliotheken

Dies ist der erste Schritt bei der Entwicklung des Spiels Snake. Dazu gehören Turtle, Random und Time.

  • Schildkröte: Wir benötigen diese Bibliothek, um die Grafiken in unserem Spiel zu erstellen. Wir sind in der Lage, die Bewegungen des Futters und der Schlange auf dem Bildschirm zu manipulieren und zu zeichnen.
  • Zufällig: Um zufällige Orte für das Essen auf dem Bildschirm zu erstellen, nutzen wir die Zufallsbibliothek. Dadurch wird sichergestellt, dass das Essen jedes Mal, wenn es gegessen wird, an einer anderen Stelle erscheint.
  • Uhrzeit: Dank der Zeitbibliothek bewegt sich die Schlange mit einer leichten Verzögerung zwischen den einzelnen Bewegungen. Dies macht das Spiel einfacher zu bedienen und macht den Spielern mehr Spaß.
import turtle
import time
import random

Schritt 2: Einrichten der Spielumgebung.

Dazu gehört die Festlegung der Bildschirmabmessungen, das Hinzufügen eines blauen Hintergrunds und das Hinzufügen einer kleinen Verzögerung, um ein flüssiges Gameplay zu gewährleisten. Wir richten außerdem Variablen wie „high_score“ ein, um die höchste erreichte Punktzahl zu speichern, „score“, um die Punktzahl des Spielers zu überwachen, und „Segmente“, um den Körper der Schlange zu verfolgen.

# Initialize the screen
sc = turtle.Screen()
sc.bgcolor("blue")
sc.setup(height=1000, width=1000)
delay = 0.1

# Initialize variables
segments = []
score = 0
high_score = 0
Output

Schritt 3: Erstellen der Schlange

Ein Schildkrötenobjekt mit quadratischer Form symbolisiert die Schlange. Wir platzieren den Stift in der Mitte des Bildschirms (goto(0, 100)), stellen seine Farbe auf Schwarz ein und heben ihn dann an, um das Zeichnen von Linien zu vermeiden. Ursprünglich auf „Stop“ eingestellt, bleibt die Richtung der Schlange unverändert, bis der Spieler beginnt, sie zu bewegen.

# Create the snake
snake = turtle.Turtle()
snake.shape("square")
snake.color("black")
snake.penup()
snake.goto(0, 100)
snake.direction = "stop"
Schlange erschaffen

Schritt 4: Bewegungsfunktionen

Wir definieren die Bewegungsfunktionen der Schlange (move()) entsprechend ihrer Richtung in diesem Moment. Diese Funktionen steuern die Fähigkeit der Schlange, sich nach oben, unten, links und rechts zu bewegen. Auf Aufforderung bewegen sie den Kopf der Schlange um 20 Einheiten in die entsprechende Richtung.

# Functions to move the snake
def move():
    if snake.direction == "up":
        y = snake.ycor()
        snake.sety(y + 20)
    if snake.direction == "down":
        y = snake.ycor()
        snake.sety(y - 20)
    if snake.direction == "left":
        x = snake.xcor()
        snake.setx(x - 20)
    if snake.direction == "right":
        x = snake.xcor()
        snake.setx(x + 20)

Schritt 5: Kontrolle der Schlange

Mit sc.listen() und sc.onkey() konfigurieren wir Schlüssel-Listener zur Steuerung der Schlange. Die zugehörigen Routinen (go_up(), go_down(), go_left(), go_right()) ändern die Richtung der Schlange als Reaktion auf Tastendrücke auf der Tastatur w, s, a oder d.

# Functions to link with the keys
def go_up():
    snake.direction = "up"

def go_down():
    snake.direction = "down"

def go_left():
    snake.direction = "left"

def go_right():
    snake.direction = "right"

# Listen for key inputs
sc.listen()
sc.onkey(go_up, "w")
sc.onkey(go_down, "s")
sc.onkey(go_left, "a")
sc.onkey(go_right, "d")

Schritt 6: Das Essen zubereiten

Das Futter wird durch ein kreisförmiges Schildkrötenobjekt mit roter Farbe dargestellt. Zunächst an den Koordinaten (100, 100) platziert, dient es der Schlange als Ziel zum Fressen. Wenn die Schlange mit dem Futter kollidiert, „frisst“ sie das Futter und an einer zufälligen Stelle erscheint ein neues.

# Create the food
food = turtle.Turtle()
food.shape("circle")
food.color("red")
food.penup()
food.goto(100, 100)
Das Essen kreieren

Schritt 7: Ergebnis anzeigen

Ein Schildkrötenobjekt (Stift) zeigt die Punktzahl des Spielers und die höchste erreichte Punktzahl an. Diese Informationen werden jedes Mal aktualisiert, wenn die Schlange das Futter frisst.

# Create the score display
pen = turtle.Turtle()
pen.penup()
pen.goto(0, 100)
pen.hideturtle()
pen.write("Score: 0  High Score: 0", align="center", font=("Arial", 30, "normal")
Punktestand anzeigen

Schritt 8: Hauptspielschleife

Der Kern des Snake-Spiels ist die primäre Spielschleife. Es verwaltet Benutzereingaben, aktualisiert den Bildschirm, bewegt die Schlange, sucht nach Kollisionen und regelt den Spielablauf. Lassen Sie uns die spezifischen Funktionen jedes Abschnitts der Hauptschleife genauer untersuchen:

while True:
    sc.update()  # Update the screen
    move()  # Move the snake
    time.sleep(delay)  # Introduce a slight delay for smooth gameplay
  • sc.update(): Aktualisiert den Bildschirm, um alle im Spiel vorgenommenen Änderungen anzuzeigen. Ohne dies würde der Bildschirm nicht aktualisiert werden und die Spieler würden weder die Schlangenbewegung noch die Punkteaktualisierung sehen.
  • move(): Diese Funktion steuert die Bewegung der Schlange basierend auf ihrer aktuellen Richtung. Es bewegt den Kopf der Schlange um 20 Einheiten in die durch die Eingabe des Spielers vorgegebene Richtung. Die Schlange bewegt sich kontinuierlich in die Richtung, in die sie zuletzt gelenkt wurde, bis der Spieler ihre Richtung ändert.
  • time.sleep(delay): führt eine leichte Verzögerung zwischen jeder Bewegung der Schlange ein. Der delay Variable ist auf gesetzt 0.1 am Anfang des Codes. Der Zweck dieser Verzögerung besteht darin, die Geschwindigkeit des Spiels zu steuern. Ohne sie würde sich die Schlange zu schnell bewegen, als dass der Spieler reagieren könnte, was das Spiel schwierig machen würde.

Essen und die Schlange züchten

    if snake.distance(food) < 20:
        x = random.randint(-200, 200)
        y = random.randint(-200, 200)
        food.penup()
        food.goto(x, y)
        food.pendown()

        # Increase the length of the snake
        new_segment = turtle.Turtle()
        new_segment.shape("square")
        new_segment.color("grey")
        new_segment.penup()
        segments.append(new_segment)
        score += 1

        # Update score and high score
        if score > high_score:
            high_score = score
        pen.clear()
        pen.write("Score: {}  High Score: {}".format(score, high_score), align="center", font=("Arial", 30, "normal"))

Essen essen

  • Wenn der Kopf der Schlange (snake) kommt in einem Abstand von 20 Einheiten zum Lebensmittel (food), bedeutet dies, dass die Schlange das Futter „gefressen“ hat.
  • Die Position des Lebensmittels wird dann mithilfe von auf eine neue zufällige Position auf dem Bildschirm zurückgesetzt random.randint().
  • Diese Aktion erzeugt die Illusion, dass das Essen jedes Mal, wenn es gegessen wird, an einer anderen Stelle „wieder auftaucht“.

Den Schlangenkörper wachsen lassen

  • Wenn die Schlange die Nahrung frisst, fügt der Code dem Körper der Schlange ein neues Segment hinzu, damit sie wächst.
  • Ein neues Schildkrötenobjekt (new_segment) wird erstellt, das Teil des wird segments Liste.
  • Diese Liste verfolgt alle Segmente, aus denen der Körper der Schlange besteht.
  • Die Punktzahl des Spielers wird erhöht (score += 1) jedes Mal, wenn die Schlange Nahrung frisst.

Punkteaktualisierung

  • Nach dem Essen und Aktualisieren des Punktestands wird die Punkteanzeige mithilfe des aktualisiert pen Objekt.
  • Das pen.clear() Die Funktion löscht die vorherige Punkteanzeige.
  • Anschließend werden die aktualisierte Punktzahl und der Highscore mit auf den Bildschirm geschrieben pen.write().

Den Körper der Schlange bewegen

    for i in range(len(segments) - 1, 0, -1):
        x = segments[i - 1].xcor()
        y = segments[i - 1].ycor()
        segments[i].goto(x, y)

    # Move the first segment to follow the head
    if len(segments) > 0:
        x = snake.xcor()
        y = snake.ycor()
        segments[0].goto(x, y)
  • Dieser Codeabschnitt ist dafür verantwortlich, dass der Körper der Schlange ihrem Kopf folgt.
  • Es iteriert durch die segments Liste, beginnend mit dem letzten Segment (len(segments) - 1) bis zum zweiten Segment (0) und verschiebt jedes Segment an die Position des davor liegenden Segments.
  • Dadurch entsteht der Effekt, dass der Körper der Schlange dem Kopf folgt, während er sich bewegt.

Aktualisieren des ersten Segments (Kopf)

  • Nachdem alle Körpersegmente verschoben wurden, wird die Position des ersten Segments (des Kopfes) aktualisiert, um sie an die aktuelle Position der Schlange anzupassen (snake).
  • Dadurch wird sichergestellt, dass der Kopf der Schlange den Körper bei seinen Bewegungen weiterhin führt.

Endnote

Dieser Code stellt eine Grundstruktur für ein Snake-Spiel unter Verwendung der Turtle-Grafikbibliothek bereit. Im Spiel geht es darum, eine Schlange so zu steuern, dass sie Nahrung frisst und länger wird, während Kollisionen mit Wänden und ihrem eigenen Schwanz vermieden werden. Es ist ein großartiges Einsteigerprojekt, um etwas über Spielentwicklungskonzepte, grundlegende Python-Programmierung und die Arbeit mit Benutzereingaben und Grafiken zu lernen. Fühlen Sie sich frei, diesen Code anzupassen und zu erweitern, um Funktionen wie Kollisionserkennung, Erhöhung des Schwierigkeitsgrads oder das Hinzufügen von Levels hinzuzufügen, um Ihr Snake-Spiel noch spannender zu machen!

Wenn Sie mehr über Python erfahren möchten, melden Sie sich bei uns an kostenloser Python-Kurs.

Lesen Sie hier auch unsere weiteren Artikel zum Thema Python:

Podcast: Spielen Sie im neuen Fenster | Herunterladen

spot_img

Neueste Intelligenz

spot_img

Copyright @ 2024 Plato Technologies Inc.