Wenn Sie gerne ein Schlangenspiel spielen, wird dieser Artikel sicher interessant für Sie sein.

In diesem Artikel zeige ich Ihnen, wie Sie ein einfaches Schlangenspiel erstellen können, das selbst für Python-Anfänger leicht zu entwickeln ist.

Es gibt mehrere Möglichkeiten, dieses Spiel zu erstellen. Eine davon ist die Verwendung der PyGame-Bibliothek von Python, einer Python-Bibliothek, die wir zur Erstellung von Spielen verwenden.

Die andere Möglichkeit ist die Verwendung der Turtle-Bibliothek. Dieses Modul ist bei Python vorinstalliert und bietet eine virtuelle Leinwand, auf der Sie Formen und Bilder erstellen können.

Daher werden wir in diesem Artikel die Turtle-Bibliothek verwenden, um unser einfaches Schlangenspiel zu implementieren, das besonders für Python-Neulinge sehr anfängerfreundlich ist.

Zusätzlich zu diesem Modul werden wir noch zwei weitere Module verwenden, nämlich

  • Time-Modul – Diese Methode ermöglicht es uns, die Anzahl der Sekunden zu verfolgen, die seit der letzten Zeit verstrichen sind.
  • Random-Modul – Es generiert Zahlen in Python nach dem Zufallsprinzip.

Zu den weiteren grundlegenden Tools, die Sie benötigen, gehört ein Texteditor Ihrer Wahl. Ich werde in diesem Artikel VSCode verwenden. Natürlich müssen Sie Python 3 auf Ihrem Rechner installieren, wenn Sie es nicht bereits haben. Sie können auch den Geekflare Compiler verwenden.

Das kann ja heiter werden!

Wie das Schlangenspiel funktioniert

Das Ziel dieses Spiels ist es, dass der Spieler die höchste Punktzahl erreicht, indem er die Schlange steuert, um das auf dem Bildschirm angezeigte Futter einzusammeln.

Der Spieler steuert die Schlange mit vier Richtungstasten, die sich auf die Richtung beziehen, in die sich die Schlange bewegt. Sollte die Schlange einen Block oder sich selbst treffen, verliert der Spieler das Spiel.

Die folgenden Schritte werden wir befolgen, um dieses Spiel zu implementieren.

  • Importieren der vorinstallierten Module (Turtle, Time und Random) in unsere Programme.
  • Erstellen der Bildschirmanzeige des Spiels mit Hilfe des Schildkrötenmoduls.
  • Festlegen der Tasten für die Bewegungsrichtung der Schlange auf dem Bildschirm.
  • Die Implementierung des Spielablaufs.

Erstellen Sie eine Datei snakegame.py, in die wir den Implementierungscode einfügen werden.

Importieren der Module

In diesem Teil des Codes importieren wir die Module turtle, time und random, die standardmäßig in Python vorinstalliert sind. Darüber hinaus werden wir Standardwerte für die anfängliche Punktzahl des Spielers, die höchste Punktzahl, die der Spieler erreichen kann, und die Zeit, die der Spieler bei jedem Zug benötigt, festlegen. Zur Berechnung der Verzögerungszeit wird hier das Modul time verwendet.

Fügen Sie den folgenden Code in Ihre Datei snakegame.py ein.

importieren Sie Schildkröte
importieren Sie random
importiere Zeit

spieler_punktzahl = 0
höchste_punktzahl = 0
verzögerung_zeit = 0.1

Erstellen der Bildschirmanzeige des Spiels

Mit dem Turtle-Modul, das wir hier importieren, können wir eine virtuelle Leinwand erstellen, die den Bildschirm des Spiels darstellen wird. Von hier aus können wir den Körper der Schlange und die Nahrung, die die Schlange sammelt, erstellen. Unser Bildschirm wird auch den Punktestand des Spielers anzeigen.

Fügen Sie diesen Code in die Python-Datei ein.

# Fensterbildschirm erstellt
wind = turtle.Screen()
wind.title("Schlangenlabyrinth🐍")
wind.bgcolor("rot")

# Die Bildschirmgröße
wind.setup(width=600, height=600)


# Erstellen der Schlange 
snake = turtle.Turtle()
snake.shape("Quadrat")
snake.color("schwarz")
snake.penup()
snake.goto(0, 0)
snake.direction = "Stopp"

# Erzeugen des Futters
schlange_futter = schildkröte.schildkröte()
shapes = random.choice('Dreieck','Kreis')
snake_food.shape(shapes)
snake_food.color("blau")
snake_food.speed(0)
snake_food.penup()
snake_food.goto(0, 100)

stift = schildkröte.schildkröte()
pen.speed(0)
pen.shape('Quadrat')
pen.color('weiß')
pen.penup()
pen.hideturtle()
pen.goto(0, 250)
pen.write("Ihr_Score: 0 Höchster_Score : 0", align="center", 
font=("Arial", 24, "normal"))
turtle.mainloop()

Das obige Codeschnipsel beginnt mit der Initialisierung des Schildkrötenbildschirms und übergibt einen Titel und eine Hintergrundfarbe an den Bildschirm. Nachdem wir die Fenstergröße unseres Bildschirms festgelegt haben, zeichnen wir die Form der Schlange auf die virtuelle Leinwand.

Die Methode penup() nimmt einfach den Stift der Schildkröte auf, damit keine Linie gezeichnet wird, wenn sich die Schildkröte bewegt. Die Methode goto(x,y) enthält Koordinatenpositionen, die die Schildkröte an eine absolute Position bringen.

Anschließend erstellen wir das Futter, das die Schlange sammelt. Wir möchten jedes Mal, wenn die Schlange das Futter einsammelt, den Punktestand des Spielers anzeigen und die höchste Punktzahl, die der Spieler während des Spiels erreicht. Daher verwenden wir die Methode pen.write(), um dies zu implementieren. Die Methode hideturtle() blendet das Schildkrötensymbol in der Kopfzeile, in der dieser Text geschrieben wird, aus dem Bildschirm aus.

Es ist wichtig, dass Sie am Ende Ihres Codes die turtle.mainloop() einfügen, die den Bildschirm länger anzeigt, damit Sie als Benutzer etwas auf dem Bildschirm tun können.

Führen Sie die Datei aus und Sie sollten die folgende Ausgabe erhalten:

The snake and food display with the player's initial and highest score.

Einrichten der Richtungstasten für die Schlange

Hier werden wir bestimmte Tasten einrichten, die die Richtung vorgeben, in die sich die Schlange auf dem Bildschirm bewegen wird. Wir werden die Tasten ‘L’ für links, ‘R’ für rechts, ‘U’ für oben und ‘D’ für unten verwenden. Wir werden diese Richtungen mit Hilfe der Richtungsfunktion der Schildkröte implementieren, die wir bei der Schlange aufrufen.

Fügen Sie den folgenden Codeschnipsel in Ihren Code ein.

# Richtungen zuweisen
def moveleft():
    if schlange.richtung != "rechts":
        schlange.richtung = "links"

def moveright():
    if snake.direction != "links":
        schlange.richtung = "rechts"

def moveup():
    if snake.direction != "unten":
        schlange.richtung = "auf"

def moveown():
    if snake.direction != "up":
        schlange.richtung = "abwärts"

def bewegt():
    if snake.direction == "up":
        coord_y = snake.ycor()
        snake.sety(coord_y 20)

    if snake.direction == "unten":
        coord_y = snake.ycor()
        snake.sety(coord_y-20)

    wenn schlange.richtung == "rechts":
        coord_x = snake.xcor()
        snake.setx(coord_x 20)

    if snake.direction == "links":
        coord_x = snake.xcor()
        snake.setx(coord_x-20)

wind.listen()
wind.onkeypress(moveleft, 'L')
wind.onkeypress(moveright, 'R')
wind.onkeypress(moveup, 'U')
wind.onkeypress(movedown, 'D')

Die obige Funktion move() legt die Bewegung der Schlange in der definierten Position innerhalb eines genauen Koordinatenwertes fest.

Die Funktion listen() ist ein Ereignislistener, der die Methoden aufruft, die die Schlange in eine bestimmte Richtung bewegen, wenn der Spieler die Taste drückt.

Die Implementierung des Schlangenspiels

Nachdem wir die Grundvoraussetzungen für unser Schlangenspiel geschaffen haben, müssen wir das Spiel in Echtzeit ablaufen lassen.

Dazu gehört Folgendes:

  • Jedes Mal, wenn die Schlange das Futter einsammelt, wird sie länger, vorzugsweise mit einer anderen Farbe.
  • Jedes Mal, wenn die Schlange das Futter einsammelt, wird die Punktzahl des Spielers erhöht und die höchste Punktzahl verfolgt.
  • Der Spieler kann die Schlange vor Kollisionen mit der Wand oder ihrem eigenen Körper bewahren.
  • Das Spiel wird neu gestartet, wenn die Schlange kollidiert.
  • Der Punktestand des Spielers wird auf Null zurückgesetzt, wenn das Spiel neu gestartet wird, während der Bildschirm den höchsten Punktestand des Spielers beibehält.

Fügen Sie den Rest dieses Codes in Ihre Python-Datei ein.

segmente = []

#Implementieren des Spielablaufs
while True:
    wind.update()
    if snake.xcor() > 290 oder snake.xcor() < -290 oder snake.ycor() > 290 oder snake.ycor() < -290:
        time.sleep(1)
        snake.goto(0, 0)
        snake.direction = "Stopp"
        snake.shape("Quadrat")
        snake.color("grün")

        for segment in segmente:
            segment.goto(1000, 1000)
            segment.clear()
            spieler_punktzahl = 0
            verzögerung_zeit = 0.1
            pen.clear()
            pen.write("Spielergebnis: {} Höchste_Punktzahl: {}".format(spieler_punktzahl, höchste_punktzahl), align="center", font=("Arial", 24, "normal"))

        if snake.distance(snake_food) < 20:
            coord_x = random.randint(-270, 270)
            coord_y = random.randint(-270, 270)
            snake_food.goto(coord_x, coord_y)

            # Hinzufügen eines Segments
            hinzugefügt_segment = turtle.Turtle()
            hinzugefügt_segment.speed(0)
            hinzugefügt_segment.shape("Quadrat")
            added_segment.color("weiß")
            added_segment.penup()
            segments.append(hinzugefügt_segment)
            delay_time -= 0.001
            spieler_punktzahl = 5

            if player_score > highest_score:
                highest_score = player_score
                pen.clear()
                pen.write("Spielergebnis: {} Höchste_Punktzahl: {}".format(spieler_punktzahl, höchste_punktzahl), align="center", font=("Arial", 24, "normal"))

    # Überprüfung auf Kollisionen
    for i in range(len(segmente)-1, 0, -1):
        coord_x = segmente[i-1].xcor()
        koord_y = segmente[i-1].ycor()
        segmente[i].goto(koord_x, koord_y)

    wenn len(Segmente) > 0:
        coord_x = snake.xcor()
        koordinate_y = Schlange.ycor()
        segmente[0].goto(Koordinate_x, Koordinate_y)
    verschieben()

    for segment in segmente:
        if segment.distance(snake) < 20:
            time.sleep(1)
            snake.goto(0, 0)
            snake.direction = "stop"
            snake.color('weiß')
            schlange.form('Quadrat')

            for segment in segmente:
                segment.goto(1000, 1000)
                segment.clear()
                spieler_punktzahl = 0
                verzögerung_zeit = 0.1
                pen.clear()
                pen.write("Spielergebnis: {} Höchste_Punktzahl: {}".format(spieler_punktzahl, höchste_punktzahl), align="center", font=("Arial", 24, "normal"))

     time.sleep(delay_time)

turtle.mainloop()

In dem obigen Codeschnipsel legen wir eine zufällige Position für das Futter der Schlange auf dem Bildschirm fest. Jedes Mal, wenn die Schlange das Futter einsammelt, erhält ihr Körpersegment eine andere Farbe, in diesem Fall weiß, um ihr Wachstum zu kennzeichnen.

Nachdem die Schlange das Futter eingesammelt hat, ohne zu kollidieren, wird das Futter an einer zufälligen Position innerhalb des 270-Koordinatenbereichs der Bildschirmgröße platziert. Jedes Mal, wenn die Schlange Nahrung einsammelt, erhöht sich die Punktzahl des Spielers um 5. Wenn die Schlange kollidiert, wird die Punktzahl des Spielers auf 0 gesetzt, während der Bildschirm seine höchste Punktzahl beibehält.

Wenn Sie nun die Python-Datei zurückgeben, sollte Ihr Schildkrötenbildschirm so aussehen:

Fazit 🐍

Die Verwendung der Turtle-Bibliothek ist eine unterhaltsame und einfache Möglichkeit, das Schlangenspiel zu erstellen, wie wir in diesem Artikel gesehen haben. Alternativ können Sie das Gleiche auch mit der PyGame-Bibliothek implementieren. Schauen Sie sich das PyGame-Tutorial hier an und sehen Sie, wie Sie das Spiel anders implementieren können.

Sie können auch ein Zahlen-Ratespiel in Python ausprobieren oder erfahren, wie Sie JSON-Daten in Python erhalten.
Viel Spaß beim Programmieren!