Обчисліть заголовок велосипеда із задніх коліс та швидкості

У мене є проста гра на велосипеді зверху вниз, до якої я намагаюся додати рульове управління. Мені хотілося б знати, як я використовую заголовки переднього колеса для визначення рухомості та швидкості руху велосипеда.

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;
}

Я намагався застосувати швидкість велосипеда до переднього і заднього колеса і використовую різницю положень там, щоб визначити заголовок велосипеда, але перетягнення вперед робить це заплутаним.

Редагувати на основі коментаря мадшого

Гаразд, я повернувся з результатами!

Я спробував два підходи:

• Використовуючи механіку твердих тіл для отримання диференціального рівняння, що регулює рух центрів коліс: входами системи «велосипед» є крутний момент на задньому колесі та кут переднього колеса, а виходи - кінематика центрів коліс. Але я здався, було важко!

• Намагаючись відгадати, що відбувається з геометричної точки зору, коли заднє колесо «штовхає» переднє колесо вперед, а переднє колесо не прямо. Цей метод безпосередньо дає рівняння нескінченно малих приростів (див. Нижче), з якого можна отримати фактичне диференціальне рівняння. Я не намагався маніпулювати цим першим рівнянням, щоб отримати ODE, але я здогадуюсь, що я отримав би той самий ODE, використовуючи механіку твердих тіл. Це просто правильно.

Позначення та гіпотези:

Ми в площині з базовими векторами ex та ey .

А - центр заднього колеса. B - центр переднього колеса. Довжина велосипеда L являє відстань між A і B . Кут між ey та вектором AB дорівнює φ . Кут між AB та переднім колесом дорівнює θ .

Інтуїтивне обгрунтування:

Ми вважаємо , що в певний момент часу Т , А (Т) має швидкість V (T) колінеарні з AB . Тому для нескінченного малого часу dt ,

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

Ми також припускаємо, що під час t переднє колесо не дрейфує, тобто швидкість B співпадає з напрямком переднього колеса, тобто утворює кут θ з AB . Ми називаємо Uθ одиничним вектором, утворюючи кут θ з AB , тобто одиничним вектором того ж напрямку, що і переднє колесо.

Тому при t + dt ,

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

для певного реального, позитивного λ такого, що довжина велосипеда L зберігається:

відстань (A (t + dt), B (t + dt)) = L

Розрахунки:

Це останнє рівняння означає

норма² (B (t) + λ.Uθ - A (t) - V (t) .dt) = L²

але B (t) , за визначенням, є A (t) + L.Uφ , так що λ повинен задовольняти рівнянню

норма² (L.Uφ + λ.Uθ - V (t) .dt) = L² .

Рішення, звичайно, не залежить від φ, оскільки проблема однакова, коли велосипед вказує на позитивне y . Отже, якщо називати R матрицею обертання з кутом -φ , λ має бути позитивним рішенням

норма² (L.ey; + λ.Uθ - RV (t) .dt) = L² .

Після кількох обчислень, якщо ми назвемо v нормою V , ви отримаєте

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

Ось псевдокод, який я використовував для отримання анімації вище (замість Uθ я використовую u = U (θ + φ), тому що це було простіше):

// 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);
}

Якщо ви багато повторюєте та / або збільшуєте кут рульового управління, траєкторія - це коло, яке є когерентним.