Rect

pygame documentation

|| Home || Help Contents ||

|| pygame || cdrom || constants || cursor || display || draw ||
|| event || font || image || joystick || key || mixer ||
|| mixer_music || mouse || movie || sndarray || surfarray || time ||
|| transform ||

|| CD || Channel || Clock || Font || Joystick || Movie ||
|| Overlay || Rect || Sound || Surface ||

|| color || cursors || sprite ||

Rect

The rectangle object is a useful object representing a rectangle area. Rectangles are created from the pygame.Rect() function. This routine is also in the locals module, so importing the locals into your namespace allows you to just use Rect().

Rect contains helpful methods, as well as a list of modifiable members:

top
bottom
left
right

topleft
topright
bottomleft
bottomright

midleft
midright
midtop
midbottom

center
centerx
centery

size
width
height

When changing these members, the rectangle will be moved to the given assignment. (except when changing the size, width, or height member, which will resize the rectangle from the topleft corner)

The rectstyle arguments used frequently with the Rect object (and elsewhere in pygame) is one of the following things.

an actual Rect object.
a sequence of [xpos, ypos, width, height].
a pair of sequences, representing the position and size [[xpos, ypos], [width,height]].
if a method takes a rectstyle argument as its only argument, you can simply pass four arguments representing xpos, ypos, width, height.

and perhaps most importantly:

A rectstyle argument can also be _any_ python object with an attribute named 'rect'.

clamp	- move rectangle inside another
clamp_ip	- moves the rectangle inside another
clip	- rectangle cropped inside another
collidedict	- find overlapping rectangle in a dictionary
collidedictall	- find all overlapping rectangles
collidelist	- find overlapping rectangle
collidelistall	- find all overlapping rectangles
collidepoint	- point inside rectangle
colliderect	- check overlapping rectangles
contains	- check if rectangle fully inside another
fit	- Fill as much of the argument as possible, maintains aspect ratio
inflate	- new rectangle with size changed
inflate_ip	- changes the Rect size
move	- new rectangle with position changed
move_ip	- move the Rect by the given offset
normalize	- corrects negative sizes
union	- makes new rectangle covering both inputs
union_ip	- rectangle covering both input
unionall	- rectangle covering all inputs
unionall_ip	- rectangle covering all inputs

clamp
Rect.clamp(rectstyle) -> Rect

Returns a new rectangle that is moved to be completely inside the argument rectangle. If the base rectangle is too large for the argument rectangle in an axis, it will be centered on that axis.

clamp_ip
Rect.clamp_ip(rectstyle) -> None

Moves the Rect to be completely inside the argument rectangle. If the given rectangle is too large for the argument rectangle in an axis, it will be centered on that axis.

clip
Rect.clip(rectstyle) -> Rect

Returns a new rectangle that is the given rectangle cropped to the inside of the base rectangle. If the two rectangles do not overlap to begin with, you will get a rectangle with 0 size.

collidedict
Rect.collidedict(dict if rectstyle keys) -> key/value pair

collidedictall
Rect.collidedictall(rectstyle list) -> key/val list

collidelist
Rect.collidelist(rectstyle list) -> int index

Returns the index of the first rectangle in the list to overlap the base rectangle. Once an overlap is found, this will stop checking the remaining list. If no overlap is found, it will return -1.

collidelistall
Rect.collidelistall(rectstyle list) -> index list

Returns a list of the indexes that contain rectangles overlapping the base rectangle. If no overlap is found, it will return an empty sequence.

collidepoint
Rect.collidepoint(x, y) -> bool

Returns true if the given point position is inside the rectangle. If a point is on the border, it is counted as inside.

colliderect
Rect.colliderect(rectstyle) -> bool

Returns true if any area of the two rectangles overlaps.

contains
Rect.contains(rectstyle) -> bool

Returns true when the given rectangle is entirely inside the base rectangle.

fit
Rect.fit(rectstyle) -> Rect

Returns a new rectangle that fills as much of the rectangle argumement as possible. The new rectangle maintains the same aspect ratio as the original rectangle. This can be used to find scaling sizes that fill an area but won't distort the image.

inflate
Rect.inflate(x, y) -> Rect

Returns a new rectangle which has the sizes changed by the given amounts. The rectangle shrinks and expands around the rectangle's center. Negative values will shrink the rectangle.

inflate_ip
Rect.inflate_ip(x, y) -> None

Changes the Rect by the given amounts. The rectangle shrinks and expands around the rectangle's center. Negative values will shrink the rectangle.

move
Rect.move(x, y) -> Rect

Returns a new rectangle which is the base rectangle moved by the given amount.

move_ip
Rect.move_ip(x, y) -> None

Moves the rectangle which by the given amount.

normalize
Rect.normalize() -> None

If the rectangle has a a negative size in width or height, this will flip that axis so the sizes are positive, and the rectangle remains in the same place.

union
Rect.union(rectstyle) -> Rect

Returns a new Rect to completely cover the given input. There may be area inside the new Rect that is not covered by either input.

union_ip
Rect.union_ip(rectstyle) -> None

Resizes the Rect to completely cover the given input. There may be area inside the new dimensions that is not covered by either input.

unionall
Rect.unionall(sequence_of_rectstyles) -> Rect

Returns a new rectangle that completely covers all the given inputs. There may be area inside the new rectangle that is not covered by the inputs.

unionall_ip
Rect.unionall_ip(sequence_of_rectstyles) -> None

Resizes the rectangle to completely cover all the given inputs. There may be area inside the new rectangle that is not covered by the inputs.