Tworzenie postaci do gier opartych na sprite’ach w Pygame

Jeśli jesteś twórcą gier korzystającym z biblioteki Pygame, prawdopodobnie zetknąłeś się z klasą Sprite. Klasa Sprite to potężne narzędzie do tworzenia postaci w grze, które można łatwo przesuwać, obracać i skalować na ekranie.

Dzięki prostemu programowi w Pythonie możesz dowiedzieć się o procesie tworzenia postaci w grze opartych na duszkach w Pygame. Dowiedz się, jak utworzyć podstawową klasę Sprite, a następnie dodać atrybuty i metody kontrolowania zachowania.

Wprowadzenie do klasy Sprite w Pygame

Klasa Sprite w Pygame to klasa kontenera, która przechowuje wszystkie atrybuty i zachowania postaci z gry. Wywodzi się z klasy Surface Pygame, która reprezentuje obraz o stałej szerokości i wysokości.

Aby z nim pracować, musisz utworzyć nową klasę, która będzie dziedziczyć po klasie Sprite, i zdefiniować wszelkie atrybuty i metody, które ma mieć Twoja postać w grze.

Tworzenie podstawowej klasy Sprite dla postaci w grze

Najpierw zainstaluj moduł pygame za pomocą pip. Zrób to za pomocą tego polecenia:

pip install pygame

Aby utworzyć podstawowego sprite’a, musisz zaimportować klasę Sprite z Pygame i utworzyć nową klasę, która po niej dziedziczy. Następnie możesz zdefiniować dowolne atrybuty i metody, które ma mieć Twoja postać w grze.

Na przykład możesz chcieć utworzyć klasę Sprite dla postaci gracza, która może poruszać się w lewo i w prawo po ekranie. Aby to zrobić, możesz zdefiniować następujące atrybuty:

• position: Krotka przechowująca współrzędne x i y duszka na ekranie.
• prędkość: Krotka przechowująca prędkość, z jaką duszek porusza się w poziomie iw pionie.

Oraz następujące metody:

• update(): Metoda, która aktualizuje pozycję duszka na podstawie jego prędkości.
• draw(): Metoda, która rysuje duszka na ekranie.

Oto przykład podstawowej klasy Sprite, która implementuje te atrybuty i metody:

import pygame


class Player(pygame.sprite.Sprite):
    def __init__(self, x, y, velocity_x, velocity_y):
        super().__init__()
        self.position = (x, y)
        self.velocity = (velocity_x, velocity_y)

    def draw(self, surface):
        pygame.draw.circle(surface, (255, 0, 0), self.position, 10)

Metoda __init__ jest specjalną metodą w klasach Pythona, która jest uruchamiana podczas tworzenia instancji klasy. Możesz go użyć do zainicjowania atrybutów instancji.

W tym kodzie metoda __init__ klasy Player przyjmuje cztery argumenty: x, y, prędkość_x i prędkość_y. Argumenty te określają początkową pozycję i prędkość duszka gracza.

Metoda __init__ wywołuje również metodę super().__init__(), która jest metodą __init__ macierzystej klasy Sprite. Jest to konieczne, ponieważ klasa Player jest podklasą klasy Sprite, a metoda __init__ klasy Sprite ustawia pewne atrybuty, których potrzebują wszystkie duszki.

Dodawanie atrybutów i metod do zachowania kontrolnego

Teraz, gdy masz już podstawową klasę Sprite, możesz dodawać atrybuty i metody, aby kontrolować zachowanie swojej postaci w grze. Może to obejmować ruch, atakowanie, skakanie i nie tylko.

Aby dodać te atrybuty i metody, musisz pomyśleć o tym, jakie działania ma wykonywać twoja postać w grze, i zdefiniować odpowiednie atrybuty i metody w swojej klasie Sprite.

Na przykład możesz chcieć dodać metodę kontrolującą ruch duszka, na przykład metodę move_left(), która zmniejsza prędkość duszka na osi x.

Oto przykład zmodyfikowanej klasy Sprite, która zawiera te dodatkowe atrybuty i metody:

class Player(pygame.sprite.Sprite):
    def __init__(self, x, y, velocity_x, velocity_y):
        super().__init__()
        self.position = (x, y)
        self.velocity = (velocity_x, velocity_y)


    def update(self):
        self.position = (self.position[0] + self.velocity[0], self.position[1] + self.velocity[1])

    def move_right(self):
        self.velocity = (1, self.velocity[1])

Aby użyć klasy Player w swojej grze Pygame, musisz utworzyć instancję tej klasy i w razie potrzeby wywołać jej metody.

Zacznij od utworzenia okna i instancji duszka Player:

# Initialize Pygame
pygame.init()


# Set the window size
window_size = (640, 480)

# Create a player sprite
player = Player(320, 240, 0, 0)


Następnie zdefiniuj główną pętlę gry, która obsługuje zdarzenia klawiatury i aktualizacje oraz rysuje duszka. Gdy naciśniesz lewy lub prawy klawisz strzałki, duszek przesunie się w odpowiednim kierunku.

# Main game loop
while True:
    # Handle events
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()


        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                player.move_left()
            elif event.key == pygame.K_RIGHT:
                player.move_right()

    # Update the display
    pygame.display.update()

Dzięki powstałemu programowi będziesz mógł kontrolować sprite’a gracza i obserwować, jak rysuje się na ekranie w różnych pozycjach:

Ładowanie i wyświetlanie grafiki sprite za pomocą modułu obrazu

Teraz, gdy masz już podstawową klasę Sprite z atrybutami i metodami kontrolującymi zachowanie, prawdopodobnie będziesz chciał dodać trochę grafiki do swojego duszka. Moduł obrazu Pygame ułatwia ładowanie i wyświetlanie obrazów na ekranie.

Aby załadować obraz, musisz użyć funkcji pygame.image.load(), która jako argument przyjmuje ścieżkę do pliku i zwraca obiekt Surface. Następnie możesz przypisać ten obiekt Surface do atrybutu duszka, takiego jak self.image, którego możesz użyć do narysowania duszka na ekranie.

Na przykład, oto jak możesz załadować obraz i przypisać go do duszka:

import pygame


class Player(pygame.sprite.Sprite):
    def __init__(self, x, y, velocity_x, velocity_y, image_path):
        super().__init__()
        self.position = (x, y)
        self.velocity = (velocity_x, velocity_y)
        self.image = pygame.image.load(image_path)

    def move_right(self):
        self.velocity = (1, self.velocity[1])

Ten kod definiuje klasę Player, która rozszerza klasę Sprite Pygame i zawiera atrybuty pozycji, prędkości i obrazu, a także metody aktualizowania pozycji duszka, rysowania duszka na ekranie i kontrolowania ruchu.

Możesz sprawdzić to repozytorium GitHub, aby uzyskać pełny kod!

Usprawnij zarządzanie duszkami dzięki klasie Sprite

Klasa Sprite zapewnia wygodny kontener dla wszystkich atrybutów i zachowań postaci w grze, ułatwiając aktualizowanie, rysowanie i kontrolowanie duszka na ekranie.

Implementując klasę Sprite w swojej grze Pygame, możesz poprawić ogólne wrażenia swoich graczy i usprawnić proces tworzenia dla siebie.