Calcular o rumo da bicicleta a partir do rumo da roda dianteira e da velocidade

Eu tenho um jogo simples de cima para baixo que estou tentando adicionar direção. Gostaria de saber como uso o rumo da roda dianteira para determinar o rumo e a velocidade da bicicleta.

void Update () 
{
    //Get input from user Vertical: 0 to 1, Horizontal -1 to 1
    float forwardInput = Input.GetAxis("Vertical");
    float sidewaysInput = Input.GetAxis("Horizontal") * m_steeringAmount;

    // Turn front wheel
    m_frontWheelTransform.localEulerAngles = new Vector3(0, sidewaysInput, 90);

    // get speed and drag
    float   speed           = m_velocity.magnitude;
    Vector3 forwardDrag     = -m_forwardDragConstant * m_velocity * speed;

    // calculate acceleration 
    float engineForce       = forwardInput * m_enginePower;
    Vector3 forwardTraction = transform.forward * engineForce;
    Vector3 forwrdForce     = forwardTraction + forwardDrag;
    Vector3 acceleration    = forwrdForce / m_mass;

    // update velocity and position
    m_velocity += acceleration * Time.deltaTime;
    transform.localPosition += m_velocity * Time.deltaTime;
}

Tentei aplicar a velocidade da bicicleta nas rodas dianteira e traseira e usar a diferença de posições para determinar o rumo da bicicleta, mas o arraste para a frente a torna confusa.

Editar com base no comentário madshogo

Ok, estou de volta com resultados!

Eu tentei duas abordagens:

• Usando a mecânica dos sólidos para derivar uma equação diferencial que governa o movimento dos centros das rodas: as entradas do sistema "bicicleta" são o torque na roda traseira e o ângulo da roda dianteira, e as saídas são a cinemática dos centros das rodas. Mas eu desisti, foi difícil!

• Tentando adivinhar o que acontece do ponto de vista geométrico quando a roda traseira "empurra" a roda dianteira para frente com a roda dianteira não reta. Este método produz diretamente uma equação de incrementos infinitesimais (veja abaixo) a partir da qual você pode obter uma equação diferencial real. Eu não tentei manipular esta primeira equação para obter o ODE, mas meu palpite é que eu teria obtido o mesmo ODE usando a mecânica de sólidos. Parece certo.

Notações e hipóteses:

Estamos no plano com os vetores base ex e ey .

A é o centro da roda traseira. B é o centro da roda dianteira. O comprimento da bicicleta L é a distância entre um e B . O ângulo entre ey e o vetor AB é φ . O ângulo entre AB e a roda dianteira é θ .

Justificativa intuitiva:

Supomos que, em um determinado instante t , A (t) tenha uma velocidade V (t) colinear com AB . Portanto, para um timestep infinitesimal dt ,

A (t + dt) = A (t) + V (t) .dt .

Supomos também que, no momento t , a roda dianteira não deriva, ou seja, a velocidade de B é colinear com a direção da roda dianteira, ou seja, forma um ângulo θ com AB . Chamamos Uθ o vetor unitário formando um ângulo θ com AB , ou seja, o vetor unitário com a mesma direção da roda dianteira.

Portanto, em t + dt ,

B (t + dt) = B (t) + λ.Uθ

para um certo real, positivo λ, de modo que o comprimento da bicicleta L seja conservado:

distância (A (t + dt), B (t + dt)) = L

Cálculos:

Esta última equação se traduz em

norm (B (t) + λ.Uθ - A (t) - V (t) .dt) = L²

mas B (t) , por definição, é A (t) + L.Uφ , de modo que λ deve satisfazer a equação

norm (L.Uφ + λ.Uθ - V (t). dt) = L² .

A solução, é claro, é independente de φ, pois o problema é o mesmo quando a bicicleta aponta para y positivo . Portanto, se chamamos R de matriz de rotação com ângulo -φ , λ deve ser a solução positiva de

norm² (L.ey; + λ.Uθ - VR (t) .dt) = L² .

Após alguns cálculos, se chamarmos v a norma de V , você obtém

λ = L. (sqrt (1 - (sin (θ). (1-v.dt / L)) ²) - cos (θ)) + v.dt.cos (θ) .

Aqui está o pseudocódigo que eu usei para obter a animação acima (em vez de usar Uθ , eu uso u = U (θ + φ) porque era mais simples):

// I start at i=1 because i=0 contains the initial values
for (int i=1; i<=N; i++)
{
    // the array in which I stored the successive A points
    Aarray[i] = Aarray[i-1] + dt*V;
    float lambda = L*( sqrt(1 - (sin(theta)*(1-v*dt/L))**2) - cos(theta) )
                   + cos(theta)*v*dt;
    // the array in which I stored the successive B points
    Barray[i] = Barray[i-1] + lambda*u;
    // the AB vector normalized
    AiBiUnit = (Barray[i] - Aarray[i])/L;
    // Refreshing the velocity of A
    V = v*AiBiUnit;
    // Refreshing u.
    // u is indeed a unit vector separated from AiBiUnit by an angle theta,
    // so you get it by rotating the newly computed AiBiUnit by an angle
    // of +theta:
    u = AiBiUnit.rotate(theta);
}

Se você repetir muito e / ou aumentar o ângulo de direção, a trajetória é um círculo, que é coerente, acredito.