программирование физической игры box2d - ориентация объекта, похожего на башню, с использованием крутящих моментов

Думайте в обратном направлении. Башня должна «начать торможение», когда у нее будет достаточно места для замедления от текущей угловой скорости до полной остановки, что соответствует комнате, которая потребуется ей для ускорения от полной остановки до текущей угловой скорости, т. е.

|differenceAngle| = w^2*Inertia/2*MaxTorque.

У вас также могут возникнуть проблемы с небольшими колебаниями вокруг цели, если время вашего шага слишком велико; это потребует большей ловкости, вам придется тормозить чуть раньше и мягче. Не беспокойся об этом, пока не увидишь.

На данный момент этого должно быть достаточно, но есть еще одна загвоздка, которая может сбить вас с толку позже: решить, в какую сторону идти. Иногда пройти длинный путь быстрее, если вы уже идете этим путем. В этом случае вы должны решить, какой путь займет меньше времени, что нетрудно, но опять же, пересечь этот мост, когда вы придете к нему.

РЕДАКТИРОВАТЬ:
Мое уравнение было неправильным, оно должно быть Inertia/2*maxTorque, а не 2*maxTorque/Inertia (это то, что я получаю, пытаясь выполнить алгебру на клавиатуре). Я исправил это.

Попробуй это:

local torque = maxTorque;
if(differenceAngle > math.pi) then -- clockwise is the shortest path
    torque = -torque;
end
if(differenceAngle < w*w*Inertia/(2*MaxTorque)) then -- brake
    torque = -torque;
end
self:applyTorque(torque)

Похоже, что эту проблему можно решить с помощью ПИД-регулятора. Я использую их в своей работе для управления мощностью нагревателя, чтобы установить температуру.

Для компонента «P» вы прикладываете крутящий момент, пропорциональный разнице между углом башни и углом цели, т.е.

P = P0 * differenceAngle

Если это все еще слишком сильно колеблется (будет немного), тогда добавьте компонент «Я»,

integAngle = integAngle + differenceAngle * dt
I = I0 * integAngle

Если это слишком много, добавьте термин «D»

derivAngle = (prevDifferenceAngle - differenceAngle) / dt
prevDifferenceAngle = differenceAngle
D = D0 * derivAngle

P0, I0 и D0 — это константы, которые вы можете настроить, чтобы получить желаемое поведение (например, как быстро реагируют турели и т. д.).

Как совет, обычно P0 > I0 > D0

Используйте эти термины, чтобы определить, какой крутящий момент применяется, т.е.

magnitudeAngMomentum = P + I + D

ИЗМЕНИТЬ:

Вот приложение, написанное с использованием Processing, использующего PID. На самом деле он отлично работает без I или D. Посмотрите, как это работает здесь

// Demonstration of the use of PID algorithm to 
// simulate a turret finding a target. The mouse pointer is the target

float dt = 1e-2;
float turretAngle = 0.0;
float turretMass = 1;
// Tune these to get different turret behaviour
float P0 = 5.0;
float I0 = 0.0;
float D0 = 0.0;
float maxAngMomentum = 1.0;

void setup() {
  size(500, 500);  
  frameRate(1/dt);
}

void draw() {
  background(0);
  translate(width/2, height/2);

  float angVel, angMomentum, P, I, D, diffAngle, derivDiffAngle;
  float prevDiffAngle = 0.0;
  float integDiffAngle = 0.0;

  // Find the target
  float targetX = mouseX;
  float targetY = mouseY;  
  float targetAngle = atan2(targetY - 250, targetX - 250);

  diffAngle = targetAngle - turretAngle;
  integDiffAngle = integDiffAngle + diffAngle * dt;
  derivDiffAngle = (prevDiffAngle - diffAngle) / dt;

  P = P0 * diffAngle;
  I = I0 * integDiffAngle;
  D = D0 * derivDiffAngle;

  angMomentum = P + I + D;

  // This is the 'maxTorque' equivelant
  angMomentum = constrain(angMomentum, -maxAngMomentum, maxAngMomentum);

  // Ang. Momentum = mass * ang. velocity
  // ang. velocity = ang. momentum / mass
  angVel = angMomentum / turretMass;

  turretAngle = turretAngle + angVel * dt;

  // Draw the 'turret'
  rotate(turretAngle);
  triangle(-20, 10, -20, -10, 20, 0);

  prevDiffAngle = diffAngle;
}

Хорошо, я считаю, что получил решение.

Это основано на идее Беты, но с некоторыми необходимыми изменениями. Вот оно:

local twoPi = 2.0 * math.pi -- small optimisation 

-- returns -1, 1 or 0 depending on whether x>0, x<0 or x=0
function _sign(x)
  return x>0 and 1 or x<0 and -1 or 0
end

-- transforms any angle so it is on the 0-2Pi range
local _normalizeAngle = function(angle)
  angle = angle % twoPi
  return (angle < 0 and (angle + twoPi) or angle)
end

function Turret:update(dt)

  local tx, ty = self:getTargetPosition()
  local x, y = self:getPosition()
  local angle = self:getAngle()
  local maxTorque = self:getMaxTorque()
  local inertia = self:getInertia()
  local w = self:getAngularVelocity()

  local targetAngle = math.atan2(ty-y,tx-x)

  -- distance I have to cover
  local differenceAngle = _normalizeAngle(targetAngle - angle)

  -- distance it will take me to stop
  local brakingAngle = _normalizeAngle(_sign(w)*2.0*w*w*inertia/maxTorque)

  local torque = maxTorque

  -- two of these 3 conditions must be true
  local a,b,c = differenceAngle > math.pi, brakingAngle > differenceAngle, w > 0
  if( (a and b) or (a and c) or (b and c) ) then
    torque = -torque
  end

  self:applyTorque(torque)
end

Идея, лежащая в основе этого, проста: мне нужно рассчитать, сколько «пространства» (угла) нужно турели, чтобы полностью остановиться. Это зависит от того, насколько быстро движется башня и какой крутящий момент она может приложить к себе. В двух словах, это то, что я вычисляю с помощью brakingAngle.

Моя формула для вычисления этого угла немного отличается от формулы Беты. Мой друг помог мне с физикой, и, кажется, они работают. Добавление знака w было моей идеей.

Мне пришлось реализовать функцию «нормализации», которая возвращает любой угол в зону 0-2Pi.

Первоначально это было запутанное if-else-if-else. Поскольку условия были очень повторяющимися, я использовал некоторую логическую логику, чтобы упростить алгоритм. Минус в том, что даже если работает нормально и не сложно, не понятно почему работает.

Как только код немного очистится, я опубликую здесь ссылку на демонстрацию.

Большое спасибо.

РЕДАКТИРОВАТЬ: Рабочий пример LÖVE теперь доступен здесь. Важные вещи находятся внутри Actors/AI.lua (файл .love можно открыть с помощью zip-распаковщика)

Вы можете найти уравнение для зависимости угловой скорости от углового расстояния для ротора при приложении ускоряющего крутящего момента и найти такое же уравнение для применения тормозного крутящего момента.

Затем измените уравнение разрыва таким образом, чтобы оно пересекало ось углового расстояния под требуемым углом. С помощью этих двух уравнений вы можете рассчитать угловое расстояние, на котором они пересекаются, что даст вам точку разрыва.

Хотя может и ошибся, давно такого не было. Возможно более простое решение. Я предполагаю, что ускорение не является линейным.

Упрощенную версию этой задачи решить довольно просто. Предположим, что двигатель имеет бесконечный крутящий момент, т.е. он может изменять скорость мгновенно. Это, очевидно, не является физически точным, но значительно упрощает решение проблемы и, в конце концов, не является проблемой.

Сосредоточьтесь на целевой угловой скорости, а не на целевом угле.

current_angle = "the turrets current angle";
target_angle = "the angle the turret should be pointing";
dt = "the timestep used for Box2D, usually 1/60";
max_omega = "the maximum speed a turret can rotate";

theta_delta = target_angle - current_angle;
normalized_delta = normalize theta_delta between -pi and pi;
delta_omega = normalized_deta / dt;
normalized_delta_omega = min( delta_omega, max_omega );

turret.SetAngularVelocity( normalized_delta_omega );

Причина, по которой это работает, заключается в том, что турель автоматически пытается двигаться медленнее, когда достигает заданного угла.

Бесконечный крутящий момент маскируется тем фактом, что башня не пытается мгновенно сократить дистанцию. Вместо этого он пытается сократить расстояние за один временной шаг. Кроме того, поскольку диапазон от -pi до pi довольно мал, возможно, безумные ускорения никогда не проявляются. Максимальная угловая скорость делает вращение башни реалистичным.

Я никогда не разрабатывал реальное уравнение для решения с крутящим моментом вместо угловой скорости, но я думаю, что оно будет очень похоже на уравнения ПИД.