Como faço para que um objeto em movimento pare sem problemas no final de um caminho?

Há uma dúzia de maneiras pelas quais eu poderia formular essa pergunta, mas para manter meus pensamentos alinhados, eu estou formulando isso de acordo com o meu problema em questão.

Então, eu estou criando uma plataforma flutuante que eu gostaria de poder simplesmente viajar de um ponto designado para outro e, em seguida, retornar ao primeiro e simplesmente passar entre os dois em uma linha reta. No entanto, apenas para torná-lo um pouco mais interessante, quero adicionar algumas regras à plataforma.

1. Estou codificando para viajar com múltiplos valores de bloco inteiros de dados mundiais. Portanto, se a plataforma não estiver estacionária, ela percorrerá pelo menos uma largura ou altura do ladrilho inteiro.
2. Dentro do comprimento de um bloco, eu gostaria que ele acelerasse de uma parada para uma determinada velocidade máxima.
3. Ao atingir a distância do comprimento de um bloco, eu gostaria que ele diminuísse até uma determinada coordenada de bloco e repita o processo ao contrário.

As duas primeiras partes não são muito difíceis, basicamente estou tendo problemas com a terceira parte. Gostaria que a plataforma parasse exatamente em uma coordenada de bloco, mas como estou trabalhando com aceleração, parece fácil simplesmente aplicar a aceleração na direção oposta a um valor que armazena a velocidade atual da plataforma assim que atingir o comprimento de um bloco de distância (supondo que o bloco esteja viajando mais do que um comprimento de bloco, mas, para simplificar, vamos assumir que sim) - mas a questão é: qual seria o valor correto para a aceleração aumentar para produzir esse efeito? Como eu encontraria esse valor?

Usando esses comportamentos de direção como um guia. Observando o comportamento de chegada:

O comportamento de chegada é idêntico ao que procurar enquanto o personagem está longe de ser o alvo. Mas, em vez de passar pelo alvo a toda velocidade, esse comportamento faz com que o personagem desacelere à medida que se aproxima do alvo, eventualmente diminuindo a velocidade para uma parada coincidente com o alvo.

Podemos criar uma função "chegar a" como algo semelhante a este:

arriveAtPoint(Vector2f position, Vector2f target) {
    float slowing_distance = 1;
    Vector2f target_offset = target - position;
    float distance = target_offset.length();
    float ramped_speed = currentVelocity * (distance / slowing_distance);
    float clipped_speed = Math.min(ramped_speed, currentVelocity);
    targetLinearVelocity = target_offset.scale(clipped_speed / distance);
    acceleration = targetLinearVelocity -linearVelocity;
}

Isso atualizará a aceleração que precisamos usar para aplicar ao objeto em movimento.

Dê uma olhada nesta página: http://sol.gfxile.net/interpolation/index.html

Parece que você deseja um efeito como o passo suave:

Se você tiver o ponto mais à esquerda, o ponto mais à direita que a plataforma deve atingir e o tempo que ela deve usar para fazer uma sequência completa, algo como isto pode estar bem:

quadro foreach:

float smoothstep(float t, int level = 1)
{
    float ret = t;
    for(int i = 0; i < level; ++i)
    {
        ret = pow(ret, 2) * (3 - 2 * ret);
    }
    return ret;
}

currentTime += deltaTime;
if(currentTime > fullTime) currentTime -= fullTime;
float halfTime = fullTime / 2.0;
float t = abs(currentTime - halfTime) / halfTime;
t = smoothstep(t, 1);
platformPosition = rightPoint * t + leftPoint * (1 - t);

se você estiver usando um mecanismo de física, poderá fazê-lo com impulsos, não deve ser tão difícil de traduzir. Se você deseja um processo ainda mais suave, pode aumentar o nível da etapa suave.

Você pode usar o XnaTweener, que fornece funções facilitadoras que interpolam valores de um ponto para outro de maneira fácil ...

Aqui está uma resposta com algum código baseado no projeto Xna Tweener e um vídeo mostrando como ele funciona ...

https://gamedev.stackexchange.com/a/26872/8390

[EDITAR]

Você deve ter uma sequência de chaves que defina o movimento da plataforma, assim:

public class MovementKey
{
    public float Time = 0;
    public float Duration;
    public Vector2 Traslation;            // Traslation is relative to previous key
    public TweeningFunction Function;

    internal float GetRatio( float Elapsed )   
    {
        // Always return a value in [0..1] range
        //    0 .. Start position relative to accumulated traslations of previous keys
        //    1 .. Target relative position reached.. then should go to next key if avalaible
        return Function( Elapsed, 0, 1, Duration ); 
    }
}

E então você pode lidar com o movimento desta maneira:

public class Movement {

    List<MovementKey> Keys;

    public void Update( float Seconds)
    {

        float ratio;
        if (Playing) Elapsed += Seconds;

        while ( index!= Keys.Count - 1 && Elapsed > Keys[iKey + 1].Time )
        {
            Traslation += Keys[iKey].Traslation;  // Relative
            index++;
        }

       if ( index == Keys.Count - 1 && Elapsed > Keys[iKey].Time + Keys[iKey].Duration )
       {
          ratio = 1;
          if ( DoLoop )
          {
              Elapsed -= (Keys[index].Time + Keys[iKey].Duration);
              Index = 0;
              Traslation = Vector2.zero;
          }
       }
       else {                    
           ratio = Keys[index].GetRatio( Elapsed - Keys[index].Time );
       }

       Position = DefaultPosition + Traslation + ratio * Keys[index].Traslation;        
   }

"DefaultPosition" é a posição inicial, "Traslation" acumula o movimento de várias teclas e cada tradução de tecla é relativa à tecla anterior; portanto, quando você a multiplica por um fator de proporção [0..1], ele retorna a tradução relativa interpolada percorrida. para acessar essa chave da chave anterior ...

Aqui você tem outro vídeo que mostra um movimento da plataforma definido como descrito aqui ...

http://www.youtube.com/watch?v=ZPHjpB-ErnM&feature=player_detailpage#t=104s

Eu refiz esse código tentando facilitar a compreensão ... talvez tenha algum bug ... o código original lida com várias instâncias do mesmo movimento, mas com alguns atrasos entre cada instância ... tenho certeza que esse código pode ser redesenhado para ser mais fácil ...