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

Jeśli jesteś fanem klasycznej gry w węża, ten artykuł z pewnością wzbudzi Twoje zainteresowanie.

W tym przewodniku pokażę Ci, jak stworzyć prostą wersję tej gry, którą nawet osoby początkujące w programowaniu w języku Python z łatwością zrozumieją i zaimplementują.

Istnieje kilka metod na stworzenie tej gry, w tym wykorzystanie biblioteki PyGame, popularnej wśród twórców gier w Pythonie.

Inna opcja to użycie modułu „turtle” (żółw), który jest standardowo dołączony do Pythona. Ten moduł udostępnia wirtualne płótno, na którym można kreować różnorodne kształty i obrazy.

W tym artykule, aby zaimplementować prostą grę w węża, wybierzemy bibliotekę „turtle”, która jest wyjątkowo przyjazna dla początkujących programistów Pythona.

Oprócz modułu „turtle”, użyjemy jeszcze dwóch innych modułów:

• Modułu „time” – Pozwala on na monitorowanie czasu, który upłynął od poprzedniego momentu.
• Modułu „random” – Umożliwia generowanie losowych liczb w Pythonie.

Oprócz tych modułów, będziesz potrzebować edytora tekstu (ja użyję VSCode w tym przykładzie). Dodatkowo, jeśli jeszcze tego nie zrobiłeś, musisz mieć zainstalowanego Pythona 3. Możesz również użyć kompilatora online.

Przygotuj się na świetną zabawę!

Zasady gry w węża

Głównym celem gry jest osiągnięcie jak największej liczby punktów poprzez sterowanie wężem i zbieranie jedzenia, które pojawia się na ekranie.

Użytkownik kontroluje węża za pomocą klawiszy strzałek, które zmieniają kierunek ruchu węża. Jeśli wąż uderzy w ścianę lub we własne ciało, gra dobiega końca.

Aby zaimplementować tę grę, wykonamy następujące kroki:

• Zaimportowanie niezbędnych modułów (turtle, time, random).
• Stworzenie obszaru gry za pomocą modułu turtle.
• Ustawienie klawiszy do poruszania wężem.
• Implementacja właściwej logiki gry.

Zacznij od stworzenia pliku o nazwie snakegame.py, w którym umieścimy kod naszej gry.

Importowanie modułów

Poniższy fragment kodu importuje moduły turtle, time i random, które są standardowo dostępne w Pythonie. Dodatkowo ustawimy domyślne wartości dla wyniku gracza, najwyższego wyniku i czasu opóźnienia między ruchami węża. Moduł time jest używany do obliczania tego opóźnienia.

Wklej poniższy kod do pliku snakegame.py.

import turtle
import random
import time

player_score = 0
highest_score = 0
delay_time = 0.1

Tworzenie ekranu gry

Moduł turtle pozwala nam na stworzenie wirtualnego płótna, które będzie służyło jako okno naszej gry. To tutaj będziemy rysować węża i jedzenie, które ma zbierać. Na ekranie będzie również wyświetlany aktualny wynik gracza.

Dodaj poniższy kod do pliku Python:

# Stworzenie okna gry
wind = turtle.Screen()
wind.title("Snake Maze🐍")
wind.bgcolor("red")

# Rozmiar okna
wind.setup(width=600, height=600)

# Tworzenie węża
snake = turtle.Turtle()
snake.shape("square")
snake.color("black")
snake.penup()
snake.goto(0, 0)
snake.direction = "Stop"

# Tworzenie jedzenia
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 kod inicjalizuje ekran żółwia, nadaje mu tytuł i kolor tła. Następnie ustawiamy rozmiar okna i rysujemy kształt węża na wirtualnym płótnie.

Metoda `penup()` podnosi pióro żółwia, co zapobiega rysowaniu linii podczas jego przemieszczania. Metoda `goto(x,y)` przenosi żółwia do określonej pozycji na podstawie współrzędnych.

Następnie tworzymy jedzenie, które wąż będzie zbierał. Wyświetlimy również wynik gracza za każdym razem, gdy wąż zje jedzenie, oraz najwyższy osiągnięty wynik. W tym celu użyjemy metody `pen.write()`. Funkcja `hideturtle()` ukrywa ikonę żółwia w sekcji nagłówka.

Na końcu kodu należy dodać `turtle.mainloop()`, aby okno gry pozostało otwarte, umożliwiając interakcję.

Uruchom plik i powinieneś zobaczyć okno gry.

Ustawianie klawiszy kierunkowych

W tej sekcji zdefiniujemy klawisze, które będą służyły do sterowania ruchem węża po ekranie. Użyjemy „L” dla lewo, „R” dla prawo, „U” dla góra i „D” dla dół. Użyjemy funkcji sterowania żółwia, aby przypisać te kierunki do węża.

Dodaj następujący fragment kodu:

# Przypisanie kierunków
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 o konkretną wartość współrzędnych.

Funkcja `listen()` nasłuchuje zdarzeń klawiatury i wywołuje odpowiednie metody, które sterują ruchem węża.

Implementacja logiki gry

Po stworzeniu podstawowej struktury naszej gry w węża, przejdziemy do implementacji dynamicznej logiki gry.

Będziemy musieli zadbać o następujące elementy:

• Zwiększenie długości węża za każdym razem, gdy ten zje jedzenie.
• Zwiększanie wyniku gracza za każdym razem, gdy wąż zje jedzenie i śledzenie najwyższego wyniku.
• Zapewnienie graczowi możliwości sterowania wężem bez zderzenia ze ścianą lub własnym ciałem.
• Ponowne uruchomienie gry po zderzeniu.
• Zresetowanie wyniku do zera po ponownym uruchomieniu gry, przy zachowaniu najwyższego wyniku.

Dodaj poniższy kod do pliku Python:

segments = []

#Implementacja logiki gry
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)

            # Dodanie segmentu
            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"))

    # Sprawdzanie kolizji
    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()

Powyższy kod odpowiada za losowe umieszczanie jedzenia na planszy. Gdy wąż zje jedzenie, jego ciało powiększa się o kolejny segment, który jest białego koloru, aby był odróżnialny.

Kiedy wąż zbiera jedzenie bez kolizji, jedzenie jest umieszczane w nowym, losowym miejscu. Za każdym razem, gdy wąż zje jedzenie, wynik gracza rośnie o 5 punktów. Po zderzeniu węża z ścianą lub samym sobą, wynik gracza jest zerowany, natomiast najwyższy wynik zostaje zachowany.

Po uruchomieniu pliku powinieneś zobaczyć działającą grę w węża.

Podsumowanie 🐍

Użycie biblioteki turtle jest przyjemnym i prostym sposobem na stworzenie gry w węża. Alternatywną metodą jest wykorzystanie biblioteki PyGame. Możesz sprawdzić Tutorial PyGame, aby poznać inne podejścia do tworzenia gier.

Zachęcam również do wypróbowania innych projektów, takich jak gra w zgadywanie liczb lub pobieranie danych JSON w Pythonie.
Życzę miłego kodowania!