Function PhysicsApplyConstantForce

physics/physics.cpp:258–291

Applies a linear force over time. --Like gravity or thrust

// Applies a linear force over time.  --Like gravity or thrust
void PhysicsApplyConstantForce(const object &objp, vector &newPos, vector &newVel, vector &movementVec,
                               const vector &force, float deltaTime) {
  const vector &pos = objp.pos;
  const vector &vel = objp.mtype.phys_info.velocity;
  const double drag = static_cast<double>(objp.mtype.phys_info.drag);
  const double mass = static_cast<double>(objp.mtype.phys_info.mass);

  if (mass < std::numeric_limits<double>::epsilon() || drag < std::numeric_limits<double>::epsilon()) {
    // No Mass/Drag
    movementVec = (vel * deltaTime) + (force * (0.5f * deltaTime * deltaTime));
    newPos = pos + movementVec;
    newVel = vel + force * deltaTime;
    return;
  }

  // Standard motion with a linear air drag (drag is proportional to velocity)
  const double dt = static_cast<double>(deltaTime);
  const double oneOverDrag = 1.0 / drag;
  const double massOverDrag = mass / drag;
  const double forceOverDrag[3] = {force.x * oneOverDrag, force.y * oneOverDrag, force.z * oneOverDrag};
  const double objVel[3] = {static_cast<double>(vel.x), static_cast<double>(vel.y), static_cast<double>(vel.z)};
  const double expDoMDt = exp((-1.0 / massOverDrag) * dt);

  newPos.x = static_cast<float>(static_cast<double>(pos.x) + forceOverDrag[0] * dt +
                                massOverDrag * (objVel[0] - forceOverDrag[0]) * (1.0 - expDoMDt));
  newPos.y = static_cast<float>(static_cast<double>(pos.y) + forceOverDrag[1] * dt +
                                massOverDrag * (objVel[1] - forceOverDrag[1]) * (1.0 - expDoMDt));
  newPos.z = static_cast<float>(static_cast<double>(pos.z) + forceOverDrag[2] * dt +
                                massOverDrag * (objVel[2] - forceOverDrag[2]) * (1.0 - expDoMDt));
  movementVec = newPos - pos;
  newVel.x = static_cast<float>((objVel[0] - forceOverDrag[0]) * expDoMDt + forceOverDrag[0]);
  newVel.y = static_cast<float>((objVel[1] - forceOverDrag[1]) * expDoMDt + forceOverDrag[1]);
  newVel.z = static_cast<float>((objVel[2] - forceOverDrag[2]) * expDoMDt + forceOverDrag[2]);
}

// Banks an object as it turns (we counteract this and then reapply it when we
// actually do the turn -- cool)