Forøg din spiloplevelse med Python Arcade-spil ved at indbygge et kamera.

Pythons Arcade-bibliotek er en kraftfuld og brugervenlig ramme til at skabe 2D-spil. En nøglefunktion, der i høj grad kan forbedre gameplayet og brugeroplevelsen, er tilføjelsen af ​​et kamera. Tilføjelse af et kamera til dit spil giver mulighed for dynamisk viewport-manipulation, hvilket gør det muligt for spilleren at udforske større spilverdener, fokusere på specifikke områder eller spore objekter i bevægelse.

Ved at flytte kameraets synsvinkel kan du skabe visuelt tiltalende effekter, forbedre gameplay-mekanikken og give en mere fordybende spiloplevelse.

Opret et simpelt spil

Inden start, installer pip på din enhed og brug nedenstående kommando til at installere arkade modul:

pip installere arkade

Start nu med at skabe et grundlæggende side-scrolling-spil, hvor spilleren styrer en karakter, der kan bevæge sig til venstre og højre ved hjælp af piletasterne.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot og er gratis for dig at bruge under MIT-licensen.

instagram viewer

Derudover kan du tilføje en forhindring, som spilleren kan navigere rundt i.

importere arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
MOVEMENT_SPEED = 5


klasseMit Spil(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde)
 self.player_x = bredde // 2
 self.player_y = højde // 2


defOpsætning(selv):
 arcade.set_background_color (arcade.color. HIMMELBLÅ)


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


defopdatering(selv, delta_tid):
passere


defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.player_x -= MOVEMENT_SPEED
elif nøgle == arkade.nøgle. HØJRE:
 self.player_x += MOVEMENT_SPEED
hvis __navn__ == "__main__":
 spil = Mit spil (SCREEN_WIDTH, SCREEN_HEIGHT)
 game.setup()
 arcade.run()

Opsætning af kameraet

For at tilføje et kamera til spillet skal du oprette en Kamera klasse, der styrer kameraets position og bevægelse. Denne klasse vil have attributter som f.eks kamera_x og camera_y for at gemme kameraets koordinater.

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

Kamerabevægelse med tastaturindgange

Derefter skal du ændre spillets on_key_press metode til at inkludere kamera bevægelse baseret på spillerens input. Når afspilleren bevæger sig til venstre eller højre, kan du opdatere kameraets position i overensstemmelse hermed. Juster også tegnekoden for at tage højde for kameraets position, når du gengiver spilobjekter.

klasseMit Spil(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde)
 self.camera = Kamera()
 self.player_x = bredde // 2
 self.player_y = højde // 2
defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.player_x -= MOVEMENT_SPEED
 self.camera.camera_x -= MOVEMENT_SPEED
elif nøgle == arkade.nøgle. HØJRE:
 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.farve. RØD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkade.farve. GRØN)

Kamerabevægelse med museindgange

Ud over tastaturindgange kan du også aktivere kamerabevægelse baseret på museindgange. For eksempel kan du tillade afspilleren at panorere kameraet ved at trække skærmen. For at opnå dette skal du ændre on_mouse_drag metode til at opdatere kameraets position baseret på musens bevægelse.

klasseMit Spil(arkade. Vindue):
defon_mouse_drag(selv, x, y, dx, dy, knapper, modifikatorer):
hvis knapper == arkade. MOUSE_BUTTON_LEFT:
 self.camera.camera_x -= dx
 self.camera.camera_y -= dy

Inklusiv yderligere funktioner

Tilføjelse af et kamera til dit spil åbner op for en verden af ​​muligheder for yderligere funktioner og effekter. Her er et par eksempler på, hvordan du kan forbedre dit spil yderligere ved hjælp af kamerasystemet.

Zoom funktionalitet

For at implementere zoomfunktionalitet skal du introducere en zoom variabel i Kamera klasse og ændre on_mouse_scroll metode til at opdatere zoomniveauet baseret på musehjulets bevægelse. Du skal også justere set_viewport parametre for at tage højde for zoomniveauet.

klasseKamera:
def__i det__(selv):
 self.camera_x = 0
 self.camera_y = 0
 selv.zoom = 1.0
klasseMit Spil(arkade. Vindue):


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.farve. RØD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkade.farve. GRØN)

Glat kamerabevægelse

For at opnå jævnere kamerabevægelser kan du introducere en interpolationsteknik kaldet lineær interpolation (lerp). Rediger opdatering metode til gradvist at flytte kameraet mod en målposition ved hjælp af lerp. Dette skaber en glidende 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
defopdatering(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)


klasseMit Spil(arkade. Vindue):


defopdatering(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.farve. RØD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkade.farve. GRØN)

Kamerabegrænsninger

For at forhindre kameraet i at bevæge sig ud over bestemte grænser, kan du indføre begrænsninger. For eksempel kan du definere en minimums- og maksimumskameraposition og sikre, at kameraet holder sig inden for disse grænser.

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
defopdatering(selv):
 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))


klasseMit Spil(arkade. Vindue):


defopdatering(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.farve. RØD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arkade.farve. GRØN)

Dette er blot nogle få eksempler på, hvordan du kan udnytte kamerasystemet til at inkludere yderligere funktioner og effekter i dine Python Arcade-spil.

Du kan også tilføje mange andre ekstra funktioner til dine Python-baserede spil. For eksempel kan du få kameraet til at huske dets position, når spiller flytter til et andet niveau. Dette sikrer, at udsigten forbliver den samme, når du skifter mellem niveauer, hvilket giver en jævn og ensartet oplevelse for spilleren.

Bedste praksis for et kamerasystem

Når du implementerer et kamerasystem i dit Python Arcade-spil, er det vigtigt at følge bedste praksis for at sikre optimal funktionalitet og en jævn spilleroplevelse. Her er nogle vigtige retningslinjer, du skal huske på:

  • Undgå overdreven kamerabevægelse: Selvom kameraet kan tilføje dynamiske elementer til dit spil, er det afgørende at finde en balance og undgå overdreven kamerabevægelse. Konstant ændring af kameraets position kan desorientere spillere og gøre det udfordrende for dem at navigere i spilverdenen.
  • Test på tværs af forskellige opløsninger og billedformater: Det er vigtigt at teste dit kamerasystem på forskellige skærmopløsninger og billedformater for at sikre, at det fungerer godt på tværs af forskellige enheder og konfigurationer. Dette vil hjælpe dig med at identificere eventuelle problemer relateret til viewport-skalering, objektplacering eller justeringer af billedformat.
  • Optimer gengivelsen: Kamerasystemet kan potentielt påvirke spillets ydeevne, især ved gengivelse af store spilverdener eller adskillige objekter. For at optimere gengivelsen skal du bestemme, hvilke objekter der er uden for kameraets syn og udelukke dem fra gengivelse.
  • Håndtag kant sager: Vær opmærksom på kanttilfælde, hvor kameraet kan støde på specifikke scenarier, såsom grænser, kollisionsdetektion eller overlappende objekter. Sørg for, at kamerasystemet håndterer disse sager yndefuldt og giver jævne overgange eller passende visuelle signaler for at indikere begrænsninger eller interaktioner med spilmiljøet.

Ved at følge disse bedste praksisser kan du skabe et robust og brugervenligt kamerasystem, der problemfrit integreres i dine Python Arcade-spil.

Gør spil sjovere med kamera

Ved at tilføje et kamera til dine Python Arcade-spil kan du i høj grad forbedre spillerens fordybelse og engagement. Uanset om det er at skabe ekspansive spilverdener, fokusere på kritiske områder eller spore objekter i bevægelse, er kamerasystemet et kraftfuldt værktøj til spiludviklere.

Ved at udnytte kamerabevægelser, zoom og yderligere effekter kan du skabe fascinerende oplevelser, der fanger spillere og får dem til at vende tilbage efter mere.