Zwiększ swoje wrażenia z grania w gry Python Arcade, wprowadzając kamerę.

Biblioteka Python Arcade to potężne i przyjazne dla użytkownika środowisko do tworzenia gier 2D. Jedną z kluczowych funkcji, która może znacznie poprawić rozgrywkę i wrażenia użytkownika, jest dodanie kamery. Dodanie kamery do gry umożliwia dynamiczną manipulację rzutnią, umożliwiając graczowi eksplorację większych światów gry, skupienie się na określonych obszarach lub śledzenie obiektów w ruchu.

Przesuwając punkt widzenia kamery, możesz tworzyć atrakcyjne wizualnie efekty, ulepszać mechanikę rozgrywki i zapewniać bardziej wciągające wrażenia z gry.

Stwórz prostą grę

Przed rozpoczęciem, zainstaluj pip na swoim urządzeniu i użyj poniższego polecenia, aby zainstalować arkada moduł:

zręcznościowa instalacja pip

Teraz zacznij od stworzenia podstawowej gry typu side-scrolling, w której gracz kontroluje postać, która może poruszać się w lewo i w prawo za pomocą klawiszy strzałek.

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

instagram viewer

Dodatkowo możesz dodać przeszkodę, po której gracz będzie mógł się poruszać.

import arkada
SZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600
PRĘDKOŚĆ_RUCHU = 5


klasaMoja gra(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
 super().__init__(szerokość, wysokość)
 self.player_x = szerokość // 2
 self.player_y = wzrost // 2


pokorganizować coś(samego siebie):
 arcade.set_background_color (arcade.color. NIEBIESKIE NIEBO)


pokon_draw(samego siebie):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arkadowy.kolor. CZERWONY)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkadowy.kolor. ZIELONY)


pokaktualizacja(ja, delta_czas):
przechodzić


pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 self.player_x -= PRĘDKOŚĆ_RUCHU
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 sam.gracz_x += PRĘDKOŚĆ_RUCHU
Jeśli __nazwa__ == "__główny__":
 gra = moja gra (SCREEN_WIDTH, SCREEN_HEIGHT)
 gra.ustawienia()
 arcade.run()

Konfigurowanie aparatu

Aby dodać kamerę do gry, utwórz plik Kamera klasa, która zarządza pozycją i ruchem kamery. Ta klasa będzie miała atrybuty takie jak kamera_x I kamera_y aby zapisać współrzędne kamery.

klasaKamera:
pok__w tym__(samego siebie):
 self.camera_x = 0
 self.camera_y = 0

Ruch kamery z wejściami klawiatury

Następnie zmodyfikuj grę on_key_press sposób na włączenie kamery ruch w oparciu o dane wejściowe gracza. Kiedy gracz porusza się w lewo lub w prawo, możesz odpowiednio zaktualizować pozycję kamery. Dostosuj także kod rysunkowy, aby uwzględniał położenie kamery podczas renderowania obiektów w grze.

klasaMoja gra(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
 super().__init__(szerokość, wysokość)
 self.camera = Camera()
 self.player_x = szerokość // 2
 self.player_y = wzrost // 2
pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 self.player_x -= PRĘDKOŚĆ_RUCHU
 self.camera.camera_x -= PRĘDKOŚĆ_RUCHU
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 sam.gracz_x += PRĘDKOŚĆ_RUCHU
 self.camera.camera_x += PRĘDKOŚĆ_RUCHU
pokon_draw(samego siebie):
 arcade.start_render()
 arcade.set_viewport(
 self.camera.camera_x,
 self.camera.camera_x + SCREEN_WIDTH,
 self.camera.camera_y,
 self.camera.camera_y + SCREEN_HEIGHT
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arkadowy.kolor. CZERWONY)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkadowy.kolor. ZIELONY)

Ruch kamery z wejściami myszy

Oprócz wprowadzania danych za pomocą klawiatury można również włączyć ruch kamery na podstawie danych wprowadzanych za pomocą myszy. Na przykład możesz pozwolić graczowi przesuwać kamerę, przeciągając ekran. Aby to osiągnąć, zmodyfikuj plik on_mouse_przeciągnij metoda aktualizowania pozycji kamery na podstawie ruchu myszy.

klasaMoja gra(arkada. Okno):
pokon_mouse_przeciągnij(self, x, y, dx, dy, przyciski, modyfikatory):
Jeśli przyciski == zręcznościowe. MOUSE_BUTTON_LEFT:
 self.camera.camera_x -= dx
 self.camera.camera_y -= dy

W tym dodatkowe funkcje

Dodanie kamery do gry otwiera świat możliwości dodatkowych funkcji i efektów. Oto kilka przykładów tego, jak możesz jeszcze bardziej ulepszyć swoją grę za pomocą systemu kamer.

Funkcjonalność zoomu

Aby zaimplementować funkcję powiększania, musisz wprowadzić a Powiększenie zmienna w Kamera class i zmodyfikuj on_mouse_scroll metoda aktualizacji poziomu powiększenia na podstawie ruchu kółka myszy. Trzeba też wyregulować set_viewport parametry, aby uwzględnić poziom powiększenia.

klasaKamera:
pok__w tym__(samego siebie):
 self.camera_x = 0
 self.camera_y = 0
 self.zoom = 1.0
klasaMoja gra(arkada. Okno):


pokon_mouse_scroll(ja, x, y, przewiń_x, przewiń_y):
 self.camera.zoom += scroll_y * 0.1
pokon_draw(samego siebie):
 arcade.start_render()
 arcade.set_viewport(
 self.camera.camera_x * self.camera.zoom,
 (self.camera.camera_x + SCREEN_WIDTH) * self.camera.zoom,
 self.camera.camera_y * self.camera.zoom,
 (self.camera.camera_y + SCREEN_HEIGHT) * self.camera.zoom
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arkadowy.kolor. CZERWONY)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkadowy.kolor. ZIELONY)

Płynny ruch kamery

Aby uzyskać płynniejszy ruch kamery, można wprowadzić technikę interpolacji zwaną interpolacją liniową (lerp). Zmodyfikuj aktualizacja metoda stopniowego przesuwania kamery w kierunku pozycji docelowej za pomocą lerp. Tworzy to płynny efekt przejścia.

klasaKamera:
pok__w tym__(samego siebie):
 self.camera_x = 0
 self.camera_y = 0
 własny.cel_x = 0
 własny.cel_y = 0
 self.lerp_speed = 0.1
pokaktualizacja(samego siebie):
 self.camera_x = arcade.lerp (self.camera_x, self.target_x, self.lerp_speed)
 self.camera_y = arcade.lerp (self.camera_y, self.target_y, self.lerp_speed)


klasaMoja gra(arkada. Okno):


pokaktualizacja(ja, delta_czas):
 self.camera.target_x = self.player_x - SCREEN_WIDTH // 2
 self.camera.target_y = self.player_y - SCREEN_HEIGHT // 2
 self.camera.update()
pokon_draw(samego siebie):
 arcade.start_render()
 arcade.set_viewport(
 self.camera.camera_x,
 self.camera.camera_x + SCREEN_WIDTH,
 self.camera.camera_y,
 self.camera.camera_y + SCREEN_HEIGHT
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arkadowy.kolor. CZERWONY)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkadowy.kolor. ZIELONY)

Ograniczenia aparatu

Aby zapobiec przesuwaniu się kamery poza określone granice, możesz wprowadzić ograniczenia. Na przykład możesz zdefiniować minimalną i maksymalną pozycję kamery i upewnić się, że kamera pozostaje w tych granicach.

klasaKamera:
pok__w tym__(samego siebie):
 self.camera_x = 0
 self.camera_y = 0
 ja.min_x = 0
 ja.max_x = 800
 ja.min_y = 0
 ja.max_y = 600
pokaktualizacja(samego siebie):
 self.camera_x = max (self.min_x, min (self.camera_x, self.max_x))
 self.camera_y = max (self.min_y, min (self.camera_y, self.max_y))


klasaMoja gra(arkada. Okno):


pokaktualizacja(ja, delta_czas):
 self.camera.camera_x = self.player_x - SCREEN_WIDTH // 2
 self.camera.camera_y = self.player_y - SCREEN_HEIGHT // 2
 self.camera.update()
pokon_draw(samego siebie):
 arcade.start_render()
 arcade.set_viewport(
 self.camera.camera_x,
 self.camera.camera_x + SCREEN_WIDTH,
 self.camera.camera_y,
 self.camera.camera_y + SCREEN_HEIGHT
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arkadowy.kolor. CZERWONY)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkadowy.kolor. ZIELONY)

To tylko kilka przykładów wykorzystania systemu kamer w celu dodania dodatkowych funkcji i efektów do gier Python Arcade.

Możesz także dodać wiele innych dodatkowych funkcji do swoich gier opartych na Pythonie. Na przykład możesz sprawić, by kamera pamiętała swoją pozycję, kiedy gracz przechodzi na inny poziom. Gwarantuje to, że widok pozostaje taki sam podczas przechodzenia między poziomami, zapewniając graczowi płynne i spójne wrażenia.

Najlepsze praktyki dotyczące systemu kamer

Wdrażając system kamer w grze Python Arcade, należy postępować zgodnie z najlepszymi praktykami, aby zapewnić optymalną funkcjonalność i płynne działanie gry. Oto kilka kluczowych wskazówek, o których należy pamiętać:

  • Unikaj nadmiernego ruchu aparatu: Chociaż kamera może dodawać dynamiczne elementy do twojej gry, ważne jest, aby zachować równowagę i unikać nadmiernych ruchów kamery. Ciągłe zmiany pozycji kamery mogą dezorientować graczy i utrudniać im poruszanie się po świecie gry.
  • Testuj w różnych rozdzielczościach i proporcjach: konieczne jest przetestowanie systemu kamery na różnych rozdzielczościach ekranu i współczynnikach proporcji, aby upewnić się, że działa dobrze na różnych urządzeniach i konfiguracjach. Pomoże Ci to zidentyfikować wszelkie problemy związane ze skalowaniem widocznego obszaru, pozycjonowaniem obiektów lub korektami proporcji.
  • Zoptymalizuj renderowanie: System kamer może potencjalnie wpływać na wydajność gry, zwłaszcza podczas renderowania dużych światów gry lub wielu obiektów. Aby zoptymalizować renderowanie, określ, które obiekty znajdują się poza polem widzenia kamery i wyklucz je z renderowania.
  • Obsługuj przypadki skrajne: Zwróć uwagę na skrajne przypadki, w których kamera może napotkać określone scenariusze, takie jak granice, wykrywanie kolizji lub nakładanie się obiektów. Upewnij się, że system kamery radzi sobie z takimi przypadkami z wdziękiem i zapewnia płynne przejścia lub odpowiednie wskazówki wizualne wskazujące na ograniczenia lub interakcje ze środowiskiem gry.

Postępując zgodnie z tymi najlepszymi praktykami, możesz stworzyć solidny i przyjazny dla użytkownika system kamer, który bezproblemowo integruje się z grami Python Arcade.

Spraw, by gry były przyjemniejsze dzięki aparatowi

Dodając kamerę do swoich gier Python Arcade, możesz znacznie zwiększyć immersję i zaangażowanie graczy. Niezależnie od tego, czy tworzysz rozległe światy gier, skupiasz się na krytycznych obszarach, czy śledzisz poruszające się obiekty, system kamer zapewnia potężne narzędzie dla twórców gier.

Wykorzystując ruch kamery, przybliżanie i dodatkowe efekty, możesz tworzyć hipnotyzujące wrażenia, które urzekają graczy i sprawiają, że wracają po więcej.