Anleitung: Gegner auf einem Canvas platzieren#

Im Labyrinth-Spiel ist das Level eine Tilemap: eine 2D-Liste, in der jede Zelle eine Zahl enthält und jede Zahl für eine Actor-Klasse steht. Das funktioniert gut in einer TiledWorld, in der alles auf einem festen Raster liegt.

Viele Spiele haben kein Raster. Gegner stehen dort, wo der Level-Designer sie haben möchte. In dieser Anleitung verwendest du eine normale World als freien Canvas, platzierst verschiedene Gegnertypen per Maus darauf und speicherst das Ergebnis in einer Datenstruktur. Aus diesen Daten kannst du das Level jederzeit neu aufbauen.

Die Idee ist dieselbe wie im Labyrinth-Spiel:

Labyrinth-Spiel (TiledWorld)

Diese Anleitung (World)

2D-Liste mit Zahlen

Liste von Dictionaries

tiles = [None, Wall, Player]

ENEMY_TYPES = {"zombie": Zombie, ...}

Position = (Spalte, Zeile)

Position = (x, y) in Pixeln

Für diese Anleitung brauchst du keine Bilddateien. Die Gegner werden als farbige Quadrate gezeichnet. Später kannst du sie durch add_costume("...") ersetzen.


Schritt 1: Ein Canvas und verschiedene Gegnertypen#

Eine World(width, height) ist ein freier Canvas, der in Pixeln gemessen wird. Erstelle für jeden Typ von Gegner eine Unterklasse von Actor:

import miniworlds

world = miniworlds.World(400, 300)
world.add_background((30, 30, 40))


class Zombie(miniworlds.Actor):
    def on_setup(self):
        self.size = (30, 30)
        self.fill_color = (0, 160, 0)


class Bat(miniworlds.Actor):
    def on_setup(self):
        self.size = (24, 24)
        self.fill_color = (150, 0, 200)


class Ghost(miniworlds.Actor):
    def on_setup(self):
        self.size = (34, 34)
        self.fill_color = (220, 220, 220)


Zombie((80, 80))
Bat((200, 150))
Ghost((320, 220))

world.run()

Zombie((80, 80)) erzeugt einen Gegner an der Pixelposition x=80, y=80. Jeder Gegnertyp sieht anders aus, aber alle haben dieselbe Basisklasse.


Schritt 2: Die Gegner in einer Datenstruktur speichern#

Wenn du Gegner direkt im Code erzeugst, kannst du sie später weder speichern noch ändern. Besser: Beschreibe das Level zuerst als Daten und erzeuge dann die Actors aus diesen Daten.

Ein Gegner wird durch seinen Typ und seine Position beschrieben. Dafür eignet sich ein Dictionary, und eine Liste enthält alle Gegner des Levels:

enemy_data = [
    {"type": "zombie", "x": 80, "y": 80},
    {"type": "bat", "x": 200, "y": 150},
    {"type": "ghost", "x": 320, "y": 220},
]

Wie tiles im Labyrinth-Spiel übersetzt eine zweite Struktur den Text in "type" in eine Klasse:

ENEMY_TYPES = {
    "zombie": Zombie,
    "bat": Bat,
    "ghost": Ghost,
}

Jetzt baut eine Funktion das gesamte Level aus den Daten auf:

def build_enemies(data):
    for actor in list(world.actors):
        actor.remove()
    for entry in data:
        enemy_class = ENEMY_TYPES[entry["type"]]
        enemy_class((entry["x"], entry["y"]))


build_enemies(enemy_data)

Zuerst werden alle vorhandenen Actors entfernt. So kannst du die Funktion jederzeit erneut aufrufen, zum Beispiel um ein anderes Level zu laden.

Bemerkung

list(world.actors) erzeugt eine Kopie der Liste. Ohne die Kopie würdest du die Liste verändern, während du darüber iterierst.


Schritt 3: Gegner mit der Maus platzieren#

Jetzt wird das Level interaktiv erstellt. Der Spieler (hier: der Level-Designer) wählt mit den Tasten 1, 2 und 3 einen Gegnertyp und platziert ihn per Linksklick. Jeder Klick macht zwei Dinge:

  1. Er fügt einen neuen Eintrag zu enemy_data hinzu.

  2. Er erzeugt den passenden Actor.

selected = "zombie"


@world.register
def on_key_down(self, keys):
    global selected
    if "1" in keys:
        selected = "zombie"
    if "2" in keys:
        selected = "bat"
    if "3" in keys:
        selected = "ghost"


@world.register
def on_mouse_left_down(self, mouse_pos):
    enemy_data.append({"type": selected, "x": mouse_pos[0], "y": mouse_pos[1]})
    ENEMY_TYPES[selected](mouse_pos)

Wichtig

Verwende hier on_mouse_left_down und nicht on_mouse_left. on_mouse_left wird immer wieder aufgerufen, solange die Taste gehalten wird, ein Klick würde also mehrere Gegner erzeugen. on_mouse_left_down wird genau einmal pro Klick ausgelöst.


Schritt 4: Gegner entfernen#

Ein Rechtsklick entfernt den Gegner, der der Maus am nächsten ist. Entferne den Eintrag aus den Daten und baue das Level neu auf, damit Daten und Actors immer übereinstimmen:

@world.register
def on_mouse_right_down(self, mouse_pos):
    for entry in reversed(enemy_data):
        close_x = abs(entry["x"] - mouse_pos[0]) < 20
        close_y = abs(entry["y"] - mouse_pos[1]) < 20
        if close_x and close_y:
            enemy_data.remove(entry)
            break
    build_enemies(enemy_data)

reversed(...) prüft zuerst den zuletzt platzierten Gegner. Das ist der, der oben gezeichnet wird.

Die wichtige Entwurfsregel: Die Daten sind die Wahrheit. Die Actors sind nur eine Darstellung davon. Wenn sich etwas ändert, ändere zuerst die Daten.


Schritt 5: Speichern und Laden#

Da das Level eine Liste von Dictionaries aus Text und Zahlen ist, kannst du es mit dem Standardmodul json direkt als JSON-Datei speichern:

import json


def save_level(filename):
    with open(filename, "w") as file:
        json.dump(enemy_data, file)


def load_level(filename):
    global enemy_data
    with open(filename) as file:
        enemy_data = json.load(file)
    build_enemies(enemy_data)

Rufe sie aus dem Tastenhandler auf, zum Beispiel mit s zum Speichern und l zum Laden:

@world.register
def on_key_down(self, keys):
    global selected
    if "1" in keys:
        selected = "zombie"
    if "2" in keys:
        selected = "bat"
    if "3" in keys:
        selected = "ghost"
    if "s" in keys:
        save_level("enemies.json")
    if "l" in keys:
        load_level("enemies.json")

Die Datei enthält dein Level als lesbaren Text:

[{"type": "zombie", "x": 80, "y": 80}, {"type": "bat", "x": 200, "y": 150}]

Mehrere Levels kannst du in einem Dictionary halten, wie die Räume in Level laden:

levels = {
    1: [{"type": "zombie", "x": 80, "y": 80}],
    2: [{"type": "bat", "x": 200, "y": 150}, {"type": "ghost", "x": 300, "y": 90}],
}

build_enemies(levels[2])

Schritt 6: Jedem Gegnertyp ein eigenes Verhalten geben#

Da jeder Typ eine eigene Klasse ist, kann sich jeder anders verhalten. Füge eine act-Methode hinzu. Sie wird einmal pro Frame aufgerufen:

class Zombie(miniworlds.Actor):
    def on_setup(self):
        self.size = (30, 30)
        self.fill_color = (0, 160, 0)
        self.speed = 1

    def act(self):
        self.x += self.speed
        if self.x < 0 or self.x > self.world.width:
            self.speed = -self.speed


class Bat(miniworlds.Actor):
    def on_setup(self):
        self.size = (24, 24)
        self.fill_color = (150, 0, 200)
        self.speed = 2

    def act(self):
        self.y += self.speed
        if self.y < 0 or self.y > self.world.height:
            self.speed = -self.speed

Zombies patrouillieren horizontal, Fledermäuse fliegen auf und ab, Geister bleiben an ihrem Platz. Da build_enemies nur den Typ und die Position braucht, ändert sich die Datenstruktur nicht, wenn du Verhalten hinzufügst.


Vollständiges Beispiel#

import json
import miniworlds

world = miniworlds.World(400, 300)
world.add_background((30, 30, 40))


class Zombie(miniworlds.Actor):
    def on_setup(self):
        self.size = (30, 30)
        self.fill_color = (0, 160, 0)
        self.speed = 1

    def act(self):
        self.x += self.speed
        if self.x < 0 or self.x > self.world.width:
            self.speed = -self.speed


class Bat(miniworlds.Actor):
    def on_setup(self):
        self.size = (24, 24)
        self.fill_color = (150, 0, 200)
        self.speed = 2

    def act(self):
        self.y += self.speed
        if self.y < 0 or self.y > self.world.height:
            self.speed = -self.speed


class Ghost(miniworlds.Actor):
    def on_setup(self):
        self.size = (34, 34)
        self.fill_color = (220, 220, 220)


ENEMY_TYPES = {"zombie": Zombie, "bat": Bat, "ghost": Ghost}
selected = "zombie"
enemy_data = []


def build_enemies(data):
    for actor in list(world.actors):
        actor.remove()
    for entry in data:
        enemy_class = ENEMY_TYPES[entry["type"]]
        enemy_class((entry["x"], entry["y"]))


def save_level(filename):
    with open(filename, "w") as file:
        json.dump(enemy_data, file)


def load_level(filename):
    global enemy_data
    with open(filename) as file:
        enemy_data = json.load(file)
    build_enemies(enemy_data)


@world.register
def on_key_down(self, keys):
    global selected
    if "1" in keys:
        selected = "zombie"
    if "2" in keys:
        selected = "bat"
    if "3" in keys:
        selected = "ghost"
    if "s" in keys:
        save_level("enemies.json")
    if "l" in keys:
        load_level("enemies.json")


@world.register
def on_mouse_left_down(self, mouse_pos):
    enemy_data.append({"type": selected, "x": mouse_pos[0], "y": mouse_pos[1]})
    ENEMY_TYPES[selected](mouse_pos)


@world.register
def on_mouse_right_down(self, mouse_pos):
    for entry in reversed(enemy_data):
        close_x = abs(entry["x"] - mouse_pos[0]) < 20
        close_y = abs(entry["y"] - mouse_pos[1]) < 20
        if close_x and close_y:
            enemy_data.remove(entry)
            break
    build_enemies(enemy_data)


world.run()

Eingabe

Aktion

1, 2, 3

Zombie, Fledermaus oder Geist auswählen

Linksklick

ausgewählten Gegner platzieren

Rechtsklick

Gegner unter der Maus entfernen

s / l

enemies.json speichern / laden


Zusammenfassung#

  • Eine normale World ist ein freier Canvas, Positionen sind Pixel.

  • Eine Liste von Dictionaries beschreibt das Level. Ein Dictionary von Klassen übersetzt Typnamen in Actors, wie tiles im Labyrinth-Spiel.

  • Eine Funktion build_enemies(data) erzeugt alle Actors aus den Daten.

  • Ändere zuerst die Daten und baue dann neu auf. Dann sind Speichern, Laden und Levelwechsel fast geschenkt.

  • Verwende on_mouse_left_down für einzelne Klicks.

Ideen zum Weitermachen: Füge einen vierten Gegnertyp hinzu, speichere zusätzliche Eigenschaften wie "speed" oder "health" in jedem Dictionary oder ergänze einen Spieler und einen “Spielmodus”, in dem sich die Gegner erst nach einem Tastendruck bewegen.