Artificial Intelligence (AI)

Create Your First Game with Python

Written by smirow

Python macht Spaß und ist einfach zu bedienen. Mit einer breiten Palette verfügbarer Bibliotheken macht Python 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 nie zuvor erlebt haben, haben Sie jetzt die Chance, es zu erkunden und Ihre eigene Version 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 Snake Game ist ein zeitloser Arcade-Klassiker, bei dem der Spieler eine Schlange steuert, deren Größe durch die Nahrungsaufnahme zunimmt. 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.

Verwendung von Turtle Graphics für die einfache Spieleentwicklung

Die Turtle-Grafikbibliothek 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 webbasierten Codierungsplattform 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 verwenden es häufig zum Lernen, für schnelles Prototyping und zum Teilen von Code, da es einfach zu verwenden ist und keine Konfiguration erfordert.

Algorithmus

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

Erstellen Sie eine Repl-Datei

Schritt 1: Erforderliche Bibliotheken installieren

Dies ist der erste Schritt in der Entwicklung des Spiels Snake. Die Schildkröte, Zufall und Zeit gehören dazu.

  • Schildkröte: Wir benötigen diese Bibliothek, um die Grafiken unseres Spiels 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 Lebensmittel auf dem Bildschirm zu erstellen, verwenden wir die Zufallsbibliothek. Dadurch wird sichergestellt, dass die Lebensmittel jedes Mal, wenn sie verzehrt werden, an einer anderen Stelle erscheinen.
  • Zeit: Dank der zeitlichen Bibliothek bewegt sich die Schlange mit einer leichten Verzögerung zwischen den einzelnen Bewegungen. Dies macht das Spiel benutzerfreundlicher 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 reibungsloses Gameplay zu gewährleisten. Wir haben außerdem Variablen wie „high_score“ konfiguriert, um die höchste erreichte Punktzahl beizubehalten, „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
Ausgehen

Schritt 3: Erstellen der Schlange

Ein quadratisches Schildkrötenobjekt symbolisiert die Schlange. Wir positionieren 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. Zunächst 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"
Erstelle eine Schlange

Schritt 4: Bewegungsfunktionen

Wir definieren die Bewegungsfunktionen der Schlange (move()) basierend auf ihrer Richtung zu diesem Zeitpunkt. 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: Kontrollieren Sie die Schlange

Mit sc.listen() und sc.onkey() konfigurieren wir die 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 das Drücken der Tastaturtasten 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: Bereiten Sie das Essen zu

Nahrung wird durch ein kreisförmiges rotes Schildkrötenobjekt dargestellt. Zunächst an den Koordinaten (100, 100) platziert, dient es der Schlange als Ziel zum Fressen. Wenn die Schlange mit der Nahrung kollidiert, „frisst“ sie die Nahrung und an einer zufälligen Stelle erscheint eine neue.

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

Kreieren Sie das Essen

Schritt 7: Anzeige des Punktestandes

Ein Schildkrötengegenstand (Stift) zeigt die Punktzahl des Spielers und die höchste erreichte Punktzahl an. Diese Informationen werden jedes Mal aktualisiert, wenn die Schlange Nahrung 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")
Punkteanzeige

Schritt 8: Hauptspielschleife

Das Herzstück des Snake-Spiels ist die Hauptspielschleife. Es verarbeitet Benutzereingaben, aktualisiert den Bildschirm, bewegt die Schlange, prüft auf Kollisionen und reguliert den Spielfluss. Schauen wir uns die spezifischen Funktionen jedes Abschnitts der Hauptschleife genauer an:

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 widerzuspiegeln. Ohne dies würde der Bildschirm nicht aktualisiert werden und die Spieler würden die Schlangenbewegung oder die Punkteaktualisierung nicht 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 zeigt, bis der Spieler die Richtung ändert.
  • time.sleep(delay): führt eine leichte Verzögerung zwischen jeder Schlangenbewegung ein. DER delay Die 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 Spielen des Spiels erschweren würde.

Iss Essen und lass die Schlange wachsen

    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) befindet sich in einem Abstand von 20 Einheiten vom 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 bei jedem Verzehr an verschiedenen Stellen „wieder auftaucht“.

Den Körper der Schlange wachsen lassen

  • Wenn die Schlange 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) entsteht, die ein integraler Bestandteil 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.

Ergebnisaktualisierung

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

Bewegen Sie den Körper der Schlange

    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 Abschnitt des Codes ist dafür verantwortlich, dass der Körper der Schlange ihrem Kopf folgt.
  • Er reist segments Liste, beginnend mit dem letzten Segment (len(segments) - 1) zum zweiten Segment (0) und verschiebt jedes Segment an die Position des vorangehenden 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. Bei dem Spiel geht es darum, eine Schlange so zu steuern, dass sie Nahrung frisst und wächst und dabei Kollisionen mit Wänden und ihrem eigenen Schwanz vermeidet. Dies 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 für unseren kostenlosen Python-Kurs an.

Lesen Sie hier auch unsere anderen Artikel zum Thema Python:

About the author

smirow

Leave a Comment