Manipulando entradas de teclado em jogos Python da biblioteca Arcade

A entrada do teclado é uma parte essencial do desenvolvimento do jogo e é crucial lidar com isso de maneira eficaz para fornecer uma ótima experiência ao usuário. A biblioteca Arcade fornece uma maneira direta e eficiente de lidar com a entrada do teclado em seus jogos Python.

Criando um jogo simples com um jogador

Você pode encontrar o código completo em este repositório do GitHub.

Antes de mergulhar no manuseio das entradas do teclado, certifique-se de ter pip instalado no seu dispositivo. Use este comando para instalar a biblioteca arcade:

pip instalar fliperama

Depois disso, crie o esqueleto de um jogo simples:

importar videogames
SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
aulaMeu jogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura, "Meu jogo")
 arcade.set_background_color (arcade.color. BRANCO)
defon_draw(auto):
 arcade.start_render()
defatualizar(auto, delta_time):
passar





instagram viewer
Meujogo (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()

Isso cria uma janela com fundo branco. Em seguida, adicione um jogador ao seu jogo:

aulaJogador:
def__iniciar__(eu, x, y):
 auto.x = x
 self.y = y
 auto.velocidade = 5
 self.radius = 20
defempate(auto):
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. AZUL)
defMova para a esquerda(auto):
 self.x -= self.speed
defmove_right(auto):
 self.x += self.speed
defsubir(auto):
 self.y += self.speed
defmove_down(auto):
 self.y -= self.speed

Isso cria um jogador simples com um círculo azul. Você pode adicionar este jogador ao seu jogo modificando o Meu jogo aula:

importar videogames
SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
aulaMeu jogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura, "Meu jogo")
 arcade.set_background_color (arcade.color. BRANCO)
 self.player = Jogador (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
defon_draw(auto):
 arcade.start_render()
 self.player.draw()
defatualizar(auto, delta_time):
passar
defprincipal():
 Meujogo (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
se __nome__ == "__principal__":
 principal()

Agora você tem um jogador em seu jogo que pode desenhar na tela.

Respondendo a teclas pressionadas e liberadas

Para responder à entrada do usuário em seu jogo, você precisa lidar com pressionamentos e liberações de teclas. A biblioteca do Arcade fornece dois métodos para lidar com esses eventos: on_key_press e on_key_release.

Para usar esses métodos, você precisa defini-los em seu videogames. Janela subclasse. Quando o jogador pressiona ou solta uma tecla, o arcade executará o método correspondente, passando a ele dois argumentos: chave e modificadores. chave é um número inteiro que representa o código da tecla pressionada ou liberada. modificadores é um campo de bits que representa quaisquer teclas modificadoras que o jogador também pressionou, como Shift ou Control.

Aqui está um exemplo de como responder a um pressionamento de tecla em seu jogo:

aulaMeu jogo(videogames. Janela):
defon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
# Move o jogador para a esquerda
elif chave == arcade.key. CERTO:
# Move o jogador para a direita
elif chave == arcade.key. ACIMA:
# Move o jogador para cima
elif chave == arcade.key. ABAIXO:
# Move o jogador para baixo

Para responder a lançamentos de teclas, você pode definir o on_key_release método da mesma forma:

aulaMeu jogo(videogames. Janela):
defon_key_release(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
# Pare de mover o jogador para a esquerda
elif chave == arcade.key. CERTO:
# Pare de mover o jogador para a direita
elif chave == arcade.key. ACIMA:
# Pare de mover o jogador para cima
elif chave == arcade.key. ABAIXO:
# Pare de mover o jogador para baixo

É importante observar que a captura entrada do usuário no pygame requer verificação manual de eventos no loop do jogo. Por outro lado, a biblioteca Arcade invoca automaticamente métodos relevantes quando o jogador pressiona ou solta uma tecla. Isso significa que você não precisa verificar manualmente os principais eventos no loop do jogo, evitando o incômodo de código extra.

Personalizando o manuseio de entrada do teclado para atender às necessidades do seu jogo

A biblioteca do Arcade fornece muitas maneiras de personalizar a entrada do teclado. Você pode querer alterar as combinações de teclas do seu jogo ou permitir que o jogador personalize suas próprias combinações de teclas.

Você pode fazer isso definindo um dicionário mapa_chave que mapeia cada chave para o método correspondente do objeto do jogador. Para permitir que o jogador personalize suas combinações de teclas, você pode adicionar um menu de configurações que modifica o mapa_chave dicionário baseado nas preferências do jogador.

Aqui está um exemplo:

aulaMeu jogo(videogames. Janela):
def__iniciar__(auto, largura, altura, título):
 super().__init__(largura, altura, título)
 self.jogador = Jogador(100, 100)
 self.key_map = {
 arcade.key. ESQUERDA: self.player.move_left,
 arcade.key. DIREITA: self.player.move_right,
 arcade.key. PARA CIMA: self.player.move_up,
 arcade.key. PARA BAIXO: self.player.move_down
 }
defon_key_press(auto, chave, modificadores):
se chave em self.key_map:
 self.key_map[chave]()
defon_key_release(auto, chave, modificadores):
se chave em self.key_map:
 self.key_map[chave + 1]()

Responda às entradas do usuário em tempo real

Responder à entrada do usuário em tempo real é um aspecto essencial da criação de um jogo envolvente. Ao reservar um tempo para lidar adequadamente com a entrada do teclado em seu jogo, você pode criar um ambiente mais envolvente e experiência imersiva para seus jogadores e, finalmente, fazer seu jogo se destacar em um ambiente lotado Mercado.