def inflate_ip(self, *args):
        """Inflate/deflate the rectsmanager in place.

        Does so by increasing/decreasing the distance of
        each rect's center to the rectsmanager center
        proportional to the change in size, so that the
        final position of the underlying rects describes
        a union rect just like described by the inflation/
        deflation of the original union rect.

        *args is a pair of integers usually given either
        as separate arguments or together in a sequence
        like a tuple, list or pygame.math.Vector2.
        Such integers may be negative as well and they
        represent the amount of pixels to increase/decrease
        in width and height.
        """
        ### get an union rect
        union = self.union_rect

        ### store the dimensions (width and height)
        ### resulting from its inflation/deflation
        infl_w, infl_h = union.inflate(*args).size

        ### also store a vector from such dimensions
        infl_size_v = Vector2(infl_w, infl_h)

        ### loop a limited number of times trying to
        ### match the inflated/deflated dimensions;
        ### the loop is exited earlier if the results
        ### are close enough;

        ### also, as commented in the "xxx" comment above
        ### this method, there may be a more direct way of
        ### performing such calculations, but for now this
        ### is the more accurate way we found; also, we used
        ### a "while" loop before, set to stop only when
        ### the minimum accuracy was reached; however, since
        ### in some cases we can't get a result accurate
        ### enough due to rounding issues, it was causing
        ### an infinite loop; we also didn't want to loop
        ### too much when we can usually get good enough
        ### accuracy with usually 2 to 5 iterations; because
        ### of all that, we now use "for" loops and iterate
        ### a maximum of 5 times, which is a number we
        ### determined empirically, since it covers most
        ### cases encountered with enough accuracy;

        for _ in range(5):

            ### obtain the ratio of each inflated/deflated
            ### dimension relative to each union rect
            ### dimension

            w_ratio = infl_w / union.w
            h_ratio = infl_h / union.h

            ### obtain a vector from the center of the union
            union_center_v = Vector2(union.center)

            ### iterate over each underlying rect moving
            ### them closer/farther from the union center
            ### depending on the ratio between inflated/
            ### deflated union and current union rect

            for rect in self._get_all_rects():

                ### get distances x and y from center of
                ### this rect to union center
                center_dx, center_dy = rect.center - union_center_v

                ### multiply each distance by the
                ### corresponding ratio to obtain the
                ### final x and y distances from the center
                ### that the rect must assume

                center_dx = round(center_dx * w_ratio)
                center_dy = round(center_dy * h_ratio)

                ### then assign the new center x and y
                ### coordinates of the rect, obtained
                ### from adding the distances calculated
                ### in the previous step to the union
                ### center

                rect.centerx = union.centerx + center_dx
                rect.centery = union.centery + center_dy

            ### break out of the loop earlier if the
            ### size difference is too small

            ## calculate the difference between the
            ## current size and the inflated/deflated
            ## size; such difference is stored as a
            ## pygame.math.Vector2 obj
            size_difference = self.size - infl_size_v

            ## if the length of the difference is 1 or less,
            ## it is accurate enough, so we exit the loop

            if size_difference.length() <= 1:
                break

            ### otherwise, get a union rect to use in the
            ### next iteration; this union rect is
            ### already updated considering any changes
            ### in the underlying rects positions made
            ### in this loop
            else:
                union = self.union_rect
Inflate/deflate the rectsmanager in place.

        Does so by increasing/decreasing the distance of
        each rect's center to the rectsmanager center
        proportional to the change in size, so that the
        final position of the underlying rects describes
        a union rect just like described by the inflation/
        deflation of the original union rect.

        *args is a pair of integers usually given either
        as separate arguments or together in a sequence
        like a tuple, list or pygame.math.Vector2.
        Such integers may be negative as well and they
        represent the amount of pixels to increase/decrease
        in width and height.
        
nodezator/rectsman/sizepos.py