Til je game-ervaring naar een hoger niveau met Python Arcade-games door een camera te integreren.

De Arcade-bibliotheek van Python is een krachtig en gebruiksvriendelijk raamwerk voor het maken van 2D-games. Een belangrijk kenmerk dat de gameplay en gebruikerservaring enorm kan verbeteren, is de toevoeging van een camera. Door een camera aan je game toe te voegen, kun je dynamische viewports manipuleren, waardoor de speler grotere gamewerelden kan verkennen, zich kan concentreren op specifieke gebieden of bewegende objecten kan volgen.

Door het gezichtspunt van de camera te verplaatsen, kunt u visueel aantrekkelijke effecten creëren, de spelmechanismen verbeteren en een meer meeslepende game-ervaring bieden.

Maak een eenvoudig spel

Voor het starten, installeer pip op uw apparaat en gebruik de onderstaande opdracht om het arcade moduul:

pip installeren arcade

Begin nu met het maken van een eenvoudig side-scrolling-spel waarbij de speler een personage bestuurt dat naar links en rechts kan bewegen met de pijltjestoetsen.

instagram viewer

De code die in dit artikel wordt gebruikt, is hierin beschikbaar GitHub-opslagplaats en is gratis voor u om te gebruiken onder de MIT-licentie.

Bovendien kun je een obstakel toevoegen waar de speler doorheen kan navigeren.

importeren arcade
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600
BEWEGING_SPEED = 5


klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 self.player_x = breedte // 2
 self.player_y = hoogte // 2


defopgericht(zelf):
 arcade.set_background_color (arcade.kleur. HEMELSBLAUW)


defon_draw(zelf):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arcade.kleur. ROOD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arcade.kleur. GROENTE)


defupdate(zelf, delta_tijd):
doorgang


defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 self.player_x -= MOVEMENT_SPEED
elif sleutel == arcade.sleutel. RECHTS:
 self.player_x += BEWEGING_SPEED
als __naam__ == "__voornaamst__":
 spel = Mijnspel (SCREEN_WIDTH, SCREEN_HEIGHT)
 spel.setup()
 speelhal.run()

De camera instellen

Om een ​​camera aan het spel toe te voegen, maak je een Camera klasse die de positie en beweging van de camera beheert. Deze klasse heeft attributen zoals camera_x En camera_y om de coördinaten van de camera op te slaan.

klasCamera:
def__in het__(zelf):
 zelf.camera_x = 0
 zelf.camera_y = 0

Camerabeweging met toetsenbordinvoer

Pas vervolgens de spelregels aan on_key_press methode om camera op te nemen beweging op basis van de invoer van de speler. Wanneer de speler naar links of rechts beweegt, kunt u de positie van de camera overeenkomstig bijwerken. Pas ook de tekencode aan om rekening te houden met de positie van de camera bij het renderen van game-objecten.

klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 zelf.camera = Camera()
 self.player_x = breedte // 2
 self.player_y = hoogte // 2
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 self.player_x -= MOVEMENT_SPEED
 self.camera.camera_x -= MOVEMENT_SPEED
elif sleutel == arcade.sleutel. RECHTS:
 self.player_x += BEWEGING_SPEED
 self.camera.camera_x += BEWEGINGSSNELHEID
defon_draw(zelf):
 arcade.start_render()
 speelhal.set_viewport(
 zelf.camera.camera_x,
 zelf.camera.camera_x + SCREEN_WIDTH,
 zelf.camera.camera_y,
 zelf.camera.camera_y + SCREEN_HEIGHT
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arcade.kleur. ROOD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arcade.kleur. GROENTE)

Camerabeweging met muisinvoer

Naast toetsenbordinvoer kunt u ook camerabewegingen inschakelen op basis van muisinvoer. U kunt de speler bijvoorbeeld toestaan ​​de camera te pannen door het scherm te slepen. Om dit te bereiken, wijzigt u de on_mouse_drag methode om de positie van de camera bij te werken op basis van de beweging van de muis.

klasMijn spel(arcade. Raam):
defon_mouse_drag(zelf, x, y, dx, dy, knoppen, modifiers):
als knoppen == arcade. MUIS_BUTTON_LEFT:
 zelf.camera.camera_x -= dx
 self.camera.camera_y -= dy

Inclusief extra functies

Door een camera aan je game toe te voegen, gaat er een wereld aan mogelijkheden open voor extra functies en effecten. Hier zijn een paar voorbeelden van hoe je je spel verder kunt verbeteren met behulp van het camerasysteem.

Zoom-functionaliteit

Om zoomfunctionaliteit te implementeren, moet u een zoom variabele in de Camera klasse en wijzig de op_mouse_scroll methode om het zoomniveau bij te werken op basis van de beweging van het muiswiel. Je moet ook de set_viewport parameters om rekening te houden met het zoomniveau.

klasCamera:
def__in het__(zelf):
 zelf.camera_x = 0
 zelf.camera_y = 0
 zelf.zoom = 1.0
klasMijn spel(arcade. Raam):


defop_mouse_scroll(zelf, x, y, scroll_x, scroll_y):
 zelf.camera.zoom += scroll_y * 0.1
defon_draw(zelf):
 arcade.start_render()
 speelhal.set_viewport(
 zelf.camera.camera_x * zelf.camera.zoom,
 (self.camera.camera_x + SCREEN_WIDTH) * self.camera.zoom,
 zelf.camera.camera_y * zelf.camera.zoom,
 (self.camera.camera_y + SCREEN_HEIGHT) * self.camera.zoom
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arcade.kleur. ROOD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arcade.kleur. GROENTE)

Soepele camerabewegingen

Om vloeiendere camerabewegingen te bereiken, kunt u een interpolatietechniek introduceren die lineaire interpolatie (lerp) wordt genoemd. Wijzig de update methode om de camera geleidelijk naar een doelpositie te bewegen met behulp van lerp. Dit zorgt voor een vloeiend overgangseffect.

klasCamera:
def__in het__(zelf):
 zelf.camera_x = 0
 zelf.camera_y = 0
 zelf.target_x = 0
 zelf.target_y = 0
 zelf.lerp_speed = 0.1
defupdate(zelf):
 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)


klasMijn spel(arcade. Raam):


defupdate(zelf, delta_tijd):
 self.camera.target_x = self.player_x - SCREEN_WIDTH // 2
 self.camera.target_y = self.player_y - SCREEN_HEIGHT // 2
 zelf.camera.update()
defon_draw(zelf):
 arcade.start_render()
 speelhal.set_viewport(
 zelf.camera.camera_x,
 zelf.camera.camera_x + SCREEN_WIDTH,
 zelf.camera.camera_y,
 zelf.camera.camera_y + SCREEN_HEIGHT
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arcade.kleur. ROOD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arcade.kleur. GROENTE)

Camerabeperkingen

Om te voorkomen dat de camera bepaalde grenzen overschrijdt, kunt u beperkingen introduceren. U kunt bijvoorbeeld een minimale en maximale camerapositie definiëren en ervoor zorgen dat de camera binnen die grenzen blijft.

klasCamera:
def__in het__(zelf):
 zelf.camera_x = 0
 zelf.camera_y = 0
 zelf.min_x = 0
 zelf.max_x = 800
 zelf.min_y = 0
 zelf.max_y = 600
defupdate(zelf):
 zelf.camera_x = max (zelf.min_x, min (zelf.camera_x, zelf.max_x))
 self.camera_y = max (self.min_y, min (self.camera_y, self.max_y))


klasMijn spel(arcade. Raam):


defupdate(zelf, delta_tijd):
 self.camera.camera_x = self.player_x - SCREEN_WIDTH // 2
 self.camera.camera_y = self.player_y - SCREEN_HEIGHT // 2
 zelf.camera.update()
defon_draw(zelf):
 arcade.start_render()
 speelhal.set_viewport(
 zelf.camera.camera_x,
 zelf.camera.camera_x + SCREEN_WIDTH,
 zelf.camera.camera_y,
 zelf.camera.camera_y + SCREEN_HEIGHT
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arcade.kleur. ROOD)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arcade.kleur. GROENTE)

Dit zijn slechts enkele voorbeelden van hoe u het camerasysteem kunt gebruiken om extra functies en effecten toe te voegen aan uw Python Arcade-spellen.

Je kunt ook veel andere extra functies toevoegen aan je op Python gebaseerde games. U kunt de camera bijvoorbeeld zijn positie laten onthouden wanneer de speler gaat naar een ander niveau. Dit zorgt ervoor dat de weergave hetzelfde blijft bij de overgang tussen niveaus, wat een soepele en consistente ervaring voor de speler oplevert.

Best Practices voor een camerasysteem

Bij het implementeren van een camerasysteem in je Python Arcade-game, is het essentieel om best practices te volgen om optimale functionaliteit en een soepele spelerservaring te garanderen. Hier zijn enkele belangrijke richtlijnen om in gedachten te houden:

  • Vermijd overmatige camerabewegingen: Hoewel de camera dynamische elementen aan je game kan toevoegen, is het cruciaal om een ​​balans te vinden en overmatige camerabewegingen te vermijden. Het voortdurend verschuiven van de positie van de camera kan spelers desoriënteren en het voor hen een uitdaging maken om door de gamewereld te navigeren.
  • Test met verschillende resoluties en beeldverhoudingen: Het is essentieel om uw camerasysteem te testen op verschillende schermresoluties en beeldverhoudingen om er zeker van te zijn dat het goed werkt op verschillende apparaten en configuraties. Dit zal u helpen bij het identificeren van problemen met betrekking tot schaalvergroting van de viewport, objectpositionering of aanpassingen van de beeldverhouding.
  • Optimaliseer de weergave: Het camerasysteem kan de spelprestaties mogelijk beïnvloeden, vooral bij het weergeven van grote spelwerelden of talrijke objecten. Om de weergave te optimaliseren, bepaalt u welke objecten zich buiten het gezichtsveld van de camera bevinden en sluit u deze uit van weergave.
  • Randgevallen behandelen: let op randgevallen waarin de camera specifieke scenario's kan tegenkomen, zoals grenzen, botsingsdetectie of overlappende objecten. Zorg ervoor dat het camerasysteem deze gevallen gracieus afhandelt en zorgt voor vloeiende overgangen of passende visuele aanwijzingen om beperkingen of interacties met de spelomgeving aan te geven.

Door deze best practices te volgen, kunt u een robuust en gebruiksvriendelijk camerasysteem maken dat naadloos kan worden geïntegreerd in uw Python Arcade-games.

Maak games leuker met behulp van de camera

Door een camera toe te voegen aan je Python Arcade-games, kun je de onderdompeling en betrokkenheid van spelers aanzienlijk verbeteren. Of het nu gaat om het creëren van uitgestrekte gamewerelden, scherpstellen op kritieke gebieden of het volgen van bewegende objecten, het camerasysteem biedt een krachtig hulpmiddel voor game-ontwikkelaars.

Door gebruik te maken van camerabewegingen, zoomen en aanvullende effecten, kun je betoverende ervaringen creëren die spelers boeien en ervoor zorgen dat ze blijven terugkomen voor meer.