pyxen.GridMap

Eine GridMap ist ein räumlicher Container aus Zellen, die in Zeilen und Spalten angeordnet sind.

Sie definiert das Tile-Layout, die Zellgröße, einen optionalen Tile-Atlas und den Kollisionsraum für GridBody.

Kollisionskonzepte findest du unter Kollision.

Konstruktor

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

Alle Parameter sind Keyword-only.

Parameter

Beispiel

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

Eine GridMap anhängen

Beim Spawn:

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

Oder nachträglich:

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

Eigenschaften

map.active

Steuert, ob die Kollisionssimulation für diese Map läuft. Bei False werden keine Körperbewegungen, Kollisionen oder Callbacks für GridBody-Objekte dieser Map verarbeitet.

# Kollisionen pausieren (z.B. Pausenmenü)
level.map.active = False

# Kollisionen fortsetzen
level.map.active = True

map.rows, map.columns

Die Größe der Map in Zellen: die beim Erstellen angegebene oder die, in der ihre .tilemap gemalt wurde. Nur lesbar. Mal der Zellgröße ergeben sie die Größe der Map in Pixeln, für die Grenzen einer Kamera oder um einen Körper in der Map zu halten.

# Die Größe der Map in Pixeln
w = level.map.columns * 16
h = level.map.rows * 16

Tiles bearbeiten

Verwende map.set(), um Tiles zu konfigurieren.

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

Parameter

Beispiel: Ein Tile setzen

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

Beispiel: Kollisions-Tag hinzufügen

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

Tiles lesen

map.get(row, column) sagt, was in einer Zelle liegt, als Paar (tile, tag): was map.set() dort gesetzt oder die .tilemap dort gemalt hat.

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

Parameter

Rückgabe

Außerhalb der Karte antwortet get mit (-1, 0) statt mit einem Fehler, so kann ein Spiel eine Zelle über den Rand hinaus nachsehen.

Beispiel: Eine Zelle lesen

tile, tag = level.map.get(4, 2)
if tag == 1:
    print("a wall")
if tile == -1:
    print("hier ist nichts gemalt")

Dinge

Eine .tilemap kann Dinge (things) auf ihren Zellen benennen: eine Truhe, eine Tür, den Start des Helden. map.things() listet sie als (name, row, column), nach Zeile, dann Spalte. Eine Karte ohne Dinge, oder mit expliziten rows/columns erstellt, gibt eine leere Liste.

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

for name, row, column in village.map.things():
    if name == "chest":
        place_chest(row, column)   # die eigene Funktion des Spiels

Der Name eines Dings ist der Name eines Sprites oder einer Art (kind): Eine Art ist ein Name für ein Frame eines Sprites, so können zwei Arten aus einem Sprite gezeichnet werden (ein slime und ein guard). Eine Zelle trägt ein Ding. Nichts bewegt oder zeichnet ein Ding; dein Code entscheidet, was aus jedem Namen wird. Jeder Aufruf gibt eine neue Liste, die du frei sortieren oder leeren kannst.

In der Datei sind beide optionale Schlüssel, die fehlen, wenn sie leer sind:

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

Rasterkoordinaten

• Zeilen nehmen vertikal zu
• Spalten nehmen horizontal zu

Indizes außerhalb der Grenzen werden sicher ignoriert.

GridMap + GridBody

Ein GridBody interagiert mit der GridMap für Kollision, Bewegungsauflösung und Trigger-Erkennung.

GridBody muss ein Kind des GridMap-Entity sein.

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

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

Minimalbeispiel: Einfaches Level

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

# Boden erstellen
for r in range(8):
    for c in range(8):
        level.map.set(row=r, column=c, tile=(0, 0))

# Wände erstellen
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 ist optionale Metadaten pro Tile.

Typische Verwendung:

• 0 — leer
• 1 — Wand
• 2 — Wasser
• 3 — Schadenszone

Tags werden von deiner Spiellogik oder deinem Kollisionssystem interpretiert.