### Animação de Salto

Para o salto, teremos duas animações: Como o jogador irá saltar e depois cair, precisamos criar duas animações para isso. A transição entre elas será baseada na "velocidade y" do jogador; se y for positivo, ele está saltando, e se y for negativo, ele está caindo. Podemos obter a velocidade y do componente Rigidbody2D anexado ao jogador.

```csharp
animator.SetFloat("JumpingForce", rb.velocity.y);
```
Este código atribui o valor para o parâmetro de transição entre o salto e a queda.

### Explicação do Código

```csharp
if (Input.GetKeyDown(KeyCode.Space) && isGrounded && animator.GetBool("isAttacking") == false)
{
    rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
    animator.SetBool("isJumping", true);
}

if (animator.GetBool("isJumping") == true && rb.velocity.y < 0 && isGrounded)
{
    animator.SetBool("isJumping", false);
}

animator.SetFloat("JumpingForce", rb.velocity.y);

isGrounded = Physics2D.Raycast(playerFeet.position, Vector2.down, 0.1f, groundLayer);
```

```csharp
if (Input.GetKeyDown(KeyCode.Space) && isGrounded && animator.GetBool("isAttacking") == false)
{
    // Code to execute when the conditions are met
}
```

Esta linha verifica se a tecla Espaço foi pressionada (`Input.GetKeyDown(KeyCode.Space)`), se o jogador está no chão (`isGrounded`) e se o jogador não está atacando atualmente (`animator.GetBool("isAttacking") == false`). Se todas as condições forem atendidas, o bloco de código a seguir será executado.

```csharp
rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
```

Esta linha adiciona uma força para cima ao componente Rigidbody (`rb`) anexado ao jogador, simulando um salto. A força aplicada é na direção para cima (`Vector2.up`) com magnitude definida por `jumpForce`, e é aplicada de forma impulsiva (`ForceMode2D.Impulse`).


```csharp
animator.SetBool("isJumping", true);
```

Esta linha define um parâmetro booleano **"isJumping"** no componente Animator como verdadeiro, acionando a animação de salto.


```csharp
if (animator.GetBool("isJumping") == true && rb.velocity.y < 0 && isGrounded)
{
    // Code to execute when the conditions are met
}
```

Esta linha verifica se o jogador está atualmente pulando (`animator.GetBool("isJumping") == true`), se a velocidade vertical do jogador é negativa (`rb.velocity.y < 0`) e se o jogador está no chão (`isGrounded`). Se todas as condições forem atendidas, o bloco de código a seguir será executado.


```csharp
animator.SetBool("isJumping", false);
```

Esta linha define o parâmetro booleano **"isJumping"** no componente Animator como falso, indicando que o jogador terminou de pular e cair e mudará sua animação para inativo.

```csharp
isGrounded = Physics2D.Raycast(playerFeet.position, Vector2.down, 0.1f, groundLayer);
```

Esta linha lança um raio para baixo a partir da posição dos pés do jogador (`playerFeet.position`) para detectar se o jogador está no chão. Retorna verdadeiro se o raio interceptar qualquer colisor na camada do chão dentro de uma distância de 0.1 unidades, atualizando a variável `isGrounded` de acordo.

Prepare-se para construir um incrível jogo de luta com animações legais e uma grande batalha contra um chefe! 
Aprenda o sistema de animação do Unity para criar movimentos suaves do jogador e ataques poderosos.
Mergulhe na IA inimiga, moldando seus comportamentos desde seguir até estados de fúria. Melhore seu jogo com elementos simples de UI, efeitos legais e sons. Finalmente, compartilhe seu jogo com outros para jogá-lo.

Neste capítulo, aprenderemos tudo sobre animações, como sincronizar animações com movimento e como fazer transições suaves entre animações.


Vamos criar um comportamento completo para o jogador e animá-lo. O jogador poderá se mover, pular e atacar usando diferentes técnicas, como o Rigidbody2D para movimento e gatilhos para ataques e interações.

Vamos criar a IA do Chefe e definir seu comportamento com base na proximidade do jogador. Quando o jogador estiver a uma longa distância, o Chefe enviará um projétil ou se moverá em direção ao jogador. Se o jogador estiver próximo, o Chefe atacará com sua arma. Além disso, quando a saúde do Chefe cair abaixo de 40%, ele entrará em um estado de fúria e desencadeará ataques diferentes e mais agressivos.

Implementaremos melhorias significativas no jogo, incluindo a adição de partículas e efeitos para melhorar a sensação geral. Além disso, criaremos elementos de UI, como o menu principal e a barra de saúde, e garantiremos que sejam controláveis. Por fim, exportaremos o jogo e faremos testes.

Vamos revisitar o jogo que criamos no curso anterior de Unity (Flappy Bird) e aprimorá-lo. Vamos adicionar geração aleatória, sincronizar o movimento do fundo com o jogador e mover obstáculos dinamicamente, criando uma experiência de jogo infinita.


Jogo de Luta no Unity

Finalizar Animação do Jogador

Animação de Salto

Explicação do Código