Como implemento a desaceleração?

Eu digo "desaceleração" porque não estou usando aceleração no momento; o que quero dizer é mover a velocidade de volta ao zero, eventualmente parando.

Eu sou novo em vetores e não sou tão bom em física e coisas do tipo. Como a "desaceleração" é normalmente tratada?

O que eu tenho agora funciona, mas parece meio tolo .

update:function(Game, t, dt) {
    var speed = Game.Input.isKeyDown('shift') ? 8 : 4;

    if (Game.Input.isKeyDown('a')) {
        this.velocity.i -= speed;
    }
    else if (Game.Input.isKeyDown('d')) {
        this.velocity.i += speed;
    }
    else {
        if (Math.abs(this.velocity.i) > 3) {
            this.velocity.i += (this.velocity.i > 0) ? -speed : speed;
        }
        else {
            this.velocity.i = 0;
        }
    }

    if (Game.Input.isKeyDown('w')) {
        this.velocity.j -= speed;
    }
    else if (Game.Input.isKeyDown('s')) {
        this.velocity.j += speed;
    }
    else {
        if (Math.abs(this.velocity.j) > 3) {
            this.velocity.j += (this.velocity.j > 0) ? -speed : speed;
        }
        else {
            this.velocity.j = 0;
        }
    }

    this.updateVectors(dt);
}

Eu usei 3 porque qualquer coisa menor exibe um comportamento estranho, acho que se eu aumentasse a velocidade, ele precisaria ser alterado.

Algo tão simples quanto

this.velocity.i *= 0.9;

funciona bem.

No Pseudocódigo, eu faço variações disso:

Velocidade + = ((MoveDirection * MaximumSpeed) - Velocidade) * AccelerationFactor

Onde:

• Velocidade é a velocidade atual em que a entidade está viajando no eixo atual.
• MoveDirection é a direção em que a entidade está tentando viajar no eixo atual, 1 está para a frente, 0 está imóvel e -1 está para trás. Todos os valores intermediários são permitidos.
• MaximumSpeed ​​é uma constante que determina o mais rápido que a entidade pode percorrer no eixo atual.
• AccelerationFactor é uma constante entre 0 e 1 que representa a taxa de aceleração e desaceleração. 1 é instantâneo e 0 nunca será movido.

Que lida com a aceleração e a desaceleração de maneira agradável em uma curva, em vez de uma linha. Se você quiser diferentes taxas de aceleração e desaceleração, poderá fazer instruções IF que determinam se o jogador está tentando não se mover ou se mover na direção oposta.

As respostas aqui ( vel = vel * 0.9) são realmente amortecedoras , não o que eu consideraria 'desaceleração' .

Costumo desacelerar assim:

if ( Game.Input.isKeyDown( "w" ) )
{
    this.velocity.i = Math.max( -WALKSPEED, this.velocity.i - WALKFORCE);
}
else if ( Game.Input.isKeyDown( "d" ) )
{
    this.velocity.i = Math.min( WALKSPEED, this.velocity.i + WALKFORCE);
}
else
{
    if (this.velocity.i < 0)
    {
        this.velocity.i = Math.min( 0, this.velocity.i + WALKFORCE);
    }
    else if (this.velocity.i > 0)
    {
        this.velocity.i = Math.max( 0, this.velocity.i - WALKFORCE);
    }
}

Alguns prós e contras vs. amortecimento:

Prós :

• A aceleração da aceleração e a desaceleração são lineares, o que proporciona uma agradável sensação sutil de jogo que acho que o amortecimento não proporciona. Este é o importante parte .
• O personagem chega a uma parada completa previsível após um número previsível de iterações.

Contras :

• Isso é mais difícil de implementar se você estiver usando movimento não ortogonal (o que parece que você é?) Basicamente, é necessário obter um vetor de força alinhado com a velocidade, comparar comprimentos e subtrair ou zerar conforme apropriado. (Se você quiser que isso seja explicado com código, basta perguntar.)

Simplificando, em pseudo-código:

if(no movement keys pressed) [Meaning we want to start to decelerate]
current speed *= 0.85 [Or some number between 0 and 1, the smaller the faster the deceleration]

No entanto, você precisaria verificar se (velocidade atual <0,001f) ou algo assim e definido como 0.