Øk spillopplevelsen din med Python Arcade-spill ved å inkorporere et kamera.

Pythons Arcade-bibliotek er et kraftig og brukervennlig rammeverk for å lage 2D-spill. En nøkkelfunksjon som i stor grad kan forbedre spillingen og brukeropplevelsen er tillegget av et kamera. Å legge til et kamera i spillet gir dynamisk visningsportmanipulasjon, slik at spilleren kan utforske større spillverdener, fokusere på bestemte områder eller spore objekter i bevegelse.

Ved å flytte kameraets synsvinkel kan du lage visuelt tiltalende effekter, forbedre spillmekanikken og gi en mer oppslukende spillopplevelse.

Lag et enkelt spill

Før start, installer pip på enheten din og bruk kommandoen nedenfor for å installere arkade modul:

pip installer arkade

Begynn nå med å lage et grunnleggende siderullende spill hvor spilleren kontrollerer en karakter som kan bevege seg til venstre og høyre ved hjelp av piltastene.

Koden som brukes i denne artikkelen er tilgjengelig i denne GitHub-depot og er gratis for deg å bruke under MIT-lisensen.

instagram viewer

I tillegg kan du legge til en hindring for spilleren å navigere rundt.

import arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
MOVEMENT_SPEED = 5


klasseMitt Spill(arkade. Vindu):
def__i det__(selv, bredde, høyde):
 super().__init__(bredde, høyde)
 self.player_x = bredde // 2
 self.player_y = høyde // 2


defoppsett(selv):
 arcade.set_background_color (arcade.color. SKY_BLUE)


defon_draw(selv):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arkade.farge. RØD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkade.farge. GRØNN)


defOppdater(selv, delta_tid):
sende


defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
 self.player_x -= MOVEMENT_SPEED
elif nøkkel == arkade.nøkkel. IKKE SANT:
 self.player_x += MOVEMENT_SPEED
hvis __navn__ == "__hoved__":
 spill = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 game.setup()
 arcade.run()

Sette opp kameraet

For å legge til et kamera i spillet, lag en Kamera klasse som styrer kameraets posisjon og bevegelse. Denne klassen vil ha attributter som f.eks kamera_x og camera_y for å lagre kameraets koordinater.

klasseKamera:
def__i det__(selv):
 self.camera_x = 0
 self.camera_y = 0

Kamerabevegelse med tastaturinnganger

Deretter endrer du spillets on_key_press metode for å inkludere kamera bevegelse basert på spillerens innspill. Når spilleren beveger seg til venstre eller høyre, kan du oppdatere kameraets posisjon tilsvarende. Juster også tegnekoden for å ta hensyn til kameraets posisjon når du gjengir spillobjekter.

klasseMitt Spill(arkade. Vindu):
def__i det__(selv, bredde, høyde):
 super().__init__(bredde, høyde)
 self.camera = Kamera()
 self.player_x = bredde // 2
 self.player_y = høyde // 2
defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
 self.player_x -= MOVEMENT_SPEED
 self.camera.camera_x -= MOVEMENT_SPEED
elif nøkkel == arkade.nøkkel. IKKE SANT:
 self.player_x += MOVEMENT_SPEED
 self.camera.camera_x += MOVEMENT_SPEED
defon_draw(selv):
 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, arkade.farge. RØD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkade.farge. GRØNN)

Kamerabevegelse med museinnganger

I tillegg til tastaturinnganger kan du også aktivere kamerabevegelse basert på museinnganger. Du kan for eksempel la spilleren panorere kameraet ved å dra skjermen. For å oppnå dette, endre on_mouse_dra metode for å oppdatere kameraets posisjon basert på musens bevegelse.

klasseMitt Spill(arkade. Vindu):
defon_mouse_dra(selv, x, y, dx, dy, knapper, modifikatorer):
hvis knapper == arkade. MOUSE_BUTTON_LEFT:
 self.camera.camera_x -= dx
 self.camera.camera_y -= dy

Inkludert tilleggsfunksjoner

Å legge til et kamera i spillet åpner opp en verden av muligheter for tilleggsfunksjoner og effekter. Her er noen eksempler på hvordan du kan forbedre spillet ditt ytterligere ved å bruke kamerasystemet.

Zoom funksjonalitet

For å implementere zoomfunksjonalitet må du introdusere en zoom variabel i Kamera klasse og endre on_mouse_scroll metode for å oppdatere zoomnivået basert på musehjulets bevegelse. Du må også justere set_viewport parametere for å vurdere zoomnivået.

klasseKamera:
def__i det__(selv):
 self.camera_x = 0
 self.camera_y = 0
 selv.zoom = 1.0
klasseMitt Spill(arkade. Vindu):


defon_mouse_scroll(selv, x, y, scroll_x, scroll_y):
 self.camera.zoom += scroll_y * 0.1
defon_draw(selv):
 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, arkade.farge. RØD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkade.farge. GRØNN)

Glatt kamerabevegelse

For å oppnå jevnere kamerabevegelser kan du introdusere en interpolasjonsteknikk kalt lineær interpolasjon (lerp). Endre Oppdater metode for å gradvis flytte kameraet mot en målposisjon ved hjelp av lerp. Dette skaper en jevn overgangseffekt.

klasseKamera:
def__i det__(selv):
 self.camera_x = 0
 self.camera_y = 0
 self.target_x = 0
 self.target_y = 0
 self.lerp_speed = 0.1
defOppdater(selv):
 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)


klasseMitt Spill(arkade. Vindu):


defOppdater(selv, delta_tid):
 self.camera.target_x = self.player_x - SCREEN_WIDTH // 2
 self.camera.target_y = self.player_y - SCREEN_HEIGHT // 2
 self.camera.update()
defon_draw(selv):
 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, arkade.farge. RØD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkade.farge. GRØNN)

Kamerabegrensninger

For å forhindre at kameraet beveger seg utenfor visse grenser, kan du innføre begrensninger. Du kan for eksempel definere en minimums- og maksimumskameraposisjon og sørge for at kameraet holder seg innenfor disse grensene.

klasseKamera:
def__i det__(selv):
 self.camera_x = 0
 self.camera_y = 0
 self.min_x = 0
 self.max_x = 800
 self.min_y = 0
 self.max_y = 600
defOppdater(selv):
 self.camera_x = maks (self.min_x, min (self.camera_x, self.max_x))
 self.camera_y = maks (self.min_y, min (self.camera_y, self.max_y))


klasseMitt Spill(arkade. Vindu):


defOppdater(selv, delta_tid):
 self.camera.camera_x = self.player_x - SCREEN_WIDTH // 2
 self.camera.camera_y = self.player_y - SCREEN_HEIGHT // 2
 self.camera.update()
defon_draw(selv):
 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, arkade.farge. RØD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkade.farge. GRØNN)

Dette er bare noen få eksempler på hvordan du kan utnytte kamerasystemet til å inkludere flere funksjoner og effekter i Python Arcade-spillene dine.

Du kan også legge til mange andre tilleggsfunksjoner til dine Python-baserte spill. Du kan for eksempel få kameraet til å huske posisjonen når spilleren flytter til et annet nivå. Dette sikrer at utsikten forblir den samme når du skifter mellom nivåer, og gir en jevn og konsistent opplevelse for spilleren.

Beste praksis for et kamerasystem

Når du implementerer et kamerasystem i Python Arcade-spillet ditt, er det viktig å følge beste praksis for å sikre optimal funksjonalitet og en jevn spilleropplevelse. Her er noen viktige retningslinjer du bør huske på:

  • Unngå overdreven kamerabevegelse: Selv om kameraet kan legge til dynamiske elementer i spillet ditt, er det avgjørende å finne en balanse og unngå overdreven kamerabevegelse. Konstant forskyvning av kameraets posisjon kan desorientere spillere og gjøre det utfordrende for dem å navigere i spillverdenen.
  • Test på tvers av forskjellige oppløsninger og sideforhold: Det er viktig å teste kamerasystemet på forskjellige skjermoppløsninger og sideforhold for å sikre at det fungerer bra på tvers av forskjellige enheter og konfigurasjoner. Dette vil hjelpe deg med å identifisere eventuelle problemer knyttet til skalering av visningsport, objektplassering eller justeringer av sideforhold.
  • Optimaliser gjengivelsen: Kamerasystemet kan potensielt påvirke spillytelsen, spesielt når du gjengir store spillverdener eller mange objekter. For å optimalisere gjengivelsen, finn ut hvilke objekter som er utenfor kameraets visning og ekskluder dem fra gjengivelsen.
  • Håndter kantsaker: Vær oppmerksom på kanttilfeller der kameraet kan møte spesifikke scenarier, for eksempel grenser, kollisjonsdeteksjon eller overlappende objekter. Sørg for at kamerasystemet håndterer disse sakene elegant og gir jevne overganger eller passende visuelle signaler for å indikere begrensninger eller interaksjoner med spillmiljøet.

Ved å følge disse beste fremgangsmåtene kan du lage et robust og brukervennlig kamerasystem som sømløst integreres i Python Arcade-spillene dine.

Gjør spill morsommere med kamera

Ved å legge til et kamera til Python Arcade-spillene dine, kan du forbedre spillerens innlevelse og engasjement betraktelig. Enten det er å skape ekspansive spillverdener, fokusere på kritiske områder eller spore objekter i bevegelse, gir kamerasystemet et kraftig verktøy for spillutviklere.

Ved å utnytte kamerabevegelser, zooming og tilleggseffekter kan du skape fascinerende opplevelser som fengsler spillere og får dem til å komme tilbake for mer.