A biblioteca Arcade do Python cobre você, desde as animações mais simples baseadas em cores até a modelagem complexa de partículas.

A animação desempenha um papel vital no aprimoramento do apelo visual e do envolvimento dos videogames. A biblioteca Arcade é uma estrutura Python para criar jogos 2D. Ele oferece uma maneira direta e eficaz de incorporar animações em seus projetos de jogos.

Você pode usar a biblioteca Arcade para criar animações básicas de movimento e animações sincronizadas com eventos do jogo.

Crie um jogo simples

Antes de começar, certifique-se de ter pip instalado no seu dispositivo. Use este comando para instalar a biblioteca arcade:

pip instalar fliperama

Depois disso, crie um arquivo Python chamado simple-game.py e comece configurando um jogo onde o jogador pode se mover para a esquerda e para a direita.

O código usado neste artigo está disponível neste Repositório GitHub e é gratuito para você usar sob a licença do MIT.

Usando a biblioteca do Arcade, você pode criar uma janela, configurar o ambiente do jogo e controlar a entrada do jogador. Aqui está um trecho de código para começar:

instagram viewer 

importar videogames
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


aulaMeu jogo(videogames. Janela):
def__iniciar__(auto):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Meu jogo")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2


defon_draw(auto):
 arcade.start_render()
 col = arcade.color. AZUL
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col)


defon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
 self.player_x -= 10
elif chave == arcade.key. CERTO:
 self.player_x += 10


defprincipal():
 jogo = MeuJogo()
 arcade.run()
se __nome__ == "__principal__":
 principal()

Adicionar animação de movimento básico

Agora, dê um passo adiante em seu jogo e adicione animação de movimento básico ao objeto do jogador. Para animar o jogador em movimento, crie 3 círculos diferentes e itere entre eles sequencialmente quando o jogador começar a se mover. Aqui está o snippet de código atualizado para o motion-animation.py arquivo:

aulaMeu jogo(videogames. Janela):
def__iniciar__(auto):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Meu jogo")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
defon_draw(auto):
 arcade.start_render()
 col1 = arcade.color. AZUL
 col2 = arcade.color. VERDE
 col3 = arcade.color. VERMELHO


se self.frame_counter < 10:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,col1 )
elif self.frame_counter < 20:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col2 )
outro:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col3)
defon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
 self.player_x -= 10
 self.frame_counter = (self.frame_counter + 1) % 30
elif chave == arcade.key. CERTO:
 self.player_x += 10
 self.frame_counter = (self.frame_counter + 1) % 30

Aqui está um exemplo de quadro de saída:

Controlando a velocidade e a direção da animação

Para controlar a velocidade da animação, você pode introduzir um sistema de taxa de quadros. Você também pode alterar a ordem dos quadros dependendo da direção do movimento do jogador. Quando o jogador se move da esquerda para a direita, os quadros serão exibidos na ordem inversa.

Aqui está o trecho de código modificado para o taxa de quadros.py arquivo:

aulaMeu jogo(videogames. Janela):
def__iniciar__(auto):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Meu jogo")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
 col1 = arcade.color. AZUL
 col2 = arcade.color. VERDE
 col3 = arcade.color. VERMELHO
 self.frames = [col1, col2, col3]
 self.frame_rate = 10
defon_draw(auto):
 arcade.start_render()
 frame_index = self.frame_counter // self.frame_rate % len (self.frames)


se self.player_x < SCREEN_WIDTH // 2:
 frame_index = len (self.frames) - 1 - frame_index


 index = self.frames[frame_index]
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, índice)
defon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
 self.player_x -= 10
 self.frame_counter += 1
elif chave == arcade.key. CERTO:
 self.player_x += 10
 self.frame_counter += 1

Use o operador de módulo % com len (self.frames) para garantir que o frame_index sempre permanece dentro do intervalo de quadros disponíveis. Isso evita que o IndexError ocorra quando a animação percorrer os quadros.

Ajusta a taxa de quadros value para controlar a velocidade da animação e aproveitar o movimento animado dos objetos do jogo.

Incluindo Recursos Adicionais

A biblioteca do Arcade fornece vários recursos para aprimorar suas animações.

Efeitos de partículas

Você pode criar efeitos de partículas, como explosões ou fumaça, para adicionar realismo ao seu jogo. Crie um arquivo chamado partícula.py e adicione o código abaixo para uma implementação simples do sistema de partículas usando Python e a biblioteca Arcade:

importar videogames
importar aleatório
# Dimensões da tela
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Cores
BRANCO = (255, 255, 255)


# Classe de partícula
aulaPartícula:
def__iniciar__(auto, x, y, dx, dy, raio, cor, tempo de vida):
 auto.x = x
 self.y = y
 self.dx = dx
 self.dy = dy
 self.radius = raio
 self.color = cor
 self.lifespan = tempo de vida


defatualizar(auto):
 self.x += self.dx
 self.y += self.dy
 self.lifespan -= 1


defempate(auto):
 arcade.draw_circle_filled (self.x, self.y, self.radius, self.color)


# classe de jogo
aulaMeu jogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura, "Exemplo de partícula")
 self.particles = []


defconfigurar(auto):
# Criar partículas
para _ em faixa(100):
 x = random.randrange (SCREEN_WIDTH)
 y = random.randrange (SCREEN_HEIGHT)
 dx = random.uniform(-1, 1)
 dy = random.uniform(-1, 1)
 raio = random.uniform(2, 5)
 color = arcada.color. BRANCO
 tempo de vida = random.randint(60, 120)
 partícula = Partícula (x, y, dx, dy, raio, cor, tempo de vida)
 self.particles.append (partícula)


defon_draw(auto):
 arcade.start_render()
para partícula em auto.partículas:
 partícula.desenho()


defatualizar(auto, delta_time):
para partícula em auto.partículas:
 partícula.atualização()


se partícula.lifespan <= 0:
 self.particles.remove (partícula)


defprincipal():
 jogo = MeuJogo (SCREEN_WIDTH, SCREEN_HEIGHT)
 game.setup()
 arcade.run()
se __nome__ == "__principal__":
 principal()

Você deve ver uma animação que envolve muitas partículas em movimento:

Animações interativas

Implemente animações interativas que respondam à entrada do usuário ou aos eventos do jogo. Por exemplo, quando o jogador interage com um objeto, ele pode ser animado, mudar de cor ou se transformar de alguma forma. Essas animações interativas fornecem feedback e aumentam o envolvimento do jogador com o jogo. Aqui está o código para o animação-interativa.py arquivo:

importar videogames
# Dimensões da tela
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Cores
BRANCO = (255, 255, 255)
VERMELHO = (255, 0, 0)


aulaMeu jogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura, "Animação interativa")
 self.player_x = 400
 self.player_y = 300
 self.player_radius = 30
 self.player_color = VERMELHO
 self.animation_radius = 60
 self.animation_color = BRANCO
 self.animation_active = Falso


defon_draw(auto):
 arcade.start_render()


 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.player_radius,
 self.player_color)


se self.animation_active:
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.animation_radius,
 self.animation_color)


defon_mouse_press(auto, x, y, botão, modificadores):
se (self.player_x - self.player_radius <=
 x <= self.player_x + self.player_radius e
 self.player_y - self.player_radius <=
 y <= self.player_y + self.player_radius
 ):
 self.animation_active = Verdadeiro


defatualizar(auto, delta_time):
se self.animation_active:
 self.animation_radius += 1


se self.animation_radius > 100:
 self.animation_active = Falso
 self.animation_radius = 0


defprincipal():
 jogo = MeuJogo (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
se __nome__ == "__principal__":
 principal()

Substitua os métodos necessários, como on_draw, on_mouse_press, e atualizar, para lidar com o desenho do player e a animação, lidar com cliques do mouse e atualizar a animação.

Para desenhar o jogador, use o arcade.draw_circle_filled função, que leva o (x, y) coordenadas do centro, do raio e da cor como argumentos. A função draw_circle_filled é uma das Ferramentas do Arcade que você pode usar para desenhar recursos do jogo. Nesse caso, você pode desenhar um círculo crescente variando o raio ao longo do tempo.

O on_mouse_press O método é executado quando o usuário clica no mouse. Ele verifica se as coordenadas do mouse estão dentro dos limites do objeto do jogador e ativa a animação se estiverem.

Práticas recomendadas para adicionar animação

Ao adicionar animação aos seus jogos, considere as seguintes práticas recomendadas:

Limite o número de animações

Ter muitas animações com muitos quadros pode afetar o desempenho. Considere minimizar o número de animações ou quadros necessários, especialmente para elementos não críticos no jogo. Simplificar as animações pode ajudar a manter uma taxa de quadros consistente e otimizar o uso de recursos.

Objetos semelhantes de renderização em lote

Agrupe objetos semelhantes que compartilham os mesmos quadros de animação e texturas e os renderize como um lote. O processamento em lote reduz o número de chamadas de desenho, resultando em melhor desempenho. Essa técnica é particularmente útil ao animar objetos que usam a mesma folha de sprite ou têm sequências de animação semelhantes.

Use interpolação para animação suave

Aplique técnicas de interpolação, como interpolação linear (lerping), para obter transições de animação suaves. A interpolação calcula valores intermediários entre quadros-chave de animação para criar movimentos fluidos. Essa abordagem evita saltos repentinos ou movimentos bruscos entre os quadros, resultando em animações visualmente mais atraentes.

Considere a velocidade e o tempo da animação

Experimente diferentes velocidades e tempo de animação para encontrar o equilíbrio certo para o seu jogo. Ajuste a duração do quadro ou use diferentes sequências de animação para criar variações de velocidade, aceleração ou desaceleração. Esses ajustes podem adicionar profundidade e personalidade às animações do seu jogo.

Teste e otimize

Teste regularmente suas animações em diferentes dispositivos e monitore o desempenho. Procure possíveis gargalos ou lentidões e otimize de acordo. Esse processo ajuda a garantir experiências de animação suaves e consistentes em uma ampla variedade de dispositivos.

Torne os jogos mais envolventes com animação

Adicionar animações aos seus jogos pode melhorar significativamente o envolvimento e a imersão do jogador. As animações fornecem feedback visual para as ações do jogador, tornando a jogabilidade mais intuitiva e agradável. Eles dão vida aos mundos dos jogos, criando uma sensação de realismo e emoção.

Seja um personagem correndo, um objeto explodindo ou um simples efeito de transição, as animações contribuem para uma experiência de jogo mais dinâmica e cativante.