pyxen.GridMap

Un GridMap est un conteneur spatial composé de cellules organisées en lignes et colonnes.

Il définit la disposition des tuiles, la taille des cellules, l’atlas de tuiles optionnel, et l’espace de collision pour les GridBody.

Pour les concepts de collision, consultez Collision.

Constructeur

GridMap(
    *,
    rows=None,
    columns=None,
    size=None,
    image=None,
    tilemap=None
)

Tous les paramètres sont par mot-clé uniquement.

Paramètres

Exemple

level_map = GridMap(
    rows=10,
    columns=16,
    size=(16, 16),
    image="tileset"
)

Attacher un GridMap

Lors du spawn :

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

Ou plus tard :

entity = world.spawn()
entity.map = GridMap(rows=8, columns=8, size=(16, 16))

Propriétés

map.active

Contrôle si la simulation de collision est active pour cette map. Lorsque la valeur est False, aucun déplacement, collision ou callback n’est traité pour les GridBody attachés à cette map.

# Mettre en pause les collisions (ex. menu pause)
level.map.active = False

# Reprendre les collisions
level.map.active = True

map.rows, map.columns

La taille de la map en cases : celle donnée à sa création, ou celle à laquelle son .tilemap a été peint. En lecture seule. Multipliées par la taille d’une case, elles donnent la taille de la map en pixels, pour les limites d’une caméra ou pour garder un corps dans la map.

# La taille de la map en pixels
w = level.map.columns * 16
h = level.map.rows * 16

Modifier les tuiles

Utilisez map.set() pour configurer les tuiles.

map.set(
    row=0,
    column=1,
    tile=(tile_column, tile_row),
    tag=optional_tag
)

Paramètres

Exemple : Définir une tuile

level.map.set(
    row=2,
    column=5,
    tile=(3, 1)
)

Exemple : Ajouter un tag de collision

level.map.set(
    row=4,
    column=2,
    tile=(0, 0),
    tag=1  # wall
)

Lire les tuiles

map.get(row, column) répond ce qu’il y a dans une case, sous la forme d’une paire (tile, tag) : ce que map.set() y a mis, ou ce que le .tilemap y a peint.

tile, tag = level.map.get(row, column)

Paramètres

Valeur renvoyée

Hors de la carte, get répond (-1, 0) plutôt qu’une erreur : un jeu peut regarder une case au-delà d’un bord.

Exemple : lire une case

tile, tag = level.map.get(4, 2)
if tag == 1:
    print("a wall")
if tile == -1:
    print("rien de peint ici")

Objets

Un .tilemap peut nommer des objets (things) sur ses cases : un coffre, une porte, le départ du héros. map.things() les liste sous la forme (name, row, column), par ligne puis par colonne. Une carte sans objets, ou construite avec rows/columns explicites, donne une liste vide.

village = world.spawn(map=GridMap(tilemap="village"))

for name, row, column in village.map.things():
    if name == "chest":
        place_chest(row, column)   # la fonction du jeu

Le nom d’un objet est celui d’un sprite, ou celui d’un genre (kind) : un genre est un nom pour une image d’un sprite, si bien que deux genres peuvent venir d’un même sprite (un slime et un guard). Une case porte un seul objet. Rien ne déplace ni ne dessine un objet : votre code décide de ce que devient chaque nom. Chaque appel donne une nouvelle liste, que vous pouvez trier ou vider librement.

Dans le fichier, ce sont deux clés optionnelles, absentes quand elles sont vides :

"kinds": [ {"frame": 1, "name": "guard", "sprite": "slime"} ],
"things": [ {"column": 16, "name": "chest", "row": 1} ]

Coordonnées de la grille

• Les lignes augmentent verticalement
• Les colonnes augmentent horizontalement

Les indices hors limites sont ignorés en toute sécurité.

GridMap + GridBody

Un GridBody interagit avec le GridMap pour la collision, la résolution de déplacement et la détection de déclencheurs.

Le GridBody doit être un enfant de l’entité GridMap.

level = world.spawn(
    map=GridMap(
        rows=8,
        columns=8,
        size=(16, 16),
        image="tiles"
    )
)

player = world.spawn(
    body=GridBody(),
    parent=level
)

Exemple minimal : Niveau basique

level = world.spawn(
    map=GridMap(
        rows=8,
        columns=8,
        size=(16, 16),
        image="tiles"
    )
)

# Créer le sol
for r in range(8):
    for c in range(8):
        level.map.set(row=r, column=c, tile=(0, 0))

# Créer les murs
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)

Tags

tag est une métadonnée optionnelle par tuile.

Utilisations typiques :

• 0 — vide
• 1 — mur
• 2 — eau
• 3 — zone de dégâts

Les tags sont interprétés par votre système de gameplay ou de collision.