pyxen.GridBody

Un GridBody es un componente de colisión basado en cuadrícula que interactúa con un GridMap.

Para conceptos de colisión, consulta Colisión.

Constructor

GridBody(
    *,
    pos=None,
    size=None,
    move=None,
    tag=None,
    mask=None
)

Todos los parámetros son solo por nombre.

Parámetros

Ejemplo

e = world.spawn(
    name="hero",
    sprite=sprite,
    layer=LAYER_HERO,
    body=GridBody(
        pos=(64, 64),
        size=(16, 16),
        move=(0, 0),
        tag=TAG_PLAYER,
        mask=(TAG_WALL, TAG_MONSTER)
    )
)

Adjuntar un GridBody

Durante spawn():

player = world.spawn(
    body=GridBody(pos=(32, 32), size=(16, 16))
)

O después:

entity = world.spawn()
entity.body = GridBody(size=(16, 16))

Propiedades

move

Establece el vector de movimiento por fotograma con una tupla o Vector2. move acepta flotantes, así que puedes moverte a velocidades de subpíxel:

body.move = (1, 0)      # 1 pixel/frame
body.move = (0.5, 0)    # half a pixel/frame — moves 1px every other frame

move persiste entre fotogramas (es una velocidad por fotograma); establécelo en (0, 0) para detenerte. Las posiciones siguen siendo perfectas al píxel: el movimiento fraccionario se acumula y se aplica un píxel entero cada vez, de modo que la colisión y el renderizado se mantienen nítidos y deterministas.

Leer move devuelve un Vector2:

m = body.move
print(m.x, m.y)

pos

La esquina superior izquierda del cuerpo, en píxeles enteros, tal como la toma GridBody(pos=...). Los x e y de la entidad son el centro del cuerpo: pos más la mitad de size.

Cambiar pos pone el cuerpo allí de golpe, a través de lo que haya entre medias, sin colisión. Su move se conserva, y los x e y de la entidad lo siguen en el mismo fotograma. Leer pos devuelve un Vector2.

body.pos = (32, 64)    # esquina superior izquierda en (32, 64)
size = body.size
body.pos = (spot.x - size.x / 2, spot.y - size.y / 2)    # su centro en spot

size

El ancho y el alto del cuerpo, en píxeles enteros, tal como los fijó GridBody(size=...). Solo lectura; un Vector2.

Propiedades planificadas

Sistema de etiquetas

tag

Cada cuerpo tiene una sola etiqueta:

body.tag = TAG_PLAYER

mask

La máscara define con qué etiquetas colisiona este cuerpo:

body.mask = (TAG_WALL, TAG_MONSTER)

Interacción GridBody + GridMap

Un GridBody colisiona con tiles en un GridMap y otros GridBodies basándose en el filtrado de etiquetas.

GridBody debe ser hijo de una entidad GridMap para que las colisiones se resuelvan.

Ejemplo de movimiento

body = player.body

if input.keyboard.left.down:
    body.move = (-1, 0)

if input.keyboard.right.down:
    body.move = (1, 0)

Configuración mínima

level = world.spawn(
    map=GridMap(
        rows=10,
        columns=10,
        size=(16, 16)
    )
)

player = world.spawn(
    parent=level,
    body=GridBody(
        pos=(16, 16),
        size=(16, 16),
        tag=1,
        mask=(2,)
    )
)

Patrón común: jugador contra paredes

TAG_PLAYER = 1
TAG_WALL = 2

player = world.spawn(
    body=GridBody(
        pos=(32, 32),
        size=(16, 16),
        tag=TAG_PLAYER,
        mask=(TAG_WALL,)
    )
)

Si un tile se establece con:

map.set(row=0, column=5, tag=TAG_WALL)

El jugador colisionará con él.