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