Documentation Index

# rabbyt.collisions

This module provides some functions for collision detection.

## Functions

### collide

`collide(objects) -> list of collisions`

Collides `objects`, first using `rdc()` and then using `brute_force()`.

Each object should have the attributes `x`, `y`, `bounding_radius`, and `bounding_radius_squared`.

### collide_single

`collide_single(single, objects)`

Finds collisions between a single object and a list of objects.

`single` can either be an object with `x`, `y`, and `bounding_radius` attributes, or a tuple of `(x,y, bounding_radius)` (In both cases, `bounding_radius` is optional and defaults to `0`.)

### collide_groups

`collide_groups(group_a, group_b)`

Returns a list of collisions between objects in `group_a` with objects in `group_b`.

All objects must either have `x`, `y`, and (optionally) `bounding_radius` attributes or behave like a tuple with the form `(x, y, bounding_radius)` or `(x, y)`.

If `bounding_radius` is missing it will default to `0`.

### aabb_collide

`aabb_collide(objects)`

`aabb_collide` works similar to `collide`, but instead of using bounding radius it uses axis aligned bounding boxes [AABB].

All objects must have `left`, `top`, `right`, and `bottom` attributes.

### aabb_collide_single

`aabb_collide_single(single, objects)`

Finds all objects in `objects` that collide with `single`, (using bounding boxes.)

All objects must have `left`, `top`, `right`, and `bottom` attributes.

A list of all objects from `objects` that collide with `single` is returned.

### aabb_collide_groups

`aabb_collide_groups(group_a, group_b)`

Returns a list of collisions between objects in `group_a` with objects in `group_b`.

All objects must have `left`, `top`, `right`, and `bottom` attributes.

### rdc

`rdc(objects, [max_depth,] [min_split]) -> list of collision groups`

Uses the Recursive Dimensional Clustering algorithm to find groups of colliding objects.

`objects` should be a list of objects. Each object should have the attributes `x`, `y`, and `bounding_radius`.

If the number of objects in a collision group is less than `min_split`, recursion will stop. This defaults to `1`, but in practice, it is usually faster to just use a brute force method once a group gets down to `10` objects.

`max_depth` is the maximum number of recursions to make. It defaults to `0`, which is infinite.

Instead of returning individual collisions, `rdc()` returns groups (lists) of colliding objects. For example, if `A` collides with `B` and `B` collides with `C`, one of the groups will be `[A, B, C]`, even though `A` and `C` don't directly collide.

Also, each object is returned at most once. If it is in one group, it won't be in any other. An object without any collisions isn't returned at all.

### brute_force

`brute_force(objects) -> list of collisions`

Finds collisions between `objects` using a brute force algorithm.

`objects` should be a list of objects, each of which have the attributes `x`, `y`, and `bounding_radius_squared`. Each object is checked against every other object.

For example, if `A` collides with `B`, `B` collides with `C`, and `D` doesn't collide with anything, the result will be: `[(A, B), (B, C)]`.