Como criar animação 2D em Godot usando AnimatedSprite

No desenvolvimento de jogos, as animações desempenham um papel crucial na criação de uma experiência envolvente e imersiva para os jogadores. Adicionar animações 2D ao seu jogo Godot pode dar vida aos seus personagens e ambientes, tornando-os visualmente mais atraentes e interativos.

Felizmente, Godot fornece ferramentas e recursos poderosos para criar e controlar facilmente animações 2D.

Configurando o jogo Godot

Para começar, configure uma cena de jogo 2D básica em motor de jogo Godot. Crie uma nova cena e adicione um Corpo Cinemático2D nó como o personagem do jogador. Dentro de Corpo Cinemático2D, adicione um CollisionShape2D com uma forma de retângulo que representa os limites de colisão do jogador.

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

Além disso, adicione um Sprite animado node para lidar com as animações do jogador. Além disso, certifique-se de mapear as seguintes ações de entrada em seu Mapa de entrada:

Em seguida, escreva o código GDScript para controlar o movimento do jogador. Anexe o seguinte script ao Corpo Cinemático2D nó:

 extends KinematicBody2Dconst SPEED = 200func _physics_process (delta): varspeed = Vector2.ZERO if Input.is_action_pressed("move_left"): speed.x -= SPEED if Input.is_action_pressed("move_right"): velocidade.x += SPEED se Input.is_action_pressed("move_up"): velocidade.y -= SPEED se Input.is_action_pressed("move_down"): velocidade.y += SPEED velocidade = move_and_slide (velocidade)

Este script configura uma velocidade constante para o jogador e permite que ele se mova para a esquerda, direita, para cima e para baixo usando as teclas de seta ou WASD.

Adicionando SpriteSheet no AnimatedSprite

Agora, configure o Sprite animado para usar uma folha de sprite para animações. Selecione os Sprite animado nó e navegue até o Molduras seção na guia de propriedades do nó. Aqui, clique no Novos SpriteFrames botão.

Mude para o SpriteFrames guia localizada na parte inferior do editor Godot. No SpriteFrames guia, clique no Nova Animação botão. Crie animações como andar e parado adicionando quadros apropriados a cada animação.

Além disso, você tem a opção de criar outras animações, como tiro, salto e escalada para um jogo de plataforma. Depois disso, clique no botão Adicionar quadros do SpriteSheet botão para extrair automaticamente quadros individuais da folha de sprite.

Controlando animações usando GDScript

Agora que você configurou suas animações, pode controlá-las programaticamente usando GDScript.

Reproduzir e parar a animação

Controlar a reprodução das animações é essencial para proporcionar experiências dinâmicas e interativas em seu jogo. O Sprite animado node em Godot oferece métodos para reproduzir e parar as animações de acordo com a lógica do seu jogo.

Estender a Corpo Cinemático2D nó e lidar com o controle de animação dentro do _physics_process função. Você pode usar o play_animation e stop_animation entradas para acionar as ações de animação correspondentes.

 extends KinematicBody2Dfunc _physics_process (delta): # Reproduza a animação if Input.is_action_just_pressed("play_animation"): $AnimatedSprite.play() # Interrompa a animação e redefina para o primeiro quadro if Input.is_action_just_pressed("stop_animation"): $AnimatedSprite.stop() $AnimatedSprite.frame = 0

Ao mapear as ações de entrada apropriadas, você pode fornecer aos jogadores controle sobre a reprodução da animação em seu jogo.

Por exemplo, você pode ligar o play_animation ação a um pressionamento de botão ou um evento específico em seu jogo, permitindo ao jogador acionar uma sequência de animação em um momento desejado. Além disso, você pode encontrar música livre de direitos autorais para reproduzir enquanto a animação está em execução.

Da mesma forma, você pode acionar o stop_animation ações para parar completamente a animação.

Ao incorporar esses mecanismos de controle de animação, você pode adicionar profundidade e interatividade às animações do seu jogo, criando experiências mais envolventes e imersivas para seus jogadores.

Girando a Animação

Girar a animação pode adicionar interesse visual e variedade ao seu jogo. Você pode girar programaticamente o Sprite animado node para alterar a orientação da animação. Você pode aplicar a rotação em graus usando o girar () método.

 extends KinematicBody2Dfunc _physics_process (delta): if Input.is_action_just_pressed("rotate_animation"): # Gira a animação 45 graus no sentido horário $AnimatedSprite.rotate (deg2rad (45))

Ao pressionar os botões associados ao rotate_animation (você pode definir esta ação em seu mapa de entrada), o girar () método é chamado no Sprite animado nó. Ele gira o nó em 45 graus no sentido horário usando deg2rad() para converter os graus em radianos.

Lembre-se de que ele aplicará rotação a todo o Sprite animado nó, incluindo todos os quadros da animação. Portanto, se você deseja girar apenas quadros específicos, pode ser necessário dividi-los em partes separadas. Sprite animado nós ou usar outras técnicas, como inverter quadros individuais.

Invertendo a Animação

Inverter a animação horizontal ou verticalmente pode ser útil para refletir mudanças na direção do personagem. Em Godot, o Sprite animado O nó fornece propriedades para controlar a inversão.

Para inverter a animação horizontalmente, defina o flip_h propriedade do Sprite animado para verdadeiro. Isso irá espelhar a animação ao longo do eixo horizontal. Da mesma forma, definir o flip_v propriedade para verdadeiro irá espelhar a animação ao longo do eixo vertical.

 estende KinematicBody2Dfunc _physics_process (delta): if Input.is_action_just_pressed("flip_animation"): $AnimatedSprite.flip_h = true # ou $AnimatedSprite.flip_v = true para inversão vertical

Se o jogador pressionar o botão flip_animation ação de entrada, em seguida, defina o flip_h propriedade do Sprite animado para verdadeiro. Isso inverterá a animação horizontalmente.

Utilizando sinais no AnimatedSprite

Além de controlar as animações programaticamente, o Godot fornece um poderoso sistema de eventos chamado sinais. Os sinais permitem que você responda a eventos ou mudanças específicas que ocorrem durante a execução do seu jogo.

No caso de Sprite animado, há dois sinais importantes que você pode usar: animação_acabada() e frame_changed().

1. animation_finished () Sinal

O animação_acabada() O sinal é emitido quando a animação atinge o último quadro, seja durante uma única reprodução ou quando ela faz um loop. Esse sinal é útil quando você deseja executar ações ou acionar eventos quando uma animação é concluída.

 estende KinematicBody2Dfunc _ready(): $AnimatedSprite.connect("animation_finished", self, "_on_animation_finished")func _on_animation_finished(): # Executar ações ou disparar eventos print("Animação terminado!") # Código adicional aqui...

Conecte o animação_acabada() sinal do Sprite animado para o _on_animation_finished() método no mesmo script usando o método conectar() função.

Quando a animação terminar de tocar, você pode executar a lógica personalizada ou acionar outras funcionalidades usando o _on_animation_finished() método.

2. frame_changed() Sinal

O frame_changed() sinal é emitido sempre que o quadro atual da animação muda. Isso pode ocorrer quando a animação está sendo reproduzida ou quando você modifica programaticamente o quadro. Você pode usar este sinal para detectar mudanças de quadro e reagir de acordo.

 extends KinematicBody2Dfunc _ready(): $AnimatedSprite.connect("frame_changed", self, "_on_frame_changed")func _on_frame_changed(): # Execute ações com base no quadro atual var currentFrame = $AnimatedSprite.frame print("Current frame: ", currentFrame) # Código adicional aqui...

Conecte o frame_changed() sinal do Sprite animado para o _on_frame_changed() método no mesmo script. Quando o quadro muda, você pode acessar o quadro atual usando o _on_frame_changed() método e executar ações ou lógica com base no valor do quadro.

Ao utilizar sinais, você pode responder a eventos de animação, como conclusão ou mudanças de quadro, e incorporar comportamentos dinâmicos ou acionar ações específicas em seu jogo.

Torne os jogos Godot mais envolventes usando animações

Adicionar animações 2D aos seus jogos Godot pode melhorar muito a experiência geral do jogador. As animações dão vida aos personagens, tornando seus movimentos e ações visualmente mais atraentes. Ao incorporar animações para várias ações, como caminhar, correr, atacar e pular, você pode criar um ambiente de jogo dinâmico e imersivo.

Além disso, você também pode usar animações para fornecer feedback visual ao jogador. Esse feedback ajuda a tornar o jogo mais envolvente e responsivo, aprimorando o senso de controle e envolvimento do jogador.