Python lernen (Teil 9): Dateien und Speichern

datei = open("notiz.txt", "w", encoding="utf-8")

datei.write("Hallo, Verlies.\n")
datei.close()

with open("notiz.txt", "w", encoding="utf-8") as datei:
    datei.write("Hallo, Verlies.\n")

datei = open("notiz.txt", "w", encoding="utf-8")

try:
    datei.write("Hallo, Verlies.\n")
finally:
    datei.close()

with open("notiz.txt", "w", encoding="utf-8") as datei:
    ...

with open("logbuch.txt", "a", encoding="utf-8") as datei:
    datei.write("Du betrittst die Halle.\n")

encoding="utf-8"

with open("notiz.txt", "w", encoding="utf-8") as datei:
    datei.write("Schlüssel, Fackel, Südtor\n")

with open("notiz.txt", "r", encoding="utf-8") as datei:
    inhalt = datei.read()

print(inhalt)

with open("notiz.txt", encoding="utf-8") as datei:
    inhalt = datei.read()

with open("logbuch.txt", encoding="utf-8") as datei:
    for zeile in datei:
        print(zeile, end="")

print(zeile)

with open("logbuch.txt", encoding="utf-8") as datei:
    for zeile in datei:
        zeile = zeile.rstrip("\n")
        print(zeile)

"spielstand.json"

from pathlib import Path

speicherdatei = Path("spielstand.json")

if speicherdatei.exists():
    print("Spielstand gefunden.")

print(speicherdatei.name)

spielstand.json

ordner = Path("daten")
speicherdatei = ordner / "spielstand.json"

from pathlib import Path

pfad = Path("notiz.txt")

pfad.write_text("Hallo, Verlies.\n", encoding="utf-8")
text = pfad.read_text(encoding="utf-8")

print(text)

with pfad.open("w", encoding="utf-8") as datei:
    datei.write("Hallo, Verlies.\n")

Du bist in der Halle.

name=Karl
hp=75
gold=50
ort=halle
inventar=fackel,schluessel

{
  "version": 1,
  "ort": "halle",
  "spieler": {
    "name": "Karl",
    "hp": 75,
    "max_hp": 100,
    "gold": 50,
    "inventar": [
      "fackel",
      "schluessel"
    ]
  }
}

import json

daten = {
    "name": "Karl",
    "hp": 75,
    "inventar": ["Fackel", "Schlüssel"],
}

json.dumps(spieler)

import json
from pathlib import Path

daten = {
    "name": "Karl",
    "hp": 75,
    "inventar": ["Fackel", "Schlüssel"],
}

pfad = Path("spielstand.json")

with pfad.open("w", encoding="utf-8") as datei:
    json.dump(
        daten,
        datei,
        ensure_ascii=False,
        indent=2,
    )
    datei.write("\n")

ensure_ascii=False

datei.write("\n")

text = json.dumps(
    daten,
    ensure_ascii=False,
    indent=2,
)

print(text)

with pfad.open(encoding="utf-8") as datei:
    daten = json.load(datei)

print(daten["name"])
print(daten["hp"])

try:
    with pfad.open(encoding="utf-8") as datei:
        daten = json.load(datei)
except json.JSONDecodeError:
    print("Die Datei enthält kein gültiges JSON.")

Gegenstand("Fackel", "Eine rußige, aber noch brauchbare Fackel.")

Fackel
Alte Fackel
Rußige Fackel

"fackel"
"schluessel"

class Gegenstand:
    def __init__(self, kennung, name, beschreibung=""):
        self.kennung = kennung
        self.name = name
        self.beschreibung = beschreibung

GEGENSTANDS_DATEN = {
    "fackel": {
        "name": "Fackel",
        "beschreibung": "Eine rußige, aber noch brauchbare Fackel.",
    },
    "schluessel": {
        "name": "Schlüssel",
        "beschreibung": "Ein schwerer Eisenschlüssel mit rostigen Zähnen.",
    },
}

def erstelle_gegenstand(kennung):
    daten = GEGENSTANDS_DATEN[kennung]

    return Gegenstand(
        kennung=kennung,
        name=daten["name"],
        beschreibung=daten["beschreibung"],
    )

{
  "ort": "bibliothek",
  "spieler": {
    "name": "Karl",
    "inventar": ["fackel"]
  }
}

"raeume": {
  "halle": {
    "gegenstaende": []
  },
  "bibliothek": {
    "gegenstaende": ["schluessel"]
  },
  "krypta": {
    "gegenstaende": []
  }
}

def gegenstands_kennungen(gegenstaende):
    """Gibt die stabilen Kennungen mehrerer Gegenstände zurück."""
    return [
        gegenstand.kennung
        for gegenstand in gegenstaende
    ]

def erstelle_spielstand(spieler, ort, raeume, besuchte_raeume):
    """Wandelt den aktuellen State in JSON-kompatible Daten um."""
    return {
        "version": 1,
        "ort": ort,
        "besuchte_raeume": sorted(besuchte_raeume),
        "spieler": {
            "name": spieler.name,
            "hp": spieler.hp,
            "max_hp": spieler.max_hp,
            "gold": spieler.gold,
            "inventar": gegenstands_kennungen(spieler.inventar),
        },
        "raeume": {
            raum_id: {
                "gegenstaende": gegenstands_kennungen(
                    raum.gegenstaende
                ),
            }
            for raum_id, raum in raeume.items()
        },
    }

sorted(besuchte_raeume)

"version": 1

["fackel", "schluessel"]

def gegenstaende_aus_kennungen(kennungen):
    """Erstellt Gegenstände aus ihren gespeicherten Kennungen."""
    return [
        erstelle_gegenstand(kennung)
        for kennung in kennungen
    ]

spieler.name = spieler_daten["name"]
spieler.hp = spieler_daten["hp"]

# Dungeon – Teil 9: Dateien und Speichern
import json
from pathlib import Path


SPEICHERDATEI = Path("spielstand.json")


class DungeonError(Exception):
    """Basisklasse für erwartbare Fehler im Dungeon."""


class UngueltigerBefehlError(DungeonError):
    """Der eingegebene Befehl ist unbekannt oder unvollständig."""


class UnmoeglicheAktionError(DungeonError):
    """Eine bekannte Aktion ist im aktuellen State nicht möglich."""


class SpielstandError(DungeonError):
    """Der Spielstand kann nicht gespeichert oder geladen werden."""


class Gegenstand:
    """Ein Gegenstand, der in einem Raum oder Inventar liegen kann."""

    def __init__(self, kennung, name, beschreibung=""):
        self.kennung = kennung
        self.name = name
        self.beschreibung = beschreibung

    def __str__(self):
        return self.name

    def untersuche(self):
        if self.beschreibung:
            return self.beschreibung

        return f"An {self.name} fällt Dir nichts Besonderes auf."


class Spieler:
    """Verwaltet den State und das Verhalten des Spielers."""

    def __init__(self, name, max_hp=100, gold=0):
        name = name.strip()

        if not name:
            raise ValueError("Der Name darf nicht leer sein.")

        if max_hp <= 0:
            raise ValueError("max_hp muss größer als 0 sein.")

        if gold < 0:
            raise ValueError("gold darf nicht negativ sein.")

        self.name = name
        self.hp = max_hp
        self.max_hp = max_hp
        self.gold = gold
        self.inventar = []

    def nimm(self, gegenstand):
        self.inventar.append(gegenstand)

    def erleide_schaden(self, menge):
        if menge < 0:
            raise ValueError("Schaden darf nicht negativ sein.")

        self.hp = max(self.hp - menge, 0)

    def heile(self, menge):
        if menge < 0:
            raise ValueError("Heilung darf nicht negativ sein.")

        self.hp = min(self.hp + menge, self.max_hp)

    def ist_besiegt(self):
        return self.hp <= 0

    def zeige_inventar(self):
        if not self.inventar:
            print("Dein Inventar ist leer.")
            return

        print("Inventar:")

        for nummer, gegenstand in enumerate(self.inventar, start=1):
            print(f"  {nummer}) {gegenstand}")

    def __str__(self):
        return (
            f"{self.name} | "
            f"HP: {self.hp}/{self.max_hp} | "
            f"Gold: {self.gold} | "
            f"Inventar: {len(self.inventar)}"
        )


class Raum:
    """Ein Raum mit Beschreibung, Ausgängen und Gegenständen."""

    def __init__(
        self,
        name,
        beschreibung,
        ausgaenge=None,
        gegenstaende=None,
    ):
        self.name = name
        self.beschreibung = beschreibung
        self.ausgaenge = dict(ausgaenge) if ausgaenge is not None else {}
        self.gegenstaende = (
            list(gegenstaende)
            if gegenstaende is not None
            else []
        )

    def beschreibe(self):
        print()
        print(f"Ort: {self.name}")
        print(self.beschreibung)

        print("Ausgänge:")

        for nummer, richtung in enumerate(self.ausgaenge, start=1):
            print(f"  {nummer}) {richtung}")

        if self.gegenstaende:
            print(
                "Hier liegt:",
                ", ".join(str(g) for g in self.gegenstaende),
            )

    def zeige_gegenstaende(self):
        if not self.gegenstaende:
            print("Hier liegt nichts Brauchbares.")
            return

        print(
            "Hier liegt:",
            ", ".join(str(g) for g in self.gegenstaende),
        )

    def nimm_gegenstand(self, name):
        gesuchter_name = name.strip().lower()

        for gegenstand in self.gegenstaende:
            if gegenstand.name.lower() == gesuchter_name:
                self.gegenstaende.remove(gegenstand)
                return gegenstand

        raise UnmoeglicheAktionError(
            f"Hier liegt kein Gegenstand namens {name}."
        )

    def ziel(self, richtung):
        try:
            return self.ausgaenge[richtung]
        except KeyError:
            raise UnmoeglicheAktionError(
                f"Du kannst nicht nach {richtung} gehen."
            ) from None


GEGENSTANDS_DATEN = {
    "fackel": {
        "name": "Fackel",
        "beschreibung": "Eine rußige, aber noch brauchbare Fackel.",
    },
    "schluessel": {
        "name": "Schlüssel",
        "beschreibung": "Ein schwerer Eisenschlüssel mit rostigen Zähnen.",
    },
}


def erstelle_gegenstand(kennung):
    """Erstellt einen Gegenstand anhand seiner stabilen Kennung."""
    if not isinstance(kennung, str):
        raise SpielstandError(
            "Eine Gegenstandskennung hat ein unerwartetes Format."
        )

    try:
        daten = GEGENSTANDS_DATEN[kennung]
    except KeyError:
        raise SpielstandError(
            f"Unbekannter Gegenstand im Spielstand: {kennung}"
        ) from None

    return Gegenstand(
        kennung=kennung,
        name=daten["name"],
        beschreibung=daten["beschreibung"],
    )


def erstelle_raeume():
    """Erstellt die Dungeon-Welt."""
    return {
        "halle": Raum(
            name="Halle",
            beschreibung=(
                "Du stehst in einer dunklen Halle mit moderigem Geruch."
            ),
            ausgaenge={
                "norden": "bibliothek",
                "osten": "krypta",
            },
            gegenstaende=[erstelle_gegenstand("fackel")],
        ),
        "bibliothek": Raum(
            name="Bibliothek",
            beschreibung=(
                "Staubige Regale voller zerfledderter Bücher umgeben Dich."
            ),
            ausgaenge={
                "sueden": "halle",
            },
            gegenstaende=[erstelle_gegenstand("schluessel")],
        ),
        "krypta": Raum(
            name="Krypta",
            beschreibung=(
                "Feuchtigkeit glänzt auf den Wänden der alten Krypta."
            ),
            ausgaenge={
                "westen": "halle",
            },
        ),
    }


def frage_ganzzahl(text, minimum=None):
    """Fragt so lange nach einer Ganzzahl, bis die Eingabe gültig ist."""
    while True:
        eingabe = input(text)

        try:
            wert = int(eingabe)
        except ValueError:
            print("Bitte gib eine ganze Zahl ein.")
            continue

        if minimum is not None and wert < minimum:
            print(f"Der Wert muss mindestens {minimum} betragen.")
            continue

        return wert


def frage_name(text):
    """Fragt so lange nach, bis ein nicht leerer Name eingegeben wurde."""
    while True:
        name = input(text).strip()

        if name:
            return name

        print("Der Name darf nicht leer sein.")


def teile_befehl(eingabe):
    """Zerlegt den Input in ein Verb und ein optionales Argument."""
    verb, _, argument = eingabe.strip().lower().partition(" ")

    if not verb:
        raise UngueltigerBefehlError(
            "Bitte gib einen Befehl ein."
        )

    return verb, argument.strip()


def finde_raeume_mit_loot(raeume):
    """Gibt die Namen aller Räume mit Gegenständen zurück."""
    return [
        raum.name
        for raum in raeume.values()
        if raum.gegenstaende
    ]


def gegenstands_kennungen(gegenstaende):
    """Gibt die stabilen Kennungen mehrerer Gegenstände zurück."""
    return [
        gegenstand.kennung
        for gegenstand in gegenstaende
    ]


def gegenstaende_aus_kennungen(kennungen):
    """Erstellt Gegenstände aus ihren gespeicherten Kennungen."""
    if not isinstance(kennungen, list):
        raise SpielstandError(
            "Eine Gegenstandsliste hat ein unerwartetes Format."
        )

    return [
        erstelle_gegenstand(kennung)
        for kennung in kennungen
    ]


def erstelle_spielstand(spieler, ort, raeume, besuchte_raeume):
    """Wandelt den aktuellen State in JSON-kompatible Daten um."""
    return {
        "version": 1,
        "ort": ort,
        "besuchte_raeume": sorted(besuchte_raeume),
        "spieler": {
            "name": spieler.name,
            "hp": spieler.hp,
            "max_hp": spieler.max_hp,
            "gold": spieler.gold,
            "inventar": gegenstands_kennungen(spieler.inventar),
        },
        "raeume": {
            raum_id: {
                "gegenstaende": gegenstands_kennungen(
                    raum.gegenstaende
                ),
            }
            for raum_id, raum in raeume.items()
        },
    }


def rekonstruiere_spielstand(daten):
    """Erzeugt aus geladenen Daten einen neuen Dungeon-State."""
    if not isinstance(daten, dict):
        raise SpielstandError(
            "Der Spielstand hat ein unerwartetes Format."
        )

    if daten.get("version") != 1:
        raise SpielstandError(
            "Der Spielstand hat eine unbekannte Version."
        )

    try:
        spieler_daten = daten["spieler"]
        raeume_daten = daten["raeume"]
        ort = daten["ort"]
        besuchte_daten = daten["besuchte_raeume"]

        name = spieler_daten["name"]
        hp = spieler_daten["hp"]
        max_hp = spieler_daten["max_hp"]
        gold = spieler_daten["gold"]
        inventar_kennungen = spieler_daten["inventar"]
    except (KeyError, TypeError) as fehler:
        raise SpielstandError(
            "Der Spielstand hat ein unerwartetes Format."
        ) from fehler

    if not isinstance(name, str):
        raise SpielstandError(
            "Der gespeicherte Spielername ist ungültig."
        )

    if not isinstance(max_hp, int) or max_hp <= 0:
        raise SpielstandError(
            "Die gespeicherten maximalen Lebenspunkte sind ungültig."
        )

    if not isinstance(hp, int) or not 0 <= hp <= max_hp:
        raise SpielstandError(
            "Die gespeicherten Lebenspunkte sind ungültig."
        )

    if not isinstance(gold, int) or gold < 0:
        raise SpielstandError(
            "Der gespeicherte Goldwert ist ungültig."
        )

    raeume = erstelle_raeume()

    if (
        not isinstance(raeume_daten, dict)
        or set(raeume_daten) != set(raeume)
    ):
        raise SpielstandError(
            "Der Spielstand passt nicht zur aktuellen Dungeon-Welt."
        )

    if not isinstance(ort, str) or ort not in raeume:
        raise SpielstandError(
            f"Unbekannter aktueller Raum im Spielstand: {ort!r}"
        )

    if not isinstance(besuchte_daten, list):
        raise SpielstandError(
            "Die Liste der besuchten Räume hat ein unerwartetes Format."
        )

    try:
        besuchte_raeume = set(besuchte_daten)
    except TypeError as fehler:
        raise SpielstandError(
            "Die Liste der besuchten Räume hat ein unerwartetes Format."
        ) from fehler

    if not besuchte_raeume <= set(raeume):
        raise SpielstandError(
            "Der Spielstand enthält unbekannte besuchte Räume."
        )

    try:
        spieler = Spieler(
            name=name,
            max_hp=max_hp,
            gold=gold,
        )
    except ValueError as fehler:
        raise SpielstandError(
            "Die Spielerdaten sind ungültig."
        ) from fehler

    spieler.hp = hp
    spieler.inventar = gegenstaende_aus_kennungen(
        inventar_kennungen
    )

    try:
        for raum_id, raum in raeume.items():
            raum.gegenstaende = gegenstaende_aus_kennungen(
                raeume_daten[raum_id]["gegenstaende"]
            )
    except (KeyError, TypeError) as fehler:
        raise SpielstandError(
            "Die Raumdaten haben ein unerwartetes Format."
        ) from fehler

    return spieler, ort, raeume, besuchte_raeume


def speichere_spielstand(spieler, ort, raeume, besuchte_raeume):
    """Schreibt den aktuellen Spielstand als JSON-Datei."""
    daten = erstelle_spielstand(
        spieler=spieler,
        ort=ort,
        raeume=raeume,
        besuchte_raeume=besuchte_raeume,
    )

    try:
        with SPEICHERDATEI.open("w", encoding="utf-8") as datei:
            json.dump(
                daten,
                datei,
                ensure_ascii=False,
                indent=2,
            )
            datei.write("\n")
    except OSError as fehler:
        raise SpielstandError(
            f"Der Spielstand konnte nicht gespeichert werden: {fehler}"
        ) from fehler


def lade_spielstand():
    """Lädt und rekonstruiert einen gespeicherten Dungeon-State."""
    try:
        with SPEICHERDATEI.open(encoding="utf-8") as datei:
            daten = json.load(datei)
    except FileNotFoundError:
        raise SpielstandError(
            "Kein Spielstand gefunden."
        ) from None
    except UnicodeDecodeError as fehler:
        raise SpielstandError(
            "Der Spielstand ist keine gültige UTF-8-Datei."
        ) from fehler
    except json.JSONDecodeError as fehler:
        raise SpielstandError(
            "Der Spielstand enthält kein gültiges JSON."
        ) from fehler
    except OSError as fehler:
        raise SpielstandError(
            f"Der Spielstand konnte nicht gelesen werden: {fehler}"
        ) from fehler

    return rekonstruiere_spielstand(daten)


def verarbeite_befehl(
    verb,
    argument,
    spieler,
    raum,
    raeume,
    besuchte_raeume,
):
    """
    Verarbeitet einen Befehl.

    Gibt die ID eines neuen Raums oder None zurück.
    """
    if verb == "umsehen":
        raum.zeige_gegenstaende()
        return None

    if verb == "nimm":
        if not argument:
            raise UngueltigerBefehlError(
                "Was möchtest Du nehmen?"
            )

        gegenstand = raum.nimm_gegenstand(argument)
        spieler.nimm(gegenstand)

        print(f"Du nimmst {gegenstand}.")
        print(gegenstand.untersuche())

        return None

    if verb == "inventar":
        spieler.zeige_inventar()
        return None

    if verb == "status":
        print(spieler)
        print(f"Besuchte Räume: {len(besuchte_raeume)}")
        return None

    if verb == "loot":
        raeume_mit_loot = finde_raeume_mit_loot(raeume)
        text = (
            ", ".join(raeume_mit_loot)
            if raeume_mit_loot
            else "(keine)"
        )

        print("Räume mit Loot:", text)
        return None

    if verb == "geh":
        if not argument:
            raise UngueltigerBefehlError(
                "In welche Richtung möchtest Du gehen?"
            )

        return raum.ziel(argument)

    if not argument:
        try:
            return raum.ausgaenge[verb]
        except KeyError:
            pass

    raise UngueltigerBefehlError(
        f"Den Befehl '{verb}' verstehe ich nicht."
    )


def main():
    """Startet den Dungeon und führt den Game-Loop aus."""
    raeume = erstelle_raeume()

    print("Du stehst vor dem rostigen Tor eines vergessenen Verlieses.")
    print("Ein kalter Luftzug weht Dir entgegen.")

    name = frage_name("Wie heißt Du, Abenteurer? ")
    gold = frage_ganzzahl(
        "Wie viele Goldmünzen bringst Du mit? ",
        minimum=0,
    )

    spieler = Spieler(
        name=name,
        max_hp=100,
        gold=gold,
    )

    ort = "halle"
    besuchte_raeume = set()
    raum_anzeigen = True

    print()
    print(f"Willkommen, {spieler.name}!")
    print(
        "Befehle: umsehen, nimm <Gegenstand>, inventar, status, "
        "loot, speichern, laden, geh <Richtung>, ende"
    )

    while True:
        raum = raeume[ort]

        if raum_anzeigen:
            besuchte_raeume.add(ort)
            raum.beschreibe()
            raum_anzeigen = False

        eingabe = input("\n> ")

        try:
            verb, argument = teile_befehl(eingabe)

            if verb == "ende":
                print("Du verlässt das Verlies. Bis zum nächsten Mal.")
                break

            if verb == "speichern":
                speichere_spielstand(
                    spieler=spieler,
                    ort=ort,
                    raeume=raeume,
                    besuchte_raeume=besuchte_raeume,
                )
                print("Spielstand gespeichert.")
                continue

            if verb == "laden":
                (
                    spieler,
                    ort,
                    raeume,
                    besuchte_raeume,
                ) = lade_spielstand()

                raum_anzeigen = True
                print("Spielstand geladen.")
                continue

            neuer_ort = verarbeite_befehl(
                verb=verb,
                argument=argument,
                spieler=spieler,
                raum=raum,
                raeume=raeume,
                besuchte_raeume=besuchte_raeume,
            )
        except DungeonError as fehler:
            print(fehler)
        else:
            if neuer_ort is not None:
                ort = neuer_ort
                raum_anzeigen = True


if __name__ == "__main__":
    main()

python dungeon.py

Du stehst vor dem rostigen Tor eines vergessenen Verlieses.
Ein kalter Luftzug weht Dir entgegen.
Wie heißt Du, Abenteurer? Karl
Wie viele Goldmünzen bringst Du mit? 50

Willkommen, Karl!
Befehle: umsehen, nimm <Gegenstand>, inventar, status, loot, speichern, laden, geh <Richtung>, ende

Ort: Halle
Du stehst in einer dunklen Halle mit moderigem Geruch.
Ausgänge:
  1) norden
  2) osten
Hier liegt: Fackel

> nimm fackel
Du nimmst Fackel.
Eine rußige, aber noch brauchbare Fackel.

> speichern
Spielstand gespeichert.

> norden

Ort: Bibliothek
Staubige Regale voller zerfledderter Bücher umgeben Dich.
Ausgänge:
  1) sueden
Hier liegt: Schlüssel

> laden
Spielstand geladen.

Ort: Halle
Du stehst in einer dunklen Halle mit moderigem Geruch.
Ausgänge:
  1) norden
  2) osten

> inventar
Inventar:
  1) Fackel

> ende
Du verlässt das Verlies. Bis zum nächsten Mal.

{
  "version": 1,
  "ort": "halle",
  "besuchte_raeume": [
    "halle"
  ],
  "spieler": {
    "name": "Karl",
    "hp": 100,
    "max_hp": 100,
    "gold": 50,
    "inventar": [
      "fackel"
    ]
  },
  "raeume": {
    "halle": {
      "gegenstaende": []
    },
    "bibliothek": {
      "gegenstaende": [
        "schluessel"
      ]
    },
    "krypta": {
      "gegenstaende": []
    }
  }
}

if verb == "speichern":
    speichere_spielstand(
        spieler=spieler,
        ort=ort,
        raeume=raeume,
        besuchte_raeume=besuchte_raeume,
    )
    print("Spielstand gespeichert.")
    continue

(
    spieler,
    ort,
    raeume,
    besuchte_raeume,
) = lade_spielstand()

raum_anzeigen = True

class SpielstandError(DungeonError):
    """Der Spielstand kann nicht gespeichert oder geladen werden."""

except DungeonError as fehler:
    print(fehler)

Kein Spielstand gefunden.

if pfad.exists():
    print("Die Datei existiert.")

if not SPEICHERDATEI.exists():
    raise SpielstandError("Kein Spielstand gefunden.")

with SPEICHERDATEI.open(encoding="utf-8") as datei:
    ...

try:
    with SPEICHERDATEI.open(encoding="utf-8") as datei:
        daten = json.load(datei)
except FileNotFoundError:
    raise SpielstandError(
        "Kein Spielstand gefunden."
    ) from None

except FileNotFoundError:
    ...

except OSError:
    ...

{
  "version": 1,
  "spieler": "Kartoffel"
}

if not isinstance(ort, str) or ort not in raeume:
    raise SpielstandError(
        f"Unbekannter aktueller Raum im Spielstand: {ort!r}"
    )

if not isinstance(hp, int) or not 0 <= hp <= max_hp:
    raise SpielstandError(
        "Die gespeicherten Lebenspunkte sind ungültig."
    )

if (
    not isinstance(raeume_daten, dict)
    or set(raeume_daten) != set(raeume)
):
    raise SpielstandError(
        "Der Spielstand passt nicht zur aktuellen Dungeon-Welt."
    )

rekonstruiere_spielstand(daten)

raeume = erstelle_raeume()

return spieler, ort, raeume, besuchte_raeume

with SPEICHERDATEI.open("w", encoding="utf-8") as datei:
    json.dump(daten, datei, ensure_ascii=False, indent=2)

temp_datei = SPEICHERDATEI.with_suffix(".tmp")

with temp_datei.open("w", encoding="utf-8") as datei:
    json.dump(
        daten,
        datei,
        ensure_ascii=False,
        indent=2,
    )
    datei.write("\n")

temp_datei.replace(SPEICHERDATEI)