pyxen.GridMap
Un GridMap es un contenedor espacial formado por celdas organizadas en filas y columnas.
Define la disposición de tiles, el tamaño de celda, el atlas de tiles opcional y el espacio de colisión para GridBody.
Para conceptos de colisión, consulta Colisión.
Constructor
GridMap(
*,
rows=None,
columns=None,
size=None,
image=None,
tilemap=None
)
Todos los parámetros son solo por nombre.
Parámetros
| Parámetro | Tipo | Descripción |
|---|---|---|
rows | int | Número de filas |
columns | int | Número de columnas |
size | (width, height) | Tamaño de celda en píxeles |
image | str | Nombre de imagen del atlas de tiles |
tilemap | str | Nombre de un asset .tilemap para precargar |
Ejemplo
level_map = GridMap(
rows=10,
columns=16,
size=(16, 16),
image="tileset"
)
Adjuntar un GridMap
Durante spawn:
level = world.spawn(
map=GridMap(
rows=10,
columns=16,
size=(16, 16),
image="tileset"
)
)
O después:
entity = world.spawn()
entity.map = GridMap(rows=8, columns=8, size=(16, 16))
Propiedades
map.active
| Propiedad | Tipo | Por defecto |
|---|---|---|
active | bool | True |
Controla si la simulación de colisiones se ejecuta para este mapa. Cuando es False, no se procesan movimientos de cuerpos, colisiones ni callbacks para ningún GridBody adjunto a este mapa.
# Pausar colisiones (ej. menú de pausa)
level.map.active = False
# Reanudar colisiones
level.map.active = True
map.rows, map.columns
| Propiedad | Tipo |
|---|---|
rows | int |
columns | int |
El tamaño del mapa en celdas: el que se le dio al crearlo, o el tamaño con el que se pintó su .tilemap. Solo lectura. Multiplicados por el tamaño de celda, dan el tamaño del mapa en píxeles, para los límites de una cámara o para mantener un cuerpo dentro del mapa.
# El tamaño del mapa en píxeles
w = level.map.columns * 16
h = level.map.rows * 16
Modificar tiles
Usa map.set() para configurar tiles.
map.set(
row=0,
column=1,
tile=(tile_column, tile_row),
tag=optional_tag
)
Parámetros
| Parámetro | Tipo | Descripción |
|---|---|---|
row | int | Índice de fila de la cuadrícula |
column | int | Índice de columna de la cuadrícula |
tile | (x, y) | Coordenadas del tile en el atlas |
tag | int | Etiqueta de colisión opcional |
Ejemplo: establecer un tile
level.map.set(
row=2,
column=5,
tile=(3, 1)
)
Ejemplo: añadir etiqueta de colisión
level.map.set(
row=4,
column=2,
tile=(0, 0),
tag=1 # wall
)
Leer tiles
map.get(row, column) responde qué hay en una celda, como un par (tile, tag): lo que map.set() puso ahí, o lo que pintó el .tilemap.
tile, tag = level.map.get(row, column)
Parámetros
| Parámetro | Tipo | Descripción |
|---|---|---|
row | int | Índice de fila de la cuadrícula |
column | int | Índice de columna de la cuadrícula |
Devuelve
| Valor | Tipo | Descripción |
|---|---|---|
tile | (x, y) o -1 | Las coordenadas del tile en el atlas; -1 para una celda sin tile (vacía, o solo una etiqueta) |
tag | int | La etiqueta de la celda, 0 cuando no tiene |
Fuera del mapa, get responde (-1, 0) en lugar de un error, así un juego puede mirar una celda más allá de un borde.
Ejemplo: leer una celda
tile, tag = level.map.get(4, 2)
if tag == 1:
print("a wall")
if tile == -1:
print("aquí no hay nada pintado")
Objetos
Un .tilemap puede nombrar objetos (things) en sus celdas: un cofre, una puerta, el inicio del héroe. map.things() los lista como (name, row, column), por fila y luego por columna. Un mapa sin objetos, o creado con rows/columns explícitos, da una lista vacía.
village = world.spawn(map=GridMap(tilemap="village"))
for name, row, column in village.map.things():
if name == "chest":
place_chest(row, column) # la función propia del juego
El nombre de un objeto es el de un sprite, o el de un tipo (kind): un tipo es un nombre para un fotograma de un sprite, así que dos tipos pueden salir de un mismo sprite (un slime y un guard). Una celda tiene un solo objeto. Nada mueve ni dibuja un objeto; tu código decide en qué se convierte cada nombre. Cada llamada da una lista nueva, que puedes ordenar o vaciar libremente.
En el archivo, ambas son claves opcionales, ausentes cuando están vacías:
"kinds": [ {"frame": 1, "name": "guard", "sprite": "slime"} ],
"things": [ {"column": 16, "name": "chest", "row": 1} ]
map.props(row, column)
Un objeto puede llevar propiedades, fijadas en el editor de tilemaps: el contenido de un cofre, el texto de un cartel, la celda donde está la llave de una puerta. map.props(row, column) da las propiedades del objeto de esa celda como un dict: {} para un objeto sin ninguna, una celda vacía, una celda fuera del mapa o un mapa creado con rows/columns explícitos. Cada llamada da un dict nuevo: cambiarlo no cambia nada en el mapa.
| En el editor | En el dict | Ejemplo |
|---|---|---|
| Texto | str | "Gone north." |
| Número | int, o float si se escribe con punto | 3, 1.5 |
| Sí / No | bool | True |
| Objeto o celda | (row, column) | (1, 5) |
village = world.spawn(map=GridMap(tilemap="village"))
door = village.map.props(1, 4)
if door.get("locked", False):
row, column = door["key_from"] # la celda donde está la llave
key = village.map.props(row, column) # las propiedades de ese objeto
row y column también pueden darse por palabra clave: map.props(row=1, column=4). get(key, default) lee una clave que un objeto quizá no tenga: el valor por defecto vive en tu código.
La mecánica de nivel las lee en un punto: level.props(level.spot("sign"))["text"].
En el archivo, "props" es una clave opcional de un objeto, con sus claves ordenadas y omitida cuando está vacía; un Objeto o celda se escribe {"column", "row"}:
"things": [ {"column": 4, "name": "door", "props": {"key_from": {"column": 5, "row": 1}, "locked": true}, "row": 1} ]
Coordenadas de la cuadrícula
- Las filas aumentan verticalmente
- Las columnas aumentan horizontalmente
Los índices fuera de los límites se ignoran de forma segura.
GridMap + GridBody
Un GridBody interactúa con el GridMap para colisión, resolución de movimiento y detección de disparadores.
GridBody debe ser hijo de la entidad GridMap.
level = world.spawn(
map=GridMap(
rows=8,
columns=8,
size=(16, 16),
image="tiles"
)
)
player = world.spawn(
body=GridBody(),
parent=level
)
Ejemplo mínimo: nivel básico
level = world.spawn(
map=GridMap(
rows=8,
columns=8,
size=(16, 16),
image="tiles"
)
)
# Crear suelo
for r in range(8):
for c in range(8):
level.map.set(row=r, column=c, tile=(0, 0))
# Crear paredes
for c in range(8):
level.map.set(row=0, column=c, tile=(1, 0), tag=1)
level.map.set(row=7, column=c, tile=(1, 0), tag=1)
Etiquetas
tag es metadato opcional por tile.
Usos típicos:
0— vacío1— pared2— agua3— zona de daño
Las etiquetas son interpretadas por tu sistema de juego o colisión.