Personagens de movimento físico no desenvolvimento do jogo (2D)

Introdução

Sim, o nome parece estranho. "Papel esportivo". o que é isso? A razão para o nome é que, quando os motores físicos foram lançados, eles foram chamados de motores "dinâmicos" (porque lidam principalmente com respostas de colisão). Para usar o motor dinâmico para criar um controlador de personagem, muitas tentativas foram feitas, mas não é tão fácil quanto parece. Godot é uma das melhores implementações de controlador de personagem dinâmico que você pode encontrar (como visto na demonstração 2d / plataforma), mas usá-lo requer um nível considerável de habilidade e compreensão do mecanismo de física (ou tentativa e erro muito paciente).

Alguns motores de física, como Havok, parecem pensar que os controladores de personagens dinâmicos são a melhor escolha, enquanto outros motores de física (PhysX) estão mais dispostos a promover motores de cinemática.

Então qual é a diferença? :

Um controlador de personagem dinâmico usa um corpo rígido com um tensor infinito de inércia. Este é um corpo rígido que não pode ser girado. O mecanismo de física sempre faz os objetos se moverem e colidirem, e então resolver suas colisões juntos. Conforme mostrado na demonstração do jogo de plataforma, isso permite que o controlador de personagem dinâmico interaja perfeitamente com outros objetos físicos. No entanto, essas interações nem sempre são previsíveis. As colisões podem levar mais do que um quadro para serem resolvidas, portanto, algumas colisões parecem deslocar apenas uma pequena parte. Esses problemas podem ser resolvidos, mas certas habilidades são necessárias.
Presume-se que um controlador de personagem em movimento sempre comece em um estado de não colisão e sempre se moverá para um estado de não colisão. Se começar a colidir, tentará se soltar como um corpo rígido, mas esta é a exceção, não a regra. Isso torna seu controle e movimento mais previsíveis e fáceis de programar. No entanto, a desvantagem é que eles não podem interagir diretamente com outros objetos físicos, a menos que o código seja escrito manualmente.
Este breve tutorial se concentrará no controlador de personagem de movimento. Basicamente, essa é a maneira antiquada de lidar com conflitos (não necessariamente simplificada nos bastidores, mas bem escondida e apresentada como uma boa API simples).

Processo físico

Para gerenciar a lógica do corpo ou personagem em movimento, é sempre recomendável utilizar o processo físico, pois é chamado antes da etapa física e sua execução é sincronizada com o servidor físico, que é sempre chamado pelo mesmo número de vezes por segundo. Isso torna a forma como a física e o cálculo de movimento funcionam mais previsível do que usando processos convencionais. Se a taxa de quadros for muito alta ou muito baixa, o processo convencional pode aumentar ou perder a precisão.

using Godot;
using System;

public class PhysicsScript : KinematicBody2D
{
    
    
    public override void _PhysicsProcess(float delta)
    {
    
    
    }
}

Configuração de cena

Existem alguns testes para a cena aqui (do tutorial do tilemap) kbscene.zip. Vamos criar uma nova cena para o personagem. Use sprites de robô para criar uma cena como esta:

Você notará que há um ícone de aviso próximo ao nosso nó CollisionShape2D. Isso ocorre porque ainda não definimos uma forma para ele. Crie um novo CircleShape2D no atributo de forma de CollisionShape2D. Clique para ir para sua opção e definir o raio para 30:

Observação: conforme mencionado no tutorial de física anterior, o mecanismo de física não consegue lidar com a escala da maioria das formas (apenas polígonos de colisão, planos e segmentos de linha são válidos), portanto, sempre altere os parâmetros da forma (como o raio) em vez de dimensioná-la . O mesmo é verdadeiro para os próprios objetos móveis / rígidos / estáticos, porque suas proporções afetam as proporções da forma.

Agora, crie um script para o personagem, e o script usado como exemplo acima deve ser usado como base.

Finalmente, instancie a cena do personagem no mapa de blocos e use-a como a cena principal a ser executada quando o play for pressionado.

Características cinemáticas

Volte para a cena do personagem, abra o roteiro e a mágica começa! O corpo móvel não executa nenhuma operação por padrão, mas tem uma função útil chamada KinematicBody2D.move_and_collide (). Esta função usa Vector2 como parâmetro e, em seguida, tenta aplicar o movimento ao corpo em movimento. Se houver uma colisão, ela parará imediatamente quando ocorrer a colisão.

Então, vamos mover o sprite para baixo até que ele caia no chão:

using Godot;
using System;

public class PhysicsScript : KinematicBody2D
{
    
    
    public override void _PhysicsProcess(float delta)
    {
    
    
        // Move down 1 pixel per physics frame
        MoveAndCollide(new Vector2(0, 1));
    }
}

O resultado é que o personagem se moverá, mas parará imediatamente ao atingir o chão. Não é legal?

A próxima etapa é adicionar gravidade à mistura para que ela se comporte um pouco como um personagem normal do jogo:

using Godot;
using System;

public class PhysicsScript : KinematicBody2D
{
    
    
    const float gravity = 200.0f;
    Vector2 velocity;

    public override void _PhysicsProcess(float delta)
    {
    
    
        velocity.y += delta * gravity;

        var motion = velocity * delta;
        MoveAndCollide(motion);
    }
}

Agora o personagem desliza suavemente. Vamos caminhar para a esquerda e para a direita enquanto tocamos nas teclas de seta. Lembre-se de que o valor usado (pelo menos para velocidade) é pixels por segundo.

Isso pode adicionar suporte simples para caminhar pressionando à esquerda e à direita:

using Godot;
using System;

public class PhysicsScript : KinematicBody2D
{
    
    
    const float gravity = 200.0f;
    const int walkSpeed = 200;

    Vector2 velocity;

    public override void _PhysicsProcess(float delta)
    {
    
    
        velocity.y += delta * gravity;

        if (Input.IsActionPressed("ui_left"))
        {
    
    
            velocity.x = -walkSpeed;
        }
        else if (Input.IsActionPressed("ui_right"))
        {
    
    
            velocity.x = walkSpeed;
        }
        else
        {
    
    
            velocity.x = 0;
        }

        // We don't need to multiply velocity by delta because "MoveAndSlide" already takes delta time into account.

        // The second parameter of "MoveAndSlide" is the normal pointing up.
        // In the case of a 2D platformer, in Godot, upward is negative y, which translates to -1 as a normal.
        MoveAndSlide(velocity, new Vector2(0, -1));
    }
}

E experimente.

Este é um bom ponto de partida para jogos de plataforma. Você pode encontrar uma demonstração mais completa no zip de demonstração distribuído com o mecanismo ou https://github.com/godotengine/godot-demo-projects/tree/master/2d/kinematic_character .