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 ( |
Diese Anleitung ( |
|---|---|
2D-Liste mit Zahlen |
Liste von Dictionaries |
|
|
Position = |
Position = |
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:
Er fügt einen neuen Eintrag zu
enemy_datahinzu.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 |
|---|---|
|
Zombie, Fledermaus oder Geist auswählen |
Linksklick |
ausgewählten Gegner platzieren |
Rechtsklick |
Gegner unter der Maus entfernen |
|
|
Zusammenfassung#
Eine normale
Worldist ein freier Canvas, Positionen sind Pixel.Eine Liste von Dictionaries beschreibt das Level. Ein Dictionary von Klassen übersetzt Typnamen in Actors, wie
tilesim 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_downfü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.