dungeoncoder 0.2.0__py3-none-any.whl

dungeoncoder/testing.py

@@ -0,0 +1,63 @@
+"""Helpers for testing Dungeon Coder programs with pytest, in the simulator.
+
+    from dungeoncoder.testing import spiel
+
+    def test_umdrehen_zweimal_ist_wie_vorher():
+        game, hero = spiel(\"\"\"
+            start: east
+            ---
+            #####
+            #H..#
+            #####
+        \"\"\")
+        umdrehen(hero)
+        umdrehen(hero)
+        assert not hero.is_facing_north() and hero.move()
+
+spiel(...) switches to the simulator (no VS Code needed, steps take no time) and
+loads a level: a map text (see asciimap.py), a .txt map file, or a .json level.
+"""
+import os
+import tempfile
+import textwrap
+
+from . import dungeoncoder as _core
+from .asciimap import GRID_H, GRID_W, parse_text
+from .dungeoncoder import Game, Hero
+
+_versatz = (0, 0)       # where the last map text was placed on the 30x20 field
+
+
+def spiel(level: str) -> tuple[Game, Hero]:
+    """(game, hero) for a level in the simulator. `level` is a map text or a file path."""
+    if _core._simulator is None:
+        _core.use_simulator()
+    if "\n" in level:
+        path = os.path.join(tempfile.mkdtemp(prefix="dungeoncoder-test-"), "level.txt")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(textwrap.dedent(level).strip("\n") + "\n")
+    else:
+        path = level
+    global _versatz
+    if path.endswith(".txt"):
+        with open(path, encoding="utf-8") as f:
+            _, rows = parse_text(f.read())
+        _versatz = ((GRID_W - max((len(r) for r in rows), default=0)) // 2, (GRID_H - len(rows)) // 2)
+    else:
+        _versatz = (0, 0)
+    game = Game(path)
+    return game, game.get_hero()
+
+
+def wachen() -> list[tuple[int, int]]:
+    """Nur für Tests im Simulator: wo die Wächter gerade stehen, (x, y) in den Koordinaten
+    der Karte, wie sie geschrieben ist. Im echten Spiel gibt es das nicht: dort sieht die
+    Heldin einen Wächter nur mit is_enemy_in_front()."""
+    if _core._simulator is None or _core._simulator.level is None:
+        raise RuntimeError("wachen() gibt es nur im Simulator, nach spiel(...)")
+    level = _core._simulator.level
+    ox, oy = _versatz
+    return [(c - ox, r - oy) for c, r in (level.cell_of(o) for o in level.objects if o.kind == "Guard")]
+
+
+game_for = spiel     # English name

dungeoncoder/trace.py

@@ -0,0 +1,92 @@
+"""Traces: every call a program made, with what came back, per loaded level.
+
+    game.save_trace("spur.json")                   # in a program: the current level so far
+    DUNGEONCODER_TRACE=spur.json python prog.py    # every level the program loads, written at the end
+
+A trace holds the level itself (also a generated level or a variant) and the calls in
+order, so it can be replayed exactly: `python -m dungeoncoder replay spur.json` shows it
+in the game, `python -m dungeoncoder trace spur.json` lists it with the hero's field after
+every call (computed in the simulator). Positions are not recorded while the program runs:
+the program itself never learns where the hero stands.
+
+Format (JSON):
+    {"format": "dungeoncoder-trace", "version": 1,
+     "runs": [{"level_file": "levels/x.json", "level": {...Tiled JSON...},
+               "calls": [["move", null, true], ["is_switch_in_front", null, false], ...],
+               "statistics": {...}}]}
+"""
+import atexit
+import json
+import os
+import signal
+import sys
+import threading
+
+FORMAT, VERSION = "dungeoncoder-trace", 1
+# calls that only the host/tools make, or that don't belong in a replay
+NOT_RECORDED = ("load_level", "get_version")
+MAX_CALLS = 50_000         # per run: a program in an endless loop still gives a trace of its start
+
+runs = []                  # one entry per loaded level: {"level_file", "level", "calls", "statistics"}
+_level_file = None         # the path the next load_level comes from (set by Game)
+
+
+def loading(path):
+    """Game is about to load the level from `path`."""
+    global _level_file
+    _level_file = path
+
+
+def record(method, params, result):
+    """Called by dungeoncoder._call for every call (cheap: one list append)."""
+    if method == "load_level":
+        if result:
+            runs.append({"level_file": _level_file, "level": params, "calls": []})
+        return
+    if method in NOT_RECORDED or not runs:
+        return
+    if len(runs[-1]["calls"]) >= MAX_CALLS:
+        runs[-1]["truncated"] = True
+        return
+    shown = result.to_dict() if hasattr(result, "to_dict") else result
+    if method == "get_statistics":
+        runs[-1]["statistics"] = shown
+    runs[-1]["calls"].append([method, params, shown])
+
+
+def document(which=None):
+    """The trace as a JSON-ready dict: all runs, or only the run objects in `which`."""
+    chosen = runs if which is None else which
+    return {"format": FORMAT, "version": VERSION, "runs": chosen}
+
+
+def write(path, which=None):
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(document(which), f, ensure_ascii=False)
+
+
+def read(path):
+    """The runs of a trace file; raises ValueError if it isn't one."""
+    with open(path, encoding="utf-8") as f:
+        data = json.load(f)
+    if not isinstance(data, dict) or data.get("format") != FORMAT:
+        raise ValueError(f"{path} is not a Dungeon Coder trace")
+    return data["runs"]
+
+
+def _write_at_exit():
+    path = os.environ.get("DUNGEONCODER_TRACE", "").strip()
+    if path and runs:
+        write(path)
+
+
+atexit.register(_write_at_exit)
+
+
+def _stop(signum, frame):
+    sys.exit(128 + signum)          # runs the atexit hooks, so the trace is written
+
+
+# a stopped program (e.g. `variants` ends one in an endless loop) still writes its trace
+if os.environ.get("DUNGEONCODER_TRACE", "").strip() and threading.current_thread() is threading.main_thread():
+    signal.signal(signal.SIGTERM, _stop)

dungeoncoder/variants.py

@@ -0,0 +1,112 @@
+"""Level variants: one level file, many levels. `Game("schalter.json", seed=17)`.
+
+A level marks what may move: a rectangle object of class `Region` (drawn in Tiled, or
+`region:` in a text map) and objects whose property `region` names it. Loading the level
+with a seed puts those objects on different free fields of their region; the same seed
+always gives the same variant, and the map property `seed` carries it (the game shows it
+on its end screen, so a failure can be reproduced).
+
+    region: s 2,2 17,13          # text map: every switch s lies somewhere in this rectangle
+
+Without a seed the level is loaded as drawn, unless its map property `variants` is
+`random`: then every load is a new variant, and the seed is printed. The environment
+variable DUNGEONCODER_SEED fixes such a random seed from outside (grading, tutors).
+
+The variant is made here, in Python, before the level goes to the game or the simulator,
+so both get exactly the same level.
+"""
+import copy
+import os
+import random
+
+REGION = "Region"
+
+
+def random_seed():
+    """A seed for "random": DUNGEONCODER_SEED if set (grading, reproducing), else a new one."""
+    fixed = os.environ.get("DUNGEONCODER_SEED", "").strip()
+    if fixed.lstrip("-").isdigit():
+        return int(fixed), False
+    return random.SystemRandom().randrange(1, 1_000_000), True
+
+
+def _prop(props, name):
+    return next((p.get("value") for p in props or [] if p.get("name") == name), None)
+
+
+def _set_prop(level, name, type_, value):
+    props = [p for p in level.get("properties", []) or [] if p.get("name") != name]
+    props.append({"name": name, "type": type_, "value": value})
+    level["properties"] = props
+
+
+def has_regions(level):
+    return any(o.get("type") == REGION for layer in level.get("layers", []) for o in layer.get("objects", []) or [])
+
+
+def strip_regions(level):
+    """The level without its Region rectangles (they only describe variants)."""
+    for layer in level.get("layers", []):
+        if "objects" in layer:
+            layer["objects"] = [o for o in layer["objects"] if o.get("type") != REGION]
+    return level
+
+
+def _walkable(level):
+    """A function (col, row) -> walkable by the game's rules, or None if the tile rules aren't
+    available here (then the region is trusted as drawn)."""
+    try:
+        from . import sim
+        rules = sim.Level(strip_regions(copy.deepcopy(level)))
+    except Exception:       # noqa: BLE001 - e.g. a missing asset pack: trust the region
+        return None
+    return rules.walkable
+
+
+def apply(level, seed):
+    """A copy of the level with every object of a region on a field of that region chosen by
+    `seed` (no two on one field, never on a field another object occupies), map property
+    `seed` set. Raises ValueError if a region has fewer free fields than objects."""
+    level = copy.deepcopy(level)
+    tw, th = level.get("tilewidth", 16), level.get("tileheight", 16)
+    objects = [o for layer in level.get("layers", []) for o in layer.get("objects", []) or []]
+    regions = {o.get("name", ""): o for o in objects if o.get("type") == REGION}
+    walkable = _walkable(level)
+    rng = random.Random(seed)
+
+    def cell(o):
+        return int(o["x"] // tw), int((o["y"] - 1) // th)
+
+    movers = {name: [o for o in objects if o.get("type") != REGION and _prop(o.get("properties"), "region") == name]
+              for name in sorted(regions)}
+    moving = {id(o) for group in movers.values() for o in group}
+    taken = {cell(o) for o in objects if o.get("type") != REGION and id(o) not in moving and o.get("gid")}
+    for name, group in movers.items():
+        if not group:
+            continue
+        r = regions[name]
+        c0, r0 = int(r["x"] // tw), int(r["y"] // th)
+        c1, r1 = int((r["x"] + r["width"] - 1) // tw), int((r["y"] + r["height"] - 1) // th)
+        free = [(c, rr) for rr in range(r0, r1 + 1) for c in range(c0, c1 + 1)
+                if (c, rr) not in taken and (walkable is None or walkable(c, rr))]
+        if len(free) < len(group):
+            raise ValueError(f"region {name!r} has {len(free)} free field(s) for {len(group)} object(s)")
+        for o, (c, rr) in zip(group, rng.sample(free, len(group))):
+            o["x"], o["y"] = c * tw, (rr + 1) * th
+            taken.add((c, rr))
+    _set_prop(level, "seed", "int", seed)
+    return strip_regions(level)
+
+
+def prepare(level, seed=None):
+    """(level to load, seed or None, chosen at random?) for Game(path, seed). Levels without
+    regions are returned unchanged (a seed given for them is ignored)."""
+    if not has_regions(level):
+        return level, None, False
+    chosen = False
+    if seed is None and str(_prop(level.get("properties"), "variants") or "").lower() == "random":
+        seed, _ = random_seed()
+        chosen = True
+    if seed is None:
+        return strip_regions(copy.deepcopy(level)), None, False
+    return apply(level, seed), seed, chosen

dungeoncoder-0.2.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: dungeoncoder
+Version: 0.2.0
+Summary: Python API for Dungeon Coder: steer the hero from a script, in VS Code or in the built-in simulator
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Education
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: httpx>=0.27
+Requires-Dist: attrs>=23.1
+Dynamic: license-file
+
+# dungeoncoder
+
+The Python API for Dungeon Coder, a VS Code extension in which a Python script steers a hero through a pixel-art dungeon.
+
+```python
+from dungeoncoder import Game
+
+game = Game("playground.json")
+hero = game.get_hero()
+while not hero.is_at_goal():
+    if hero.is_collision_in_front():
+        hero.turn_left()
+    else:
+        hero.move()
+```
+
+- **With the extension:** start the game in VS Code (`Dungeon Coder: Enter the dungeon`); the script talks to it over a local REST API.
+- **Without VS Code:** `dungeoncoder.use_simulator()` (or `DUNGEONCODER_SIM=1`) runs the same script in a pure-Python simulator of the game's rules: no picture, no waiting. `dungeoncoder.testing.spiel(map_text)` gives `(game, hero)` for pytest.
+- **Levels from text maps:** `Game("karte.txt")`.
+- **Setup check:** `python -m dungeoncoder` says which Python and which copy of the package run, whether the game answers and whether its version fits.
+
+The package has the same version as the extension. Install it with `pip install dungeoncoder`.

dungeoncoder-0.2.0.dist-info/RECORD

@@ -0,0 +1,77 @@
+dungeoncoder/__init__.py,sha256=XrFyz332acwER5Y781xhNsC4izHNQNGxbo0hCTv_mDI,158
+dungeoncoder/__main__.py,sha256=HYiXQM02zWpM75K3wpK5gD3FL85oTV-tPISkT6c8M7E,11331
+dungeoncoder/_api_config.py,sha256=wWI57wQZgDT9fsL5Ljasf9B46Ukr1zD5qsKzcLc1zYI,187
+dungeoncoder/asciimap.py,sha256=IpBHmu9xeto4bhWZczCpcOqqZd0V4mkZ9OKCQ_T9lxo,44901
+dungeoncoder/dungeoncoder.py,sha256=fZ32hKKGmH8DrsiNmrWR4WAd0YF-huu2PZr_fUFkI8E,23167
+dungeoncoder/generator.py,sha256=dmkW2C7-fIe2LmnaZzuYwB6THS5HTqBluW5t1C4asnQ,9427
+dungeoncoder/replay.py,sha256=3nQEtXG19x2ZIK1jWgEWbvguNcEXOMNStquXMeSzKlE,3304
+dungeoncoder/requirements.txt,sha256=F-GNwkLSOnRQ1ebP-ZUs2th-4HRn-7j-N_xkDLCn2to,24
+dungeoncoder/sim.py,sha256=OOgKDJh5ak9LzIqnXV_HYaMVHTuQPa89yIdFrCpLym4,35924
+dungeoncoder/testing.py,sha256=CiYsJLKKoU3GBU0bbxolkQkqFe8QZ3lEoFgbwuEFlgo,2252
+dungeoncoder/trace.py,sha256=xE-CewFpmSq2aDCHtT5Lh74AMjmUbGV4eCAC7C1HxnE,3426
+dungeoncoder/variants.py,sha256=3dhyBgmuurwIFG1VAZkzRrxYdRldbiQ_8sjKb8K-iis,4896
+dungeoncoder/_generated/__init__.py,sha256=HIZSbxk1_1Zg9M8NfwBlcYFM1vI7OQsIoQ3a_MLDE1c,162
+dungeoncoder/_generated/client.py,sha256=GDzw6T2uRmPlUb1DImpBGxwy0dNbhmBknfvvIQW0GuU,12387
+dungeoncoder/_generated/errors.py,sha256=trp-p5qn1_JLRxGZhdHtICaNPaCrcDCe4TgIihBravk,546
+dungeoncoder/_generated/types.py,sha256=k9-ddYg6Tq-sd90hvGkH8-9hLj94QeCGVmGNz2xM5JQ,1350
+dungeoncoder/_generated/api/__init__.py,sha256=87ApBzKyGb5zsgTMOkQXDqsLZCmaSFoJMwbGzCDQZMw,47
+dungeoncoder/_generated/api/game/__init__.py,sha256=wYN6A3_bvYW13B1J9YvYCmcv5Els-q-E07kZJwJ7Vto,58
+dungeoncoder/_generated/api/game/get_statistics.py,sha256=xf3zg-Cmv1-vc6s6pGUeqUrjOMwBNZLG3J-dR1HQqOo,3998
+dungeoncoder/_generated/api/game/get_version.py,sha256=qFQ9_6E5fq0krHDr_Zr_tsx6g2wGT4MSjhfmJu7g6Ck,4388
+dungeoncoder/_generated/api/hero/__init__.py,sha256=wYN6A3_bvYW13B1J9YvYCmcv5Els-q-E07kZJwJ7Vto,58
+dungeoncoder/_generated/api/hero/ask_oracle.py,sha256=2vF_NNscEi8AY1dLpjOhwRKCD56ts03ToXH-bWEh_yY,5009
+dungeoncoder/_generated/api/hero/configure.py,sha256=TTusVxlNCF0gVUQli1L-7A8uU-VPKdxfvzF9Vyy7a6U,4880
+dungeoncoder/_generated/api/hero/drop.py,sha256=9Uzizy5b-vAMdkw4YrtDYLElfG15pbdOQH0Puey7u_c,4805
+dungeoncoder/_generated/api/hero/get_inventory.py,sha256=AY4jlFaEBY-x9qnNfXL7LprHAoLhyoNB76IgVuBds2U,4433
+dungeoncoder/_generated/api/hero/get_items_at_position.py,sha256=sN_xsXLQcZ-y2UTRGtwlDBbiZVn8beOmJPqiF5n9voY,4433
+dungeoncoder/_generated/api/hero/interact.py,sha256=fLZnyDjwzengqjbFwdvsPp4T3JAboSwCEWE95tcHeUk,4484
+dungeoncoder/_generated/api/hero/is_abyss_in_front.py,sha256=aoc7FLrR2LK4h4e55KnW1mmR3f8Yfdv75cccFFfRZM0,4432
+dungeoncoder/_generated/api/hero/is_at_goal.py,sha256=k6JwNK8ujRc6f92RL2NoerDSF7HzeAh3KwgjxhPEQZc,4669
+dungeoncoder/_generated/api/hero/is_collision_in_front.py,sha256=4DSrSFRm_f4F0xfNvKw4z6mhxY_vk5kWrFztrd_jiNE,4440
+dungeoncoder/_generated/api/hero/is_enemy_in_front.py,sha256=bH2fN45-8wVqoYSUGQYz86bvaCzNOpRXPhq3rj20JkQ,4412
+dungeoncoder/_generated/api/hero/is_facing_north.py,sha256=YVGZs_4c7c3O7aXfZC_y3lsCGM0xdkFKKZ9-skWvOmE,4342
+dungeoncoder/_generated/api/hero/is_switch_in_front.py,sha256=5hkQVGMfJE-hwBimmZMMmV68G5FAAaYCXeYAIbmI4XQ,4401
+dungeoncoder/_generated/api/hero/is_torch_in_front.py,sha256=cT-1XHDlMxRgEUyAOC39aayKB650sP3pTHDb35rMQMA,4396
+dungeoncoder/_generated/api/hero/move.py,sha256=XMol15DR6Lbxqui1YK7tVPrpghxk64eyI0NcZeVks8k,4300
+dungeoncoder/_generated/api/hero/peek_item_value.py,sha256=Ml8mizVE7na7fMEd6tyhEMrm6JXbhvZRQAb-6qiryJE,5297
+dungeoncoder/_generated/api/hero/pickup.py,sha256=VLDn2qD0iK2YY4Q1wzDEgEwV1QUoB1UTXiQBrXU2CbM,4839
+dungeoncoder/_generated/api/hero/read_item_value.py,sha256=ockVa8TCfc3NHTIxVUfwi5T3DKWmXku-QFJirrZ79AA,4639
+dungeoncoder/_generated/api/hero/sense_goal.py,sha256=eGmulE3qaGxrLwXua5M9urmVTceM2gTr52LM5uagXeg,4850
+dungeoncoder/_generated/api/hero/set_pace.py,sha256=6YZosGxLyzfPyOTT0F3G11Q_5sMmeCZhNRnvwGCljA4,4820
+dungeoncoder/_generated/api/hero/turn_left.py,sha256=AP7tYD-lyyHsVV969PJoQRJzt6jvAV5mVebCihToMoU,4329
+dungeoncoder/_generated/api/level/__init__.py,sha256=wYN6A3_bvYW13B1J9YvYCmcv5Els-q-E07kZJwJ7Vto,58
+dungeoncoder/_generated/api/level/load_level.py,sha256=1iVkkyXHZNbjjOMwIJ42yESplmPoMK51INzpectpn3U,4902
+dungeoncoder/_generated/api/level/reset_level.py,sha256=Id6Vcsl1Wavj7lYWeSE82AKg0mBKbnk4JUZnpo3oOro,3824
+dungeoncoder/_generated/models/__init__.py,sha256=c4f_16DlsbV6LRjLHFHGLehO_bTheQFs53DuzgLO8Qg,1675
+dungeoncoder/_generated/models/api_error_response.py,sha256=2nXlvesqNRP-2VGzVUfWEe-XyU20PvlbrS2x0AX4QXQ,2212
+dungeoncoder/_generated/models/api_error_response_status.py,sha256=oTCGPrkFh-gFE_hm12L8qZ2GL88N3A4S7rwMV75UkGw,146
+dungeoncoder/_generated/models/boolean_result.py,sha256=eKwEKhKC7QtfuNTy8Mn6859GKHl_2hojy4Htno0Nukw,2039
+dungeoncoder/_generated/models/boolean_result_status.py,sha256=4NOZA9jv11OspDKT2Ve_x3yusew6ulZFtssf2FdiFs4,147
+dungeoncoder/_generated/models/configure_params.py,sha256=Lu13I-dBox_S2VW9eUGVj8coknictO5JUZ7kVw7TmtA,1845
+dungeoncoder/_generated/models/distance_param.py,sha256=sBwka39M4n6JgHdsnAXGHXauUGiPGtyZIS7rClXUiB8,1677
+dungeoncoder/_generated/models/name_param.py,sha256=HUKqlv7F5QMnUbnIz3PJx3Ut8oFRRBJ-fISHlAfBzm4,1599
+dungeoncoder/_generated/models/nullable_integer_result.py,sha256=F_6lO01BDRuw4CJQjdflgrTM8VKmUqc0lK54C9ixKNg,2357
+dungeoncoder/_generated/models/nullable_integer_result_status.py,sha256=HJ3Ja0c2Eh9vUZ-wiXOcgTYsnbRcmm-nr2BHAW3bszU,155
+dungeoncoder/_generated/models/nullable_string_result.py,sha256=RKbXYPKIcXiSJk7y5EhidHKO8pmvpZ1N1Yx4Zt8TXF8,2347
+dungeoncoder/_generated/models/nullable_string_result_status.py,sha256=2LBvP2NtWwYNVeTC-6gN_Y5KPG9_fxeuyl_c3q9XZrQ,154
+dungeoncoder/_generated/models/pace_params.py,sha256=gLoWR0ripIbFNb0HrZo2wISspoUnkS3Kgp-U_zzXv2U,1618
+dungeoncoder/_generated/models/statistics.py,sha256=l_cq5x-I30JY0xEgHgQ-IBCB03kIpjXEPYOnTFDEbrc,5718
+dungeoncoder/_generated/models/statistics_result.py,sha256=u0fTcIDmZ75qIVePbsDjWJW9nuZBZH92_SpXWygBrtA,2346
+dungeoncoder/_generated/models/statistics_result_status.py,sha256=HjJ92u3UfD1Oz4KDE_x-JA5_TtfOrNHXGrPHrLae9tw,150
+dungeoncoder/_generated/models/string_array_result.py,sha256=j2IcdEamX8buigvKH5_9_If6ZbVk-GyImnqkNQ6TOqA,2137
+dungeoncoder/_generated/models/string_array_result_status.py,sha256=H1mw62iwwZIgVElO3hI9d9nmGFOUTk5ZLVON_5UE9GE,151
+dungeoncoder/_generated/models/tiled_level.py,sha256=IKVBujaSycyKteryR1BMoCStKAUWoeYe0HEbFpgZ6Hw,1496
+dungeoncoder/_generated/models/version_result.py,sha256=lPLIS4bjzd7u-CxAuhCO1hdDCLt_6cGiBbNw2zpl_U0,2362
+dungeoncoder/_generated/models/version_result_result.py,sha256=uzwIJdobBpNAJOOt7tXjUvwJuojGNzo91TR2WWk_HLk,1871
+dungeoncoder/_generated/models/version_result_status.py,sha256=slTpNJowot9-yOXffNiV4mGptdobN3B85EWyZr33cMs,147
+dungeoncoder/packs/gelaende.json,sha256=Q8NzzL6rVhA2Bymzd6tWa9zVv6h41e9rrcRXiauUvg4,8021
+dungeoncoder/packs/items.json,sha256=ZcuYBLo8larn3JH2qJ4E0nkfKtryntelnJx6lk4b8cU,1554
+dungeoncoder/packs/station.json,sha256=ItoPil_83LprELwygrDU9vMHGhKDlceaLK2n3VqpPwA,7918
+dungeoncoder/packs/studio.json,sha256=-KqKBgTT5DnaJcco1789cZHI5rJINQ0NT3VxAFaOuAg,7854
+dungeoncoder/packs/tilesets.json,sha256=vVHjE_dOBEalXKLoIu3FRDaTT8UiXe0hzrH37sIgkr8,54226
+dungeoncoder/packs/werkstatt.json,sha256=DbPvym5jwiZokBDn7U79zps5jHMAtD0bKvr88sdwczk,8091
+dungeoncoder-0.2.0.dist-info/licenses/LICENSE.txt,sha256=6Hbha-oiKVwW83FDLzR4iCqHHYsM2aPrxXCHWGw60P4,1178
+dungeoncoder-0.2.0.dist-info/METADATA,sha256=opqoq7XqdogE2_4IDIN4emVhxdDf9jkFosagmbU7ePE,1517
+dungeoncoder-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+dungeoncoder-0.2.0.dist-info/top_level.txt,sha256=LyJOZeLnQba_mjU-xD0fXxLBj343jnnUwhOeaOEVyPc,13
+dungeoncoder-0.2.0.dist-info/RECORD,,

dungeoncoder-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dungeoncoder-0.2.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) Microsoft Corporation
+Copyright (c) Munich University of Applied Sciences
+Copyright (c) Benedikt Dietrich
+
+All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dungeoncoder-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dungeoncoder