This module holds functions, exceptions and constants that are or might be used by both the game, renderer and perhaps the agents. By putting this code in a separate module, each of them can access it without requiring the other modules.

domination.utilities.frange(limit1, limit2=None, increment=1.0)[source]

Like xrange, but for real numbers.


Returns mean of given list or generator.


Returns standard deviation of given list or generator.

>>> stdev([1,2,3])
domination.utilities.point_add(a, b)[source]

Add the coordinates of two points (Inline this if you can, function calls are slow)

domination.utilities.point_sub(a, b)[source]

Subtract two 2d vectors (Inline this if you can, function calls are slow)

domination.utilities.point_mul(a, f)[source]

Multiply a vector by a scalar (Inline this if you can, function calls are slow)

domination.utilities.point_dist(a, b)[source]

Distance between two points.

domination.utilities.line_intersects_rect(p0, p1, r)[source]

Check where a line between p1 and p2 intersects given axis-aligned rectangle r. Returns False if no intersection found. Uses the Liang-Barsky line clipping algorithm.

>>> line_intersects_rect((1.0,0.0),(1.0,4.0),(0.0,1.0,4.0,1.0))
((0.25, (1.0, 1.0)), (0.5, (1.0, 2.0)))
>>> line_intersects_rect((1.0,0.0),(3.0,0.0),(0.0,1.0,3.0,1.0))
domination.utilities.line_intersects_circ((p0x, p0y), (p1x, p1y), (cx, cy), r)[source]

Computes intersections between line and circle. The line runs between (p0x,p0y) and (p1x,p1y) and the circle is centered at (cx,cy) with a radius r. Returns False if no intersection is found, and one or two intersection points otherwise. Intersection points are (t, (x, y)) where t is the distance along the line between 0-1. (From stackoverflow.com/questions/1073336/circle-line-collision-detection)

>>> line_intersects_circ((0,0), (4,0), (2,0), 1)
[(0.25, (1.0, 0.0)), (0.75, (3.0, 0.0))]
>>> line_intersects_circ((0,0), (2,0), (2,0), 1)
[(0.5, (1.0, 0.0))]
>>> line_intersects_circ((0,1), (2,1), (1,0), 1)
[(0.5, (1.0, 1.0))]
>>> line_intersects_circ((0,0), (0,1), (2,0), 1)
domination.utilities.line_intersects_grid((x0, y0), (x1, y1), grid, grid_cell_size=1)[source]

Performs a line/grid intersection, finding the “super cover” of a line and seeing if any of the grid cells are occupied. The line runs between (x0,y0) and (x1,y1), and (0,0) is the top-left corner of the top-left grid cell.

>>> line_intersects_grid((0,0),(2,2),[[0,0,0],[0,1,0],[0,0,0]])
>>> line_intersects_grid((0,0),(0.99,2),[[0,0,0],[0,1,0],[0,0,0]])
domination.utilities.rect_contains_point(rect, point)[source]

Check if rectangle contains a point.

domination.utilities.rect_offset(rect, offset)[source]

Offsets (grows) a rectangle in each direction.


Returns cornerpoints of given rectangle.

>>> rect_corners((1,2,1,3))
((1, 2), (2, 2), (2, 5), (1, 5))

Returns a rectangle that bounds all given rectangles

>>> rects_bound([(0,0,1,1), (3,3,1,1)])
(0, 0, 4, 4)

Merge a list of rectangle (xywh) tuples. Returns a list of rectangles that cover the same surface. This is not necessarily optimal though.

>>> rects_merge([(0,0,1,1),(1,0,1,1)])
[(0, 0, 2, 1)]

Fixes an angle to a value between -pi and pi.

>>> angle_fix(-2*pi)
domination.utilities.reachable(grid, (x, y), border=1)[source]

Performs a ‘flood fill’ operation to find reachable areas on given tile map from (x,y). Returns as binary grid with 1 for reachable.

Parameters:border – can be a value or a function indicating borders of region
>>> reachable([[0,1,0],[0,1,0]], (0,0))
[[1, 0, 0], [1, 0, 0]]
domination.utilities.make_nav_mesh(walls, bounds=None, offset=7, simplify=0.001, add_points=[])[source]

Generate an almost optimal navigation mesh between the given walls (rectangles), within the world bounds (a big rectangle). Mesh is a dictionary of dictionaries:

mesh[point1][point2] = distance
domination.utilities.find_path(start, end, mesh, grid, tilesize=16)[source]

Uses astar to find a path from start to end, using the given mesh and tile grid.

>>> grid = [[0,0,0,0,0],[0,0,0,0,0],[0,0,1,0,0],[0,0,0,0,0],[0,0,0,0,0]]
>>> mesh = make_nav_mesh([(2,2,1,1)],(0,0,4,4),1)
>>> find_path((0,0),(4,4),mesh,grid,1)
[(4, 1), (4, 4)]