Animuj obiekty gry za pomocą biblioteki Arcade

Animacja odgrywa istotną rolę w zwiększaniu atrakcyjności wizualnej i zaangażowania gier wideo. Biblioteka Arcade to framework Pythona do tworzenia gier 2D. Oferuje prosty i skuteczny sposób włączania animacji do projektów gier.

Możesz użyć biblioteki Arcade do tworzenia podstawowych animacji ruchu i animacji zsynchronizowanych z wydarzeniami w grze.

Stwórz prostą grę

Zanim zaczniesz, upewnij się, że masz pip zainstalowany na twoim urządzeniu. Użyj tego polecenia, aby zainstalować bibliotekę arcade:

zręcznościowa instalacja pip

Następnie utwórz plik Pythona o nazwie prosta gra.py i zacznij od przygotowania gry, w której gracz może poruszać się w lewo iw prawo.

Kod użyty w tym artykule jest dostępny w this Repozytorium GitHub i jest darmowy do użytku na licencji MIT.

Korzystając z biblioteki Arcade, możesz utworzyć okno, skonfigurować środowisko gry i obsłużyć dane wprowadzane przez gracza. Oto fragment kodu na początek:

import arkada
SZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600
klasaMoja gra(arkada. Okno):
pok__w tym__(samego siebie):
 super().__init__(SZEROKOŚĆ_EKRANU, WYSOKOŚĆ_EKRANU, "Moja gra")
 self.player_x = SZEROKOŚĆ_EKRANU // 2
 self.player_y = WYSOKOŚĆ_EKRANU // 2
pokon_draw(samego siebie):
 arcade.start_render()
 col = arcade.kolor. NIEBIESKI
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, kol)
pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 sam.gracz_x -= 10
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 sam.gracz_x += 10
pokgłówny():
 gra = moja gra()
 arcade.run()
Jeśli __nazwa__ == "__główny__":
 główny()

Dodaj podstawową animację ruchu

Teraz pójdź w swojej grze o krok dalej i dodaj podstawową animację ruchu do obiektu gracza. Aby animować gracz w ruchu, utwórz 3 różne kręgi i przechodź między nimi kolejno, gdy gracz zacznie się poruszać. Oto zaktualizowany fragment kodu dla ruch-animacja.py plik:

klasaMoja gra(arkada. Okno):
pok__w tym__(samego siebie):
 super().__init__(SZEROKOŚĆ_EKRANU, WYSOKOŚĆ_EKRANU, "Moja gra")
 self.player_x = SZEROKOŚĆ_EKRANU // 2
 self.player_y = WYSOKOŚĆ_EKRANU // 2
 własny.licznik_ramek = 0
pokon_draw(samego siebie):
 arcade.start_render()
 col1 = arcade.kolor. NIEBIESKI
 col2 = arcade.kolor. ZIELONY
 col3 = arcade.kolor. CZERWONY
Jeśli własny.licznik_ramek < 10:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,kol.1 )
Elif własny.licznik_ramek < 20:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,kol.2 )
w przeciwnym razie:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, kol.3)
pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 sam.gracz_x -= 10
 self.frame_counter = (self.frame_counter + 1) % 30
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 sam.gracz_x += 10
 self.frame_counter = (self.frame_counter + 1) % 30

Oto przykładowa ramka wyjściowa:

Kontrolowanie prędkości i kierunku animacji

Aby kontrolować szybkość animacji, możesz wprowadzić system liczby klatek na sekundę. Możesz także zmieniać kolejność klatek w zależności od kierunku ruchu gracza. Gdy gracz porusza się od lewej do prawej, klatki będą wyświetlane w odwrotnej kolejności.

Oto zmodyfikowany fragment kodu dla liczba klatek na sekundę.py plik:

klasaMoja gra(arkada. Okno):
pok__w tym__(samego siebie):
 super().__init__(SZEROKOŚĆ_EKRANU, WYSOKOŚĆ_EKRANU, "Moja gra")
 self.player_x = SZEROKOŚĆ_EKRANU // 2
 self.player_y = WYSOKOŚĆ_EKRANU // 2
 własny.licznik_ramek = 0
 col1 = arcade.kolor. NIEBIESKI
 col2 = arcade.kolor. ZIELONY
 col3 = arcade.kolor. CZERWONY
 self.frames = [kolumna1, kolumna2, kolumna3]
 self.frame_rate = 10
pokon_draw(samego siebie):
 arcade.start_render()
 frame_index = self.frame_counter // self.frame_rate % len (self.frames)
Jeśli self.player_x < SZEROKOŚĆ_EKRANU // 2:
 frame_index = len (self.frames) - 1 - indeks_ramek
 index = self.frames[frame_index]
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, indeks)
pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 sam.gracz_x -= 10
 własny.licznik_ramek += 1
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 sam.gracz_x += 10
 własny.licznik_ramek += 1

Użyj operatora modulo % z len (samo.ramki) aby upewnić się, że indeks_ramek zawsze mieści się w zakresie dostępnych klatek. Zapobiega to Błąd indeksu przed wystąpieniem, gdy animacja zapętla się w klatkach.

Poprawić częstotliwość wyświetlania klatek wartość, aby kontrolować szybkość animacji i cieszyć się animowanym ruchem obiektów w grze.

W tym dodatkowe funkcje

Biblioteka Arcade udostępnia różne funkcje poprawiające animacje.

Efekty cząsteczkowe

Możesz tworzyć efekty cząsteczkowe, takie jak eksplozje lub dym, aby dodać realizmu do swojej gry. Utwórz plik o nazwie cząstka.py i dodaj poniższy kod dla prostej implementacji systemu cząstek przy użyciu Pythona i biblioteki arkadowej:

import arkada
import losowy
# Wymiary ekranu
SZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600
# Kolory
BIAŁY = (255, 255, 255)
# Klasa cząstek
klasaCząstka:
pok__w tym__(ja, x, y, dx, dy, promień, kolor, żywotność):
 ja.x = x
 ja.y = y
 sam.dx = dx
 sam.dy = dy
 promień własny = promień
 własny.kolor = kolor
 długość życia = długość życia
pokaktualizacja(samego siebie):
 sam.x += sam.dx
 ja.y += ja.dy
 długość życia -= 1
pokrysować(samego siebie):
 arcade.draw_circle_filled (self.x, self.y, self.radius, self.color)
# Klasa gry
klasaMoja gra(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
 super().__init__(szerokość, wysokość, „Przykład cząstek”)
 własne.cząstki = []
pokorganizować coś(samego siebie):
# Twórz cząsteczki
Do _ W zakres(100):
 x = losowy.zakres losowy (SCREEN_WIDTH)
 y = losowy.zakres losowy (SCREEN_HEIGHT)
 dx = losowy.uniform(-1, 1)
 dy = losowo.uniform(-1, 1)
 promień = random.uniform(2, 5)
 kolor = arcade.kolor. BIAŁY
 długość życia = random.randint(60, 120)
 cząstka = cząstka (x, y, dx, dy, promień, kolor, żywotność)
 self.cząstki.dołącz (cząsteczka)
pokon_draw(samego siebie):
 arcade.start_render()
Do cząstka W cząstki własne:
 cząsteczka.draw()
pokaktualizacja(ja, delta_czas):
Do cząstka W cząstki własne:
 cząsteczka.aktualizacja()
Jeśli czas życia cząstki <= 0:
 self.cząstki.usuń (cząsteczka)
pokgłówny():
 gra = moja gra (SCREEN_WIDTH, SCREEN_HEIGHT)
 gra.ustawienia()
 arcade.run()
Jeśli __nazwa__ == "__główny__":
 główny()

Powinieneś zobaczyć animację zawierającą wiele poruszających się cząstek:

Animacje interaktywne

Implementuj interaktywne animacje, które reagują na dane wprowadzane przez użytkownika lub zdarzenia w grze. Na przykład, gdy gracz wchodzi w interakcję z obiektem, może on w jakiś sposób animować, zmieniać kolor lub przekształcać. Te interaktywne animacje dostarczają informacji zwrotnych i zwiększają zaangażowanie gracza w grę. Oto kod do interaktywna animacja.py plik:

import arkada
# Wymiary ekranu
SZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600
# Kolory
BIAŁY = (255, 255, 255)
CZERWONY = (255, 0, 0)
klasaMoja gra(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
 super().__init__(szerokość, wysokość, „Animacja interaktywna”)
 sam.gracz_x = 400
 sam.gracz_y = 300
 self.player_radius = 30
 sam.kolor_gracza = CZERWONY
 self.promień_animacji = 60
 self.animation_color = BIAŁY
 self.animation_active = FAŁSZ
pokon_draw(samego siebie):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 sam.gracz_y,
 self.player_radius,
 sam.kolor_gracza)
Jeśli self.animation_active:
 arcade.draw_circle_filled (self.player_x,
 sam.gracz_y,
 self.animation_radius,
 sam.kolor_animacji)
pokon_mouse_press(ja, x, y, przycisk, modyfikatory):
Jeśli (self.player_x - self.player_radius <=
 x <= self.player_x + self.player_radius I
 self.player_y - self.player_radius <=
 y <= self.player_y + self.player_radius
 ):
 self.animation_active = PRAWDA
pokaktualizacja(ja, delta_czas):
Jeśli self.animation_active:
 self.promień_animacji += 1
Jeśli self.promień_animacji > 100:
 self.animation_active = FAŁSZ
 self.promień_animacji = 0
pokgłówny():
 gra = moja gra (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
Jeśli __nazwa__ == "__główny__":
 główny()

Zastąp niezbędne metody, takie jak on_draw, on_mouse_press, I aktualizacja, do obsługi rysowania odtwarzacza i animacji, obsługi kliknięć myszą i aktualizowania animacji.

Aby narysować gracza, użyj arcade.draw_circle_filled funkcja, która przyjmuje (x, y) współrzędne środka, promień i kolor jako argumenty. Funkcja draw_circle_filled jest jedną z Narzędzia Arcade, których możesz użyć do rysowania zasobów gry. W takim przypadku możesz narysować rosnący okrąg, zmieniając promień w czasie.

The on_mouse_press Metoda jest uruchamiana, gdy użytkownik kliknie myszką. Sprawdza, czy współrzędne myszy mieszczą się w granicach obiektu gracza i aktywuje animację, jeśli tak jest.

Sprawdzone metody dodawania animacji

Dodając animację do swoich gier, weź pod uwagę następujące sprawdzone metody:

Ogranicz liczbę animacji

Posiadanie wielu animacji z wieloma klatkami może mieć wpływ na wydajność. Rozważ zminimalizowanie liczby wymaganych animacji lub klatek, zwłaszcza w przypadku niekrytycznych elementów gry. Uproszczenie animacji może pomóc w utrzymaniu stałej liczby klatek na sekundę i optymalizacji wykorzystania zasobów.

Renderuj wsadowo podobne obiekty

Grupuj podobne obiekty, które mają te same klatki animacji i tekstury, i renderuj je jako partię. Batching zmniejsza liczbę wywołań losowania, co skutkuje lepszą wydajnością. Ta technika jest szczególnie przydatna podczas animowania obiektów, które używają tego samego arkusza sprite lub mają podobne sekwencje animacji.

Użyj interpolacji, aby uzyskać płynną animację

Zastosuj techniki interpolacji, takie jak interpolacja liniowa (lerping), aby uzyskać płynne przejścia animacji. Interpolacja oblicza wartości pośrednie między klatkami kluczowymi animacji, aby tworzyć płynne ruchy. Takie podejście zapobiega nagłym skokom lub gwałtownym ruchom między klatkami, co skutkuje bardziej atrakcyjnymi wizualnie animacjami.

Weź pod uwagę szybkość i synchronizację animacji

Eksperymentuj z różnymi prędkościami i synchronizacją animacji, aby znaleźć odpowiednią równowagę dla swojej gry. Dostosuj czas trwania klatki lub użyj różnych sekwencji animacji, aby stworzyć różnice w szybkości, przyspieszeniu lub spowolnieniu. Te poprawki mogą dodać głębi i charakteru animacjom w grze.

Testuj i optymalizuj

Regularnie testuj swoje animacje na różnych urządzeniach i monitoruj wydajność. Szukaj potencjalnych wąskich gardeł lub spowolnień i odpowiednio optymalizuj. Ten proces pomaga zapewnić płynne i spójne animacje na wielu różnych urządzeniach.

Spraw, by gry były bardziej wciągające dzięki animacji

Dodanie animacji do gier może znacznie zwiększyć zaangażowanie i immersję graczy. Animacje zapewniają wizualną informację zwrotną na temat działań gracza, dzięki czemu rozgrywka jest bardziej intuicyjna i przyjemna. Ożywiają światy gier, tworząc wrażenie realizmu i ekscytacji.

Niezależnie od tego, czy jest to bieg postaci, eksplodujący obiekt, czy prosty efekt przejścia, animacje przyczyniają się do bardziej dynamicznego i wciągającego wrażenia z gry.