docs: def get_distance(
          self, l_motor: float, r_motor: float, tm_diff: float
      ) -> typing.Tuple[float, float]:
          """
              Given motor values and the amount of time elapsed since this was last
              called, retrieves the x,y,angle that the robot has moved. Pass these
              values to :meth:`PhysicsInterface.distance_drive`.
              
              To update your encoders, use the ``l_position`` and ``r_position``
              attributes of this object.
          
              :param l_motor:    Left motor value (-1 to 1); -1 is forward
              :param r_motor:    Right motor value (-1 to 1); 1 is forward
              :param tm_diff:    Elapsed time since last call to this function
  
              :returns: x travel, y travel, angle turned (radians)
              
              .. note:: If you are using more than 2 motors, it is assumed that
                        all motors on each side are set to the same speed. Only
                        pass in one of the values from each side
          """
  
          # This isn't quite right, the right way is to use matrix math. However,
          # this is Good Enough for now...
          x = 0
          y = 0
          angle = 0
  
          # split the time difference into timestep_ms steps
          total_time = int(tm_diff * 100000)
          steps = total_time // self._timestep
          remainder = total_time % self._timestep
          step = self._timestep / 100000.0
          if remainder:
              last_step = remainder / 100000.0
              steps += 1
          else:
              last_step = step
  
          while steps != 0:
              if steps == 1:
                  tm_diff = last_step
              else:
                  tm_diff = step
  
              steps -= 1
  
              l = self._lmotor.compute(-l_motor, tm_diff)
              r = self._rmotor.compute(r_motor, tm_diff)
  
              # Tank drive motion equations
              velocity = (l + r) * 0.5
  
              # Thanks to Tyler Veness for fixing the rotation equation, via conservation
              # of angular momentum equations
              # -> omega = b * m * (l - r) / J
              rotation = self._bm * (l - r) / self._inertia
  
              distance = velocity * tm_diff
              turn = rotation * tm_diff
  
              x += distance * math.cos(angle)
              y += distance * math.sin(angle)
              angle += turn
  
          return x, y, angle