Como criar um jogo 2D com Python e uma biblioteca de arcade

Olá Habr! Apresento a você a tradução do artigo Como criar um jogo 2D com Python e a biblioteca Arcade de Paul Vincent Craven

Como criar um jogo 2D com Python e uma biblioteca de arcade

Aprenda como começar com o Arcade, uma biblioteca Python fácil de usar para criar videogames 2D.

Phython é uma ótima linguagem para quem está aprendendo programação, e é ideal para quem quer "fazer alguma coisa" e não gastar muito tempo no código padrão. O Arcade é uma biblioteca Python para a criação de videogames 2D, que é fácil de usar e muito eficaz quando você ganha experiência. Neste artigo, explicarei como começar a usar o Python e o Arcade para programar videogames.

Comecei o desenvolvimento no Arcade depois de ensinar os alunos a usar a biblioteca PyGame . Eu ensinei pessoalmente usando o PyGame por quase 10 anos e desenvolvi o ProgramArcadeGames .com para ensinar on-line. O PyGame é ótimo, mas no final senti vontade de perder tempo tentando cobrir erros que nunca foram corrigidos .
Eu estava preocupado em ensinar coisas como o loop de eventos , que não era mais a maneira como codificamos. Eu tinha uma seção inteira na qual expliquei por que as coordenadas Y foram invertidas. Como o PyGame raramente foi atualizado e é baseado na antiga biblioteca SDL 1, e não em algo mais moderno, como o OpenGL , eu não tinha muita esperança no futuro.

Eu queria criar uma biblioteca que fosse mais fácil de usar, mais poderosa e usasse alguns dos novos recursos do Python 3, como decoradores e dicas de tipo. Isto é uma arcada. E aqui está como começar.

Instalação

O Arcade, como muitos outros pacotes, está disponível no PyPi , o que significa que você pode instalar o Arcade usando o comando pip (ou comando pipenv). Se você já possui o Python instalado, provavelmente poderá abrir um prompt de comando no Windows e digitar:

pip install arcade 

Ou no tipo MacOS e Linux:

 pip3 install arcade 

Para instruções de instalação mais detalhadas, você pode consultar a documentação de instalação do Arcade .

Desenho simples

Você pode abrir a janela e criar desenhos simples com apenas algumas linhas de código. Vamos criar um exemplo que desenhe um smiley, como mostra a imagem abaixo:

O algoritmo abaixo mostra como você pode usar os comandos de desenho do Arcade para fazer isso. Observe que você não precisa saber como usar classes ou mesmo definir funções. Programar com feedback visual rápido é ótimo para quem deseja começar a aprender programação.

 import arcade # Set constants for the screen size SCREEN_WIDTH = 600 SCREEN_HEIGHT = 600 # Open the window. Set the window title and dimensions (width and height) arcade.open_window(SCREEN_WIDTH, SCREEN_HEIGHT, "Drawing Example") # Set the background color to white. # For a list of named colors see: # http://arcade.academy/arcade.color.html # Colors can also be specified in (red, green, blue) format and # (red, green, blue, alpha) format. arcade.set_background_color( arcade.color.WHITE) # Start the render process. This must be done before any drawing commands. arcade.start_render() # Draw the face x = 300 y = 300 radius = 200 arcade.draw_circle_filled( x, y, radius, arcade.color.YELLOW) # Draw the right eye x = 370 y = 350 radius = 20 arcade.draw_circle_filled( x, y, radius, arcade.color.BLACK) # Draw the left eye x = 230 y = 350 radius = 20 arcade.draw_circle_filled( x, y, radius, arcade.color.BLACK) # Draw the smile x = 300 y = 280 width = 120 height = 100 start_angle = 190 end_angle = 350 arcade.draw_arc_outline( x, y, width, height, arcade.color.BLACK, start_angle, end_angle, 10) # Finish drawing and display the result arcade.finish_render() # Keep the window open until the user hits the 'close' button arcade.run() 

Uso da função

Obviamente, escrever código em um contexto global não é uma boa forma. Felizmente, é fácil melhorar seu programa com recursos. Aqui podemos ver um exemplo de desenho de pinheiro em um local específico (x, y) usando a função:

 def draw_pine_tree(x, y) : """ This function draws a pine tree at the specified location. """ # Draw the triangle on top of the trunk. # We need three x, y points for the triangle. arcade.draw_triangle_filled( x + 40, y, # Point 1 x, y - 100, # Point 2 x + 80, y - 100, # Point 3 arcade.color.DARK_GREEN) # Draw the trunk arcade.draw_lrtb_rectangle_filled( x + 30, x + 50, y - 100, y - 140 , arcade.color.DARK_BROWN) 

Para um exemplo completo, consulte o desenho com funções .

Um programador mais experiente saberá que os programas gráficos modernos primeiro carregam informações gráficas na placa de vídeo e, em seguida, solicitam à placa de vídeo que as desenhe posteriormente como um pacote. O Arcade também suporta isso. Desenhar 10.000 retângulos individualmente leva cerca de .800 segundos. Desenha-los como um pacote leva menos de 0,001 segundos.

classe de janela

Programas maiores geralmente herdam da classe Window ou usam decoradores . Isso permite que o programador escreva código para lidar com desenho, atualização e processamento de entrada do usuário. O modelo para iniciar o programa da janela é mostrado abaixo.

 import arcade SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 class MyGame( arcade.Window): """ Main application class. """ def __init__(self, width, height) : super( ) .__init__(width, height) arcade.set_background_color( arcade.color.AMAZON) def setup( self) : # Set up your game here pass def on_draw(self) : """ Render the screen. """ arcade.start_render() # Your drawing code goes here def update(self, delta_time) : """ All the logic to move, and the game logic goes here. """ pass def main( ) : game = MyGame( SCREEN_WIDTH, SCREEN_HEIGHT) game.setup( ) arcade.run() if __name__ = = "__main__": main() 

A classe Window possui vários métodos que seus programas podem substituir para fornecer funcionalidade ao programa. Aqui estão alguns dos mais usados:

on_draw: todo o código para desenhar uma tela aparece aqui.
Atualização: todo o código para mover seus itens e executar a lógica do jogo está aqui. Isso é chamado cerca de 60 vezes por segundo.
on_key_press: manipula eventos quando uma tecla é pressionada, por exemplo, fornece velocidade ao player.
on_key_release: processa quando a tecla é liberada, aqui você pode parar o movimento do jogador.
on_mouse_motion: chamado sempre que o mouse se move.
on_mouse_press: chamado quando o botão do mouse é clicado.
set_viewport: esta função é usada em jogos de rolagem quando o seu mundo é muito maior do que o que você pode ver em uma tela. A chamada set_viewport permite que o programador defina qual parte deste mundo está atualmente visível.

Sprites

Sprites são uma maneira fácil de criar um objeto raster bidimensional no Arcade. O Arcade possui métodos que facilitam o desenho, o movimento e a animação de sprites. Você também pode usar sprites facilmente para detectar colisões entre objetos.

Criação de Sprite

Criar uma instância da classe Sprite Arcade a partir de gráficos é fácil. O programador precisa apenas do nome do arquivo de imagem para que o sprite se baseie e, opcionalmente, de um número, para aumentar ou diminuir a imagem. Por exemplo:

 SPRITE_SCALING_COIN = 0,2 coin = arcade.Sprite("coin_01.png", SPRITE_SCALING_COIN) 

Este código criará um sprite usando a imagem armazenada em coin_01.png. A imagem será reduzida para 20% da altura e largura originais.

Listas de sprites

Sprites são geralmente organizados em listas. Essas listas facilitam o gerenciamento de sprites. Os sprites da lista usarão o OpenGL para desenhar sprites em lote como um grupo. O código abaixo configura um jogo com um jogador e um monte de moedas que o jogador coleta. Usamos duas listas, uma para o jogador e outra para as moedas.

 def setup(self): """ Set up the game and initialize the variables. """ # Create the sprite lists self.player_list = arcade.SpriteList() self.coin_list = arcade.SpriteList() # Score self.score = 0 # Set up the player # Character image from kenney.nl self. player_sprite = arcade.Sprite("images/character.png", SPRITE_SCALING_PLAYER) self.player_sprite.center_x = 50 # Starting position self.player_sprite.center_y = 50 self.player_list.append(self.player_sprite) # Create the coins for i in range( COIN_COUNT): # Create the coin instance # Coin image from kenney.nl coin = arcade.Sprite("images/coin_01.png", SPRITE_SCALING_COIN) # Position the coin coin.center_x = random.randrange(SCREEN_WIDTH) coin.center_y = random.randrange(SCREEN_HEIGHT) # Add the coin to the lists self.coin_list.append(coin) 

Podemos facilmente desenhar todas as moedas nas listas de moedas:

 def on_draw(self): """ Draw everything """ arcade.start_render() self.coin_list.draw() self.player_list.draw() 

Detecção de colisão de Sprite

Detecção de colisão de Sprite
A função check_for_collision_with_list nos permite ver se um sprite encontra outro sprite na lista. Podemos usar isso para ver todas as moedas com as quais o sprite do jogador está em contato. Usando um loop simples, podemos nos livrar da moeda do jogo e aumentar nossa pontuação.

 def update(self, delta_time): # Generate a list of all coin sprites that collided with the player. coins_hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.coin_list) # Loop through each colliding sprite, remove it, and add to the score. for coin in coins_hit_list: coin.kill() self.score += 1 

Para um exemplo completo, consulte collect_coins.py .

Física dos jogos

Muitos jogos incluem algum tipo de física. Os mais simples são os programas de cima para baixo que impedem o jogador de atravessar paredes. Os profissionais de plataforma adicionam mais complexidade à gravidade e às plataformas móveis. Alguns jogos usam um mecanismo de física 2D completo com massa, atrito, molas e muito mais.

Jogos de cima para baixo

Para jogos simples de cima para baixo, o programa arcade precisa de uma lista de paredes pelas quais o jogador (ou qualquer outra coisa) não pode passar. Eu costumo chamar de wall_list. Em seguida, o mecanismo de física é criado no código de instalação da classe Window usando:

 self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list) 

Player_sprite recebe um vetor de movimento com dois atributos: change_x e change_y. Um exemplo simples disso é mover um jogador usando o teclado. Por exemplo, isso pode estar em um filho personalizado da classe Window:

 MOVEMENT_SPEED = 5 def on_key_press(self, key, modifiers) : """Called whenever a key is pressed. """ if key = = arcade.key.UP: self.player_sprite.change_y = MOVEMENT_SPEED elif key = = arcade.key.DOWN: self.player_sprite.change_y = -MOVEMENT_SPEED elif key = = arcade.key.LEFT: self.player_sprite.change_x = -MOVEMENT_SPEED elif key = = arcade.key.RIGHT: self.player_sprite.change_x = MOVEMENT_SPEED def on_key_release(self, key, modifiers) : """Called when the user releases a key. """ if key = = arcade.key.UP or key = = arcade.key.DOWN: self.player_sprite.change_y = 0 elif key = = arcade.key.LEFT or key = = arcade.key.RIGHT: selfplayer_sprite.change_x = 0 

Embora esse código defina a velocidade do player, ele não o move. No método de atualização da classe Window, ao chamar Physics_engine.update (), o jogador se moverá, mas não através das paredes.

 def update(self, delta_time): """ Movement and game logic """ self.physics_engine.update() 

Para um exemplo completo, consulte sprite_move_walls.py .

Platformers

Mudar para um jogo de plataformas com vista lateral é bastante simples. O programador só precisa mudar o mecanismo de física para PhysicsEnginePlatformer e adicionar a constante gravitacional.

 self.physics_engine = arcade.PhysicsEnginePlatformer(self.player_sprite, self.wall_list, gravity_constant= GRAVITY) 

Você pode usar um programa como o Tiled para colocar as peças / blocos que compõem o seu nível.

Para um exemplo, consulte sprite_tiled_map.py .

Para física 2D completa, você pode integrar a biblioteca PyMunk.

Aprenda com um exemplo

Uma das melhores maneiras de aprender é um exemplo. A Arcade Library possui uma longa lista de exemplos de programas que as pessoas podem usar para criar jogos. Cada um desses exemplos mostra o conceito de um jogo que os alunos pediram nas minhas aulas ou na Internet ao longo dos anos.

A execução de qualquer uma dessas demos é fácil após a instalação do Arcade. Cada um dos exemplos possui um comentário no início do programa com um comando que você pode inserir na linha de comandos para executar o exemplo, por exemplo:

 python -m arcade.examples.sprite_moving_platforms 

Breve informação

O Arcade permite iniciar a programação de gráficos e jogos com código fácil de entender. Muitos novos programadores criaram ótimos jogos logo após o início. Experimente!