Reageren op invoer is van vitaal belang voor elke game, en het is goed om het toetsenbord te ondersteunen voor gebruikers die er de voorkeur aan geven. Ontdek hoe met de arcadebibliotheek van Python.

Toetsenbordinvoer is een essentieel onderdeel van game-ontwikkeling en het is van cruciaal belang om er effectief mee om te gaan om een ​​geweldige gebruikerservaring te bieden. De Arcade-bibliotheek biedt een eenvoudige en efficiënte manier om toetsenbordinvoer in uw Python-spellen te verwerken.

Een eenvoudig spel maken met een speler

De volledige code vind je in deze GitHub-opslagplaats.

Zorg ervoor dat u dat hebt gedaan voordat u begint met het omgaan met toetsenbordinvoer pip op uw apparaat geïnstalleerd. Gebruik deze opdracht om de arcadebibliotheek te installeren:

pip installeren arcade

Maak daarna het skelet van een eenvoudig spel:

importeren arcade
SCREEN_WIDTH = 640
SCHERM_HOOGTE = 480


klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte, "Mijn spel")
 arcade.set_background_color (arcade.kleur. WIT)







instagram viewer



defon_draw(zelf):
 arcade.start_render()


defupdate(zelf, delta_tijd):
doorgang
Mijn spel (SCREEN_WIDTH, SCREEN_HEIGHT)
speelhal.run()

Hierdoor ontstaat een venster met een witte achtergrond. Voeg vervolgens een speler toe aan je spel:

klasSpeler:
def__in het__(zelf, x, y):
 zelf.x = x
 zelf.y = y
 zelf.snelheid = 5
 zelf.radius = 20
deftekenen(zelf):
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. BLAUW)


defga naar links(zelf):
 zelf.x -= zelf.snelheid


defga naar rechts(zelf):
 zelf.x += zelf.snelheid


defverplaats_omhoog(zelf):
 zelf.y += zelf.snelheid
defNaar beneden verplaatsen(zelf):
 zelf.y -= zelf.snelheid

Dit creëert een eenvoudige speler met een blauwe cirkel. Je kunt deze speler aan je spel toevoegen door de Mijn spel klas:

importeren arcade
SCREEN_WIDTH = 640
SCHERM_HOOGTE = 480


klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte, "Mijn spel")
 arcade.set_background_color (arcade.kleur. WIT)
 self.player = Speler (SCREEN_WIDTH // 2, SCHERM_HOOGTE // 2)


defon_draw(zelf):
 arcade.start_render()
 self.player.draw()


defupdate(zelf, delta_tijd):
doorgang


defvoornaamst():
 Mijn spel (SCREEN_WIDTH, SCREEN_HEIGHT)
 speelhal.run()
als __naam__ == "__voornaamst__":
 voornaamst()

Nu heb je een speler in je spel die je op het scherm kunt tekenen.

Reageren op toetsaanslagen en releases

Om te reageren op gebruikersinvoer in uw game, moet u toetsaanslagen en -loslaten afhandelen. De Arcade-bibliotheek biedt twee methoden voor het afhandelen van deze gebeurtenissen: on_key_press En on_key_release.

Om deze methoden te gebruiken, moet u ze definiëren in uw arcade. Raam subklasse. Wanneer de speler een toets indrukt of loslaat, zal arcade de overeenkomstige methode uitvoeren en twee argumenten doorgeven: sleutel en modificaties. sleutel is een geheel getal dat de toetscode vertegenwoordigt van de ingedrukte of losgelaten toets. modificaties is een bitveld dat alle wijzigingstoetsen vertegenwoordigt die de speler ook heeft ingedrukt, zoals Shift of Control.

Hier is een voorbeeld van hoe te reageren op een toetsaanslag in uw game:

klasMijn spel(arcade. Raam):
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
# Verplaats speler naar links
elif sleutel == arcade.sleutel. RECHTS:
# Verplaats speler naar rechts
elif sleutel == arcade.sleutel. OMHOOG:
# Verplaats speler omhoog
elif sleutel == arcade.sleutel. OMLAAG:
# Verplaats speler naar beneden

Om te reageren op belangrijke releases, kunt u de on_key_release methode op dezelfde manier:

klasMijn spel(arcade. Raam):
defon_key_release(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
# Stop met het verplaatsen van de speler naar links
elif sleutel == arcade.sleutel. RECHTS:
# Stop met het verplaatsen van de speler naar rechts
elif sleutel == arcade.sleutel. OMHOOG:
# Stop met het verplaatsen van de speler
elif sleutel == arcade.sleutel. OMLAAG:
# Stop met het naar beneden verplaatsen van de speler

Het is belangrijk op te merken dat vastleggen gebruikersinvoer in pygame vereist handmatige gebeurteniscontrole binnen je gameloop. Aan de andere kant roept de Arcade-bibliotheek automatisch relevante methoden op wanneer de speler een toets indrukt of loslaat. Dit betekent dat u niet handmatig hoeft te controleren op belangrijke gebeurtenissen in uw game-loop, waardoor u het gedoe van extra code bespaart.

De verwerking van toetsenbordinvoer aanpassen aan de behoeften van uw spel

De Arcade-bibliotheek biedt vele manieren om toetsenbordinvoer aan te passen. Misschien wil je de toetscombinaties voor je spel wijzigen of de speler toestaan ​​zijn eigen toetscombinaties aan te passen.

U kunt dit doen door een woordenboek te definiëren key_map die elke sleutel toewijst aan de overeenkomstige methode van het spelerobject. Om de speler toe te staan ​​zijn toetscombinaties aan te passen, kunt u een instellingenmenu toevoegen dat de key_map woordenboek op basis van de voorkeuren van de speler.

Hier is een voorbeeld:

klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte, titel):
 super().__init__(breedte, hoogte, titel)
 zelf.speler = Speler(100, 100)
 zelf.key_map = {
 arcade.sleutel. LINKS: self.player.move_left,
 arcade.sleutel. RECHTS: self.player.move_right,
 arcade.sleutel. UP: self.player.move_up,
 arcade.sleutel. DOWN: self.player.move_down
 }


defon_key_press(zelf, sleutel, modifiers):
als sleutel in zelf.key_map:
 zelf.key_map[key]()
defon_key_release(zelf, sleutel, modifiers):
als sleutel in zelf.key_map:
 self.key_map[toets + 1]()

Reageer in realtime op gebruikersinvoer

In realtime reageren op gebruikersinvoer is een essentieel aspect van het maken van een boeiende game. Door de tijd te nemen om de toetsenbordinvoer in uw spel goed te verwerken, kunt u een boeiender en aantrekkelijker spel creëren meeslepende ervaring voor je spelers, en laat je game uiteindelijk opvallen in een drukke marktplaats.