World > Tiled Elements

TiledWorld exposes tile helper classes for grid-based projects. They are most useful when you need to inspect or customize tiles, edges, or corners directly.

TileFactory

class miniworlds.worlds.tiled_world.tile_factory.TileFactory

TileBase

class miniworlds.worlds.tiled_world.tile_elements.TileBase(position, world=None)

Base class for Tiles and TileDelimiters (like Corners, Edges).

add_actor(actor)

Places an actor on this tile.

corner_vectors: dict = {}

classmethod from_pixel(pixel_position, world)

Finds the nearest tile to a given pixel coordinate.

This method uses caching to avoid redundant recalculation of the mapping between tile grid positions and their corresponding pixel coordinates for a given world. It also uses squared distance instead of Euclidean distance for better performance.

Return type:

TileBase

Parameters:

• pixel_position (Tuple[float, float]) – The (x, y) pixel position.

• world (world_mod.World) – The world instance containing the tile layout.

Returns:

The tile object closest to the given pixel position.

Return type:

TileBase

abstract classmethod from_position(position, world)

Create a tile from a world-relative position.

Return type:

TileBase

get_actors()

Returns all actors currently on this tile.

Return type:

List

static get_local_center_coordinate(world)

Returns the center point offset for a tile, in local pixel coordinates.

Return type:

Tuple[float, float]

get_local_corner_points()

Returns corner point offsets for rendering.

get_neighbour_tiles()

Returns neighboring tiles around this tile.

Return type:

List[Tile]

static get_position_pixel_dict(world)

Returns a mapping of tile positions to pixel coordinates.

Return type:

dict

merge(other)

Merge tile positions from another tile at the same location.

tile_vectors: dict = {}

Tile

class miniworlds.worlds.tiled_world.tile.Tile(position, world=None)

corner_vectors: OrderedDict[str, Tuple[float, float]] = {'no': (-0.5, 0.5), 'nw': (0.5, 0.5), 'so': (-0.5, -0.5), 'sw': (0.5, -0.5)}

distance_to(other)

Return type:

float

edge_vectors: dict[str, Tuple[float, float]] = {'n': (0, -0.5), 'o': (0.5, 0), 's': (0, 0.5), 'w': (-0.5, 0)}

classmethod from_actor(actor)

Return type:

Tile

classmethod from_pixel(pixel_position, world=None)

Finds the nearest tile to a given pixel coordinate.

This method uses caching to avoid redundant recalculation of the mapping between tile grid positions and their corresponding pixel coordinates for a given world. It also uses squared distance instead of Euclidean distance for better performance.

Return type:

Tile

Parameters:

• pixel_position (Tuple[float, float]) – The (x, y) pixel position.

• world (world_mod.World) – The world instance containing the tile layout.

Returns:

The tile object closest to the given pixel position.

Return type:

TileBase

classmethod from_position(position, world)

Create a tile from a world-relative position.

Return type:

Tile

get_neighbour_corners()

Return type:

List[Corner]

static get_position_pixel_dict(world)

Returns a mapping of tile positions to pixel coordinates.

Return type:

dict

tile_vectors: dict[str, Tuple[int, int]] = {'no': (-1, 1), 'nw': (1, 1), 'o': (-1, 0), 'so': (-1, -1), 'sw': (1, -1), 'w': (1, 0)}

to_center()

Return type:

Tuple[float, float]

to_pixel()

Return type:

Tuple[float, float]

Edge

class miniworlds.worlds.tiled_world.edge.Edge(position, direction, world)

angles: Dict[str, int] = {'n': 3, 'o': 0, 's': 1, 'w': 2}

direction_angles: Dict[str, int] = {'n': 90, 'o': 0, 's': 90, 'w': 0}

static direction_vectors()

Returns the available directions.

classmethod from_position(position, world)

Create a tile delimiter (override expected).

static get_position_pixel_dict(world)

Returns a mapping of tile positions to pixel coordinates.

start_angle()

Override: starting angle offset for layouting (e.g. hex rotation).

tile_vectors: dict = {'n': [(0, 0.5), (0, -0.5)], 'o': [(-0.5, 0), (0.5, 0)], 's': [(0, 0.5), (0, -0.5)], 'w': [(-0.5, 0), (0.5, 0)]}

Corner

class miniworlds.worlds.tiled_world.corner.Corner(position, direction, world)

angles: Dict[str, int] = {'no': 0, 'nw': 1, 'so': 3, 'sw': 2}

direction_angles: Dict[str, int] = {'no': 0, 'nw': 0, 'so': 0, 'sw': 0}

static direction_vectors()

Returns the available directions.

classmethod from_pixel(position, world=None)

Finds the nearest tile to a given pixel coordinate.

This method uses caching to avoid redundant recalculation of the mapping between tile grid positions and their corresponding pixel coordinates for a given world. It also uses squared distance instead of Euclidean distance for better performance.

Parameters:

• pixel_position (Tuple[float, float]) – The (x, y) pixel position.

• world (world_mod.World) – The world instance containing the tile layout.

Returns:

The tile object closest to the given pixel position.

Return type:

TileBase

classmethod from_position(position, world)

Create a tile delimiter (override expected).

classmethod from_tile(position, direction_string)

start_angle()

Override: starting angle offset for layouting (e.g. hex rotation).