Att svara på input är avgörande för alla spel, och det är bra att stödja tangentbordet för användare som föredrar det. Ta reda på hur med Pythons arkadbibliotek.

Tangentbordsinmatning är en viktig del av spelutveckling, och det är avgörande att hantera det effektivt för att ge en fantastisk användarupplevelse. Arcade-biblioteket ger ett enkelt och effektivt sätt att hantera tangentbordsinmatning i dina Python-spel.

Skapa ett enkelt spel med en spelare

Du hittar hela koden i denna GitHub-repo.

Innan du dyker in i hanteringen av tangentbordsingångar, se till att du har pip installerad i din enhet. Använd detta kommando för att installera arkadbiblioteket:

pip installera arkad

Efter det skapar du skelettet av ett enkelt spel:

importera arkad
SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480


klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
 super().__init__(bredd, höjd, "Mitt spel")
 arcade.set_background_color (arcade.color. VIT)


defon_draw(själv):
 arcade.start_render()


defuppdatering(själv, delta_tid):
passera
MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
instagram viewer

Detta skapar ett fönster med vit bakgrund. Lägg sedan till en spelare i ditt spel:

klassSpelare:
def__i det__(själv, x, y):
 själv.x = x
 själv.y = y
 själv.hastighet = 5
 self.radius = 20
defdra(själv):
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. BLÅ)


defflytta vänster(själv):
 self.x -= self.speed


defflytta höger(själv):
 self.x += self.speed


defflytta upp(själv):
 self.y += self.speed
defflytta ner(själv):
 self.y -= self.speed

Detta skapar en enkel spelare med en blå cirkel. Du kan lägga till den här spelaren i ditt spel genom att ändra Mitt spel klass:

importera arkad
SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480


klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
 super().__init__(bredd, höjd, "Mitt spel")
 arcade.set_background_color (arcade.color. VIT)
 self.player = Spelare (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)


defon_draw(själv):
 arcade.start_render()
 self.player.draw()


defuppdatering(själv, delta_tid):
passera


defhuvud():
 MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
om __namn__ == "__huvud__":
 main()

Nu har du en spelare i ditt spel som du kan rita på skärmen.

Svara på knapptryckningar och släpp

För att svara på användarinput i ditt spel måste du hantera knapptryckningar och släpp. Arcade-biblioteket tillhandahåller två metoder för att hantera dessa händelser: on_key_press och on_key_release.

För att använda dessa metoder måste du definiera dem i din arkad. Fönster underklass. När spelaren trycker på eller släpper en tangent kommer arcade att köra motsvarande metod och skicka två argument till den: tangent och modifierare. nyckel är ett heltal som representerar nyckelkoden för den nedtryckta eller släppta tangenten. modifierare är ett bitfält som representerar alla modifieringstangenter som spelaren också tryckte på, som Shift eller Control.

Här är ett exempel på hur du svarar på en knapptryckning i ditt spel:

klassMitt spel(arkad. Fönster):
defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
# Flytta spelaren åt vänster
elif nyckel == arkad.nyckel. HÖGER:
# Flytta spelaren åt höger
elif nyckel == arkad.nyckel. UPP:
# Flytta upp spelaren
elif nyckel == arkad.nyckel. NER:
# Flytta ner spelaren

För att svara på nyckelutgåvor kan du definiera on_key_release metod på samma sätt:

klassMitt spel(arkad. Fönster):
defon_key_release(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
# Sluta flytta spelaren åt vänster
elif nyckel == arkad.nyckel. HÖGER:
# Sluta flytta spelaren rätt
elif nyckel == arkad.nyckel. UPP:
# Sluta flytta upp spelaren
elif nyckel == arkad.nyckel. NER:
# Sluta flytta ner spelaren

Det är viktigt att notera att fånga användarinmatning i pygame kräver manuell händelsekontroll i din spelloop. Å andra sidan anropar Arcade-biblioteket automatiskt relevanta metoder när spelaren trycker eller släpper en tangent. Detta innebär att du inte behöver leta manuellt efter nyckelhändelser i din spelloop, vilket sparar dig besväret med extra kod.

Anpassa tangentbordsinmatningshantering för att passa ditt spels behov

Arcade-biblioteket erbjuder många sätt att anpassa tangentbordsinmatning. Du kanske vill ändra nyckelbindningarna för ditt spel eller låta spelaren anpassa sina egna nyckelbindningar.

Du kan göra detta genom att definiera en ordbok key_map som mappar varje nyckel till motsvarande metod för spelarobjektet. För att låta spelaren anpassa sina nyckelbindningar kan du lägga till en inställningsmeny som ändrar key_map ordbok baserad på spelarens preferenser.

Här är ett exempel:

klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd, titel):
 super().__init__(bredd, höjd, titel)
 self.player = Spelare(100, 100)
 self.key_map = {
 arcade.key. VÄNSTER: self.player.move_left,
 arcade.key. HÖGER: self.player.move_right,
 arcade.key. UPP: self.player.move_up,
 arcade.key. NED: self.player.move_down
 }


defon_key_press(själv, nyckel, modifierare):
om nyckel i self.key_map:
 self.key_map[nyckel]()
defon_key_release(själv, nyckel, modifierare):
om nyckel i self.key_map:
 self.key_map[tangent + 1]()

Svara på användarinmatningar i realtid

Att svara på användarinput i realtid är en viktig aspekt för att skapa ett engagerande spel. Genom att ta dig tid att korrekt hantera tangentbordsinmatning i ditt spel kan du skapa en mer engagerande och uppslukande upplevelse för dina spelare, och i slutändan få ditt spel att sticka ut i en fullsatt marknad.