Como faço uma aceleração simples no Unity?

Boa tarde, galera.
Baixei o Unity de novo e estou tentando aprender alguns conceitos básicos para recriar um jogo de navinha, e queria pedir ajuda para reproduzir a seguinte situação:

1 - Quando seguro a tecla 'up', o cubo desenvolve uma velocidade progressiva e acelera de zero até a sua velocidade máxima, em dois segundos;
2 - Quando solto a tecla 'up', o cubo inicia um processo de desaceleração até voltar a zero, mas essa desaceleração é mais lenta, de modo que não freie repentinamente.


Entendo que preciso (no mínimo) declarar as seguintes variáveis:

Velocidade máxima
taxa de aceleração
taxa de desaceleração

...Mas não faço a mínima ideia de como opero elas em C Sharp, e se isso é tão simples como espero que seja.

Não utilizo o Unit. Mas, você pode declarar variaveis em C++ ou C# assim:

Código:


double vel_max = 100;
double tx_acel = 2.0;
double tx_des  = 1.0;
double vel = 0;
if (botao_pressionado) {
   if (vel < vel_max)
   {
      vel += tx_acel;
      if (vel > vel_max) vel = vel_max;

} else {
   if (vel > 0) vel -= tx_des;
   if (vel < 0) vel = 0;
}


Para aplicar o vetor de velocidade na nave, genericamente seria:

Código:


x += cos(dir) * vel;
y += sin(dir) * vel;


Onde "dir" é a direção que a nave esta apontando.
Esse código é generico, mas dar pra "portar" pra unity.

Pseudo real code hehehhe.

Vou montar uma explicação simples assumindo que você ja tenha criado um novo script via Unity e aplicado ele a um gameObject:

De dentro do script você pode acessar algumas estruturas que representam o objeto aonde ele está sendo executado, os mais importantes sendo gameObject e transform.

GameObject representa o objeto na forma simples, e a partir dele você pode acessar/gerenciar outros componentes (outros scripts) do mesmo objeto
Todo gameObject possui um Transform, que mantem as informações de posição, escala e rotação do objeto.

Ou seja, se você quer movimentar uma nave, você quer influenciar a position do transform da nave. Isso pode ser feito diretamente (de dentro do script) ou usando um componente de física (ou seja, você manipula a física do objeto, e o Unity processa o resultado) .

ex:

Código:


void Start()
{
 // Jogando o objeto atual pra posição 0,0,0 assim que criado
 transform.position = Vector3.zero; // Vector3.zero = new Vector3(0,0,0)
 //
}


---

Vou deixar aqui o exemplo mais simples, utilizando o mapeamento de Input padrão do Unity e movendo o objeto diretamente, sem utilizar física.
Basta trocar "MoverNave" pelo nome do seu script.

Código:

using UnityEngine;

public class MoverNave : MonoBehaviour
{
    float velocidade = 5f; //A nave se moverá {{velocidade}} unidades por segundo


    // Start is called before the first frame update
    void Start()
    {

    }

    // Update is called once per frame
    void Update()
    {
        //Primeiro precisamos decidir a direção do movimento, baseado no input
        Vector3 direcao = ObterDirecao();

        //Move o objeto na direção desejada, {{velocidade}} unidades por segundo
        transform.position += direcao * velocidade * Time.deltaTime;

        // O método Update() ocorre diversas vezes por segundo.
        // Time.deltaTime ajuda a regular a velocidade de forma que ela aconteça gradualmente ao longo de 1 segundo.        
    }

    /// <summary>
    /// Obtem o input via Eixo (Input.Axis), configurado via janela "Input" no Unity
    /// </summary>
    /// <returns></returns>
    private Vector3 ObterDirecao()
    {
        //cada eixo pode ir de -1 a 1, modificando as direções Vector3.forward e Vector3.right conforme a leitura

        var direcao =  Vector3.forward * Input.GetAxis("Vertical") + Vector3.right * Input.GetAxis("Horizontal");

        // se a direção for fraca demais, ou nula (analogico foi puxado de menos, ou nenhuma tecla está sendo pressionada)
        // vamos deixar a nave imóvel, retornar uma direção neutra
        if (direcao.magnitude < 0.3f)
            return Vector3.zero;
        // A execução do código para após o return. Ou seja, se a direção for fraca, o código para aqui.

        // Se o código bater aqui, sabemos que a direcao é >=0.3f, ou seja, forte o suficiente
        // Entao vamos "normalizar" o vetor
        // Isso cria um novo vetor com "magnitude" = 1,  mantendo a mesma direção
        // magnitude significa módulo, força.
        // Da mesma força que ao multiplicar 1 por qualquer numero, obtemos o mesmo numero (x: 1x5 = 5),
        // Ao multiplicarmos este vetor com módulo 1 pela velocidade, teremos um vetor com módulo "velocidade" na direção do input
        return direcao.normalized;
    }
}


Versão sem frufrus:

Código:

using UnityEngine;

public class MoverNave : MonoBehaviour
{
    float velocidade = 5f;

    void Update()
    {
        Vector3 direcao = ObterDirecao();
        transform.position += direcao * velocidade * Time.deltaTime;  
    }

    private Vector3 ObterDirecao()
    {
        var direcao =  Vector3.forward * Input.GetAxis("Vertical") + Vector3.right * Input.GetAxis("Horizontal");

        if (direcao.magnitude < 0.3f)
            return Vector3.zero;

        return direcao.normalized;
    }
}

Mover o objeto diretamente é bom pra ter uma ideia de como o Unity opera, via Update() e atenuando coisas ao longo do tempo (Time.deltaTime), mas o jeito ideal é utilizar um componente de física. Sem isso pode se tornar muito trabalhoso, e custoso, na hora de verificar colisão com tiros, itens, etc etc.

Eu aconselharia aproximar o Unity com calma e utilizando alguma série de video aulas como referência, pois 80% deles vão passar por Input e Física, e mesmo que eles nao sejam SOBRE jogos de nave, o que você aprende num tipo de projeto serve pra todos.

Abraços!

Amigos, muito obrigado pelas respostas! Estou com o Unity aberto e tentarei reproduzir esses códigos agora mesmo! Andei ocupado nos últimos dias, por isso não vi as respostas de vocês em tempo.

Eu me distraí escrevendo a resposta, e no fim usei apenas velocidade estática.

Pra termos aceleração você aplicaria aceleração na velocidade (ao longo do tempo), e entao velocidade na posicao (ao longo do tempo).

Código:


float velocidadeMaxima = 5f;
float aceleracao = 3f;
Vector3 velocidadeAtual = Vector3.zero;

void Update()
    {
        Vector3 direcao = ObterDirecao();
        velocidadeAtual+= direcao*aceleracao*Time.deltaTime;// acelera na direção do input

        if (velocidadeAtual.magnitude > velocidadeMaxima)
          velocidadeAtual = velocidadeAtual.normalized * velocidadeMaxima; // Limitando a velocidade  

        transform.position += velocidadeAtual  * Time.deltaTime;  //movimento
    }

(... o resto continua o mesmo)