Jak zrobić grę w węża w Pythonie

Jeśli lubisz grać w węża, jestem pewien, że ten artykuł zainteresuje Cię.

W tym artykule nauczę Cię, jak wymyślić prostą grę w węża, którą nawet początkujący w Pythonie mógłby łatwo opracować.

Istnieje wiele sposobów tworzenia tej gry, a jeden obejmuje użycie biblioteki Pythona PyGame, która jest biblioteką Pythona, której używamy do tworzenia gier.

Innym sposobem jest skorzystanie z biblioteki żółwi. Ten moduł jest fabrycznie zainstalowany w języku Python i zapewnia użytkownikom wirtualne płótno do tworzenia kształtów i obrazów.

Dlatego w tym artykule wykorzystamy bibliotekę żółwia do zaimplementowania naszej prostej gry w węża, która jest przyjazna dla początkujących, szczególnie dla początkujących programistów Pythona.

Oprócz tego modułu użyjemy również dwóch innych modułów, a mianowicie;

Moduł czasu – Ta metoda pozwoli nam śledzić liczbę sekund, które upłynęły od poprzedniego czasu.
Moduł Random – generuje liczby losowo w Pythonie.

Inne podstawowe narzędzia, których będziesz potrzebować, to wybrany przez Ciebie edytor tekstu. W tym artykule użyję VSCode. Oczywiście będziesz musiał zainstalować Pythona 3 na swoim komputerze, jeśli jeszcze go nie masz. Możesz również użyć kompilatora wdzzwdz.

To powinno być fajne!

Spis treści:

Jak działa gra w węża

Ostatecznym celem tej gry jest osiągnięcie przez gracza najwyższego wyniku poprzez kontrolowanie węża, aby zbierać jedzenie wyświetlane na ekranie.

Gracz kontroluje węża za pomocą czterech klawiszy kierunkowych, które są zależne od kierunku, w którym porusza się wąż. Jeśli wąż uderzy w blok lub sam, gracz przegrywa.

Poniższe kroki będziemy wykonywać, aby zaimplementować tę grę.

Importowanie do naszych programów preinstalowanych modułów (żółw, czas i losowe).
Tworzenie zrzutu ekranu gry za pomocą modułu żółwia.
Ustawianie klawiszy do poruszania się węża po ekranie.
Implementacja rozgrywki.

Utwórz plik snakegame.py, w którym dodamy kod implementacji.

Importowanie modułów

Ten fragment kodu zaimportuje żółwia, czas i moduły losowe, które są domyślnie preinstalowane w Pythonie. Dodatkowo ustalimy wtedy domyślne wartości dla początkowego wyniku gracza, najwyższy wynik, jaki gracz uzyska, oraz czas opóźnienia, jaki gracz zajmuje w każdym ruchu. Moduł czasu służy tutaj do obliczania czasu opóźnienia.

Dodaj następujący fragment kodu do pliku snakegame.py.

import turtle
import random
import time

player_score = 0
highest_score = 0
delay_time = 0.1

Tworzenie ekranu gry

Importowany tutaj moduł żółwia pozwoli nam stworzyć wirtualne płótno, które będzie ekranem okna gry. Stąd możemy stworzyć ciało węża i jedzenie, które wąż zbierze. Nasz ekran wyświetli również śledzony wynik gracza.

Dodaj ten kod do pliku Pythona.

# window screen created
wind = turtle.Screen()
wind.title("Snake Maze🐍")
wind.bgcolor("red")

# The screen size
wind.setup(width=600, height=600)


# creating the snake 
snake = turtle.Turtle()
snake.shape("square")
snake.color("black")
snake.penup()
snake.goto(0, 0)
snake.direction = "Stop"

# creating the food
snake_food = turtle.Turtle()
shapes = random.choice('triangle','circle')
snake_food.shape(shapes)
snake_food.color("blue")
snake_food.speed(0)
snake_food.penup()
snake_food.goto(0, 100)

pen = turtle.Turtle()
pen.speed(0)
pen.shape('square')
pen.color('white')
pen.penup()
pen.hideturtle()
pen.goto(0, 250)
pen.write("Your_score: 0 Highest_Score : 0", align="center", 
font=("Arial", 24, "normal"))
turtle.mainloop()

Powyższy fragment kodu zaczyna się od inicjalizacji ekranu żółwia i przekazuje na ekran tytuł i kolor tła. Po określeniu rozmiaru okna naszego ekranu, na wirtualnym płótnie rysujemy kształt węża.

Metoda penup() po prostu podnosi pióro żółwia, dzięki czemu linia nie jest rysowana, gdy żółw się porusza. Metoda goto(x,y) zawiera pozycje współrzędnych, które przesuwają żółwia do pozycji bezwzględnej.

Następnie tworzymy pożywienie, które zbiera wąż. Będziemy chcieli wyświetlać wynik gracza za każdym razem, gdy wąż zbierze jedzenie i najwyższy wynik, jaki gracz osiągnie podczas gry. Dlatego do zaimplementowania tego używamy metody pen.write(). Funkcja hideturtle() ukrywa ikonę żółwia na ekranie w sekcji nagłówka, w której zapisany jest ten tekst.

Ważne jest, aby dodać turtle.mainloop() na końcu kodu, który będzie wyświetlał ekran dłużej, abyś mógł coś zrobić na ekranie.

Uruchom plik i powinieneś mieć następujące dane wyjściowe:

Konfigurowanie klawiszy kierunkowych dla węża

Tutaj ustawimy konkretne klawisze, które będą wskazywały kierunek poruszania się węża po ekranie. Użyjemy litery „L” dla lewej, „R” dla prawej, „U” dla góry, „D” dla dołu. Zaimplementujemy te kierunki za pomocą funkcji kierunku żółwia, którą wywołamy na wężu.

Dodaj następujący fragment kodu do swojego kodu.

# Assigning directions
def moveleft():
    if snake.direction != "right":
        snake.direction = "left"

def moveright():
    if snake.direction != "left":
        snake.direction = "right"

def moveup():
    if snake.direction != "down":
        snake.direction = "up"

def movedown():
    if snake.direction != "up":
        snake.direction = "down"

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

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

    if snake.direction == "right":
        coord_x = snake.xcor()
        snake.setx(coord_x+20)

    if snake.direction == "left":
        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')

Powyższa funkcja move() ustawia ruch węża w określonej pozycji w ramach dokładnej wartości współrzędnych.

Funkcja listen() to detektor zdarzeń, który wywołuje metody, które przesuwają węża w określonym kierunku, gdy gracz naciśnie klawisz.

Implementacja gry w węża

Po ustaleniu podstawowego wyglądu naszej gry w węża, będziemy musieli stworzyć grę w czasie rzeczywistym.

Będzie to obejmować następujące elementy:

Zwiększanie długości węża za każdym razem, gdy zbiera pokarm, najlepiej przy użyciu innego koloru.
Zwiększanie wyniku gracza za każdym razem, gdy wąż zbiera jedzenie i śledzi najwyższy wynik.
Gracz jest w stanie kontrolować węża przed zderzeniem ze ścianą lub własnym ciałem.
Gra uruchamia się ponownie, gdy wąż się zderza.
Wynik gracza jest resetowany do zera po ponownym uruchomieniu gry, podczas gdy ekran zachowuje najwyższy wynik gracza.

Dodaj resztę tego kodu do pliku Pythona.

segments = []

#Implementing the gameplay
while True:
    wind.update()
    if snake.xcor() > 290 or snake.xcor() < -290 or snake.ycor() > 290 or snake.ycor() < -290:
        time.sleep(1)
        snake.goto(0, 0)
        snake.direction = "Stop"
        snake.shape("square")
        snake.color("green")

        for segment in segments:
            segment.goto(1000, 1000)
            segments.clear()
            player_score = 0
            delay_time = 0.1
            pen.clear()
            pen.write("Player's_score: {} Highest_score: {}".format(player_score, highest_score), 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)

            # Adding segment
            added_segment = turtle.Turtle()
            added_segment.speed(0)
            added_segment.shape("square")
            added_segment.color("white")
            added_segment.penup()
            segments.append(added_segment)
            delay_time -= 0.001
            player_score += 5

            if player_score > highest_score:
                highest_score = player_score
                pen.clear()
                pen.write("Player's_score: {} Highest_score: {}".format(player_score, highest_score), align="center", font=("Arial", 24, "normal"))

    # checking for collisions
    for i in range(len(segments)-1, 0, -1):
        coord_x = segments[i-1].xcor()
        coord_y = segments[i-1].ycor()
        segments[i].goto(coord_x, coord_y)

    if len(segments) > 0:
        coord_x = snake.xcor()
        coord_y = snake.ycor()
        segments[0].goto(coord_x, coord_y)
    move()

    for segment in segments:
        if segment.distance(snake) < 20:
            time.sleep(1)
            snake.goto(0, 0)
            snake.direction = "stop"
            snake.color('white')
            snake.shape('square')

            for segment in segments:
                segment.goto(1000, 1000)
                segment.clear()
                player_score = 0
                delay_time = 0.1
                pen.clear()
                pen.write("Player's_score: {} Highest_score: {}".format(player_score, highest_score), align="center", font=("Arial", 24, "normal"))

     time.sleep(delay_time)

turtle.mainloop()

W powyższym fragmencie kodu ustawiamy losową pozycję dla jedzenia węża na ekranie. Za każdym razem, gdy wąż zbiera ten pokarm, jego segment ciała powiększa się o inny kolor; biały, w tym przypadku, aby odróżnić jego wzrost.

Po tym, jak wąż zbiera jedzenie bez kolizji, jedzenie jest ustawiane w losowej pozycji w zakresie 270 współrzędnych rozmiaru ekranu. Za każdym razem, gdy wąż zbiera jedzenie, wynik gracza zwiększa się o 5. Kiedy wąż się zderza, wynik gracza jest ustawiony na 0, podczas gdy ekran zachowuje najwyższy wynik.

Teraz zwróć plik Pythona i powinieneś zobaczyć swój ekran żółwia wyglądający tak:

Wniosek 🐍

Korzystanie z biblioteki żółwi jest zabawnym i łatwym sposobem na stworzenie gry w węża, jak widzieliśmy w tym artykule. Alternatywnie możesz zaimplementować to samo za pomocą biblioteki PyGame. Możesz sprawdzić Tutorial PyGame i zobacz, jak możesz inaczej zaimplementować grę.

Możesz także wypróbować grę w zgadywanie liczb w Pythonie lub jak uzyskać dane JSON w Pythonie.
Ciesz się kodowaniem!