# Schritt 14 — Tavern Art Pass

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** `taproom.tscn` (Gastraum EG, geteilt von Lobby + In-Game-Taverne) und die Obergeschoss-Zimmer in `tavern.tscn` bekommen echte 3D-Props statt Placeholder-Geometrie. Quellen: Polyhaven (CC0, kostenlos) via `blender-mcp`, optional Hyper3D/Meshy für fehlende Assets.

**Architecture:** Assets via Blender-MCP downloaden/generieren → Skala normalisieren → als `.glb` nach `ruf-der-pilze/assets/props/` exportieren → via Godot-Editor in Szenen platzieren. `taproom.tscn` hat kein Script — Props als reine MeshInstance3D-Nodes einfügen. Keine Logic-Änderungen an Scripts.

**Tech Stack:** Godot 4.x, Blender (blender-mcp MCP-Server), Polyhaven (CC0 Models), godot-mcp Screenshot-Loop

**Asset-Liste:**

| Asset | Anzahl | Szene | Polyhaven-Suche |
|-------|--------|-------|-----------------|
| Holztisch | 4–5 | taproom | `"wooden table"` / `"pub table"` |
| Holzstuhl/Hocker | 8–12 | taproom | `"wooden chair"` / `"stool"` |
| Bar-Counter/Tresen | 1 | taproom | `"bar counter"` (evtl. Hyper3D) |
| Fässer (Barrel) | 3–5 | taproom | `"barrel"` / `"wooden barrel"` |
| Kerzenhalter | 4–6 | taproom | `"candle"` / `"candlestick"` |
| Bett (einfach) | 1 Template | tavern OG | `"bed"` / `"medieval bed"` |
| Kleiner Tisch | 1 Template | tavern OG | (Wiederverwendung Tisch) |

---

## Files

| File | Aktion |
|------|--------|
| `ruf-der-pilze/assets/props/` | Verzeichnis anlegen, .glb Dateien ablegen |
| `ruf-der-pilze/scenes/taproom.tscn` | Modify — Props platzieren (Tische, Stühle, Tresen, Fässer, Kerzen) |
| `ruf-der-pilze/scenes/tavern.tscn` | Modify — Zimmer-Props (Bett, Tisch, Stuhl, Kerze) |
| `docs/STATUS.md` | Modify — Schritt 14 ✅ |

---

## Task 1: Assets via Polyhaven-MCP suchen und downloaden

**Vorbedingung:** Blender muss offen sein und der blender-mcp-Server muss laufen.

- [ ] **Schritt 1: Polyhaven-Kategorien abrufen**

  ```
  Tool: mcp__blender__get_polyhaven_categories
  ```

  Kategorien für Models notieren (sollte "models" o.ä. enthalten).

- [ ] **Schritt 2: Tisch-Assets suchen**

  ```
  Tool: mcp__blender__search_polyhaven_assets
  Params: type="models", query="wooden table"
  ```

  Und:
  ```
  Tool: mcp__blender__search_polyhaven_assets
  Params: type="models", query="pub table"
  ```

  Passenden Asset-ID notieren (z.B. `pub_table`, `round_wooden_table`).

- [ ] **Schritt 3: Stuhl/Hocker-Assets suchen**

  ```
  Tool: mcp__blender__search_polyhaven_assets
  Params: type="models", query="wooden stool"
  ```

- [ ] **Schritt 4: Fass-Assets suchen**

  ```
  Tool: mcp__blender__search_polyhaven_assets
  Params: type="models", query="barrel"
  ```

- [ ] **Schritt 5: Kerzen-Assets suchen**

  ```
  Tool: mcp__blender__search_polyhaven_assets
  Params: type="models", query="candle"
  ```

- [ ] **Schritt 6: Bett-Assets suchen**

  ```
  Tool: mcp__blender__search_polyhaven_assets
  Params: type="models", query="bed"
  ```

- [ ] **Schritt 7: Gefundene Assets herunterladen (nacheinander)**

  Für jeden Asset:
  ```
  Tool: mcp__blender__download_polyhaven_asset
  Params: asset_id="<id>", asset_type="models", resolution="1k"
  ```

  Status pollen:
  ```
  Tool: mcp__blender__get_polyhaven_status
  ```

  Warten bis `status = "completed"`.

- [ ] **Schritt 8: Falls Bar-Counter nicht auf Polyhaven: Hyper3D nutzen**

  ```
  Tool: mcp__blender__generate_hyper3d_model_via_text
  Params: prompt="medieval tavern bar counter, dark wood, worn surface, low poly game asset, simple geometry"
  ```

  Status pollen:
  ```
  Tool: mcp__blender__get_hyper3d_status
  ```

  Asset importieren:
  ```
  Tool: mcp__blender__import_generated_asset
  ```

---

## Task 2: Assets in Blender normalisieren und als .glb exportieren

- [ ] **Schritt 1: Blender-Szene prüfen**

  ```
  Tool: mcp__blender__get_scene_info
  Tool: mcp__blender__get_viewport_screenshot
  ```

  Alle heruntergeladenen Assets sollten in der Szene sichtbar sein.

- [ ] **Schritt 2: Assets-Verzeichnis anlegen**

  ```bash
  mkdir -p /home/mpuchstein/Dev/Godot/DnD_Anna_OneShot/ruf-der-pilze/assets/props
  ```

- [ ] **Schritt 3: Skala prüfen und normalisieren**

  Referenz-Maße für mittelalterliche Taverne:
  - Tisch: ca. 0.75m hoch, 1.2m × 0.8m Fläche
  - Stuhl/Hocker: ca. 0.45m hoch
  - Barrel: ca. 0.8m hoch
  - Kerzenhalter: ca. 0.3m hoch
  - Bett: ca. 0.5m hoch, 2.0m × 1.0m

  Skala per Blender-Code anpassen (für jeden Asset einzeln ausführen):

  ```python
  # Beispiel: Tisch auf 0.75m Höhe skalieren
  import bpy
  obj = bpy.data.objects["<asset_object_name>"]  # Namen aus get_scene_info
  dims = obj.dimensions
  if dims.z > 0:
      scale_factor = 0.75 / dims.z
      obj.scale = (scale_factor, scale_factor, scale_factor)
      bpy.ops.object.select_all(action='DESELECT')
      obj.select_set(True)
      bpy.context.view_layer.objects.active = obj
      bpy.ops.object.transform_apply(scale=True)
  ```

  ```
  Tool: mcp__blender__execute_blender_code
  Params: code="<python_code>"
  ```

- [ ] **Schritt 4: Assets einzeln als .glb exportieren**

  Für jeden Asset (Objekt selektieren, dann exportieren):

  ```python
  import bpy
  bpy.ops.object.select_all(action='DESELECT')
  bpy.data.objects["<object_name>"].select_set(True)
  bpy.ops.export_scene.gltf(
      filepath="/home/mpuchstein/Dev/Godot/DnD_Anna_OneShot/ruf-der-pilze/assets/props/table.glb",
      export_format='GLB',
      use_selection=True,
      export_materials='EXPORT'
  )
  ```

  Zieldateien:
  - `assets/props/table.glb`
  - `assets/props/chair.glb`
  - `assets/props/barrel.glb`
  - `assets/props/candle.glb`
  - `assets/props/bed.glb`
  - `assets/props/bar_counter.glb`

- [ ] **Schritt 5: Commit**

  ```bash
  git add ruf-der-pilze/assets/props/
  git commit -m "assets: import tavern props — table, chair, barrel, candle, bed, bar_counter"
  ```

---

## Task 3: taproom.tscn mit Props bestücken

**Files:** Modify `ruf-der-pilze/scenes/taproom.tscn`

`taproom.tscn` ist die Gastraum-Geometrie ohne Script. Hier werden Props als Kinder-Nodes eingefügt. Die Props werden als instanziierte .glb-Szenen oder MeshInstance3D-Nodes platziert.

- [ ] **Schritt 1: Aktuellen Stand per Screenshot prüfen**

  In Godot: `taproom.tscn` öffnen. Godot-MCP Screenshot machen um die Raumgröße und Geometry zu sehen:
  ```
  Tool: mcp__godot-mcp__scene
  Params: action="get_node_properties", scene_path="res://scenes/taproom.tscn", node_path="."
  ```

- [ ] **Schritt 2: Bar-Counter an Wand platzieren**

  Im Godot-Editor: `bar_counter.glb` (aus `assets/props/`) per Drag & Drop in `taproom.tscn` ziehen, oder Node3D hinzufügen und Mesh zuweisen. Position entlang einer Wand:
  - Ungefähre Position: `Vector3(-4.0, 0.0, 0.0)` — an der linken Wand
  - Rotation anpassen damit Counter zur Mitte zeigt

- [ ] **Schritt 3: 4 Tische im Raum verteilen**

  Vier Tisch-Nodes platzieren, gleichmäßig verteilt:
  ```
  Tisch 1: Vector3(-1.5, 0.0, -2.0)
  Tisch 2: Vector3( 1.5, 0.0, -2.0)
  Tisch 3: Vector3(-1.5, 0.0,  1.0)
  Tisch 4: Vector3( 1.5, 0.0,  1.0)
  ```

- [ ] **Schritt 4: Stühle/Hocker um jeden Tisch**

  Je 2–4 Stühle um jeden Tisch. Versatz vom Tisch-Zentrum: ca. 0.7m in jede Richtung.

- [ ] **Schritt 5: 3–4 Fässer nahe Tresen**

  Fässer geclustert nahe dem Bar-Counter. Position: entlang der Tresen-Wand.

- [ ] **Schritt 6: Kerzenhalter auf Tischen + Wandbefestigung**

  Je 1 Kerzenhalter auf jedem Tisch (Y-Position = Tischhöhe ~0.75). 2 Kerzenhalter an Wänden.

- [ ] **Schritt 7: Screenshot via godot-mcp, Iterationen bis es gut aussieht**

  Mindestens 2–3 Korrekturrunden. Ziel: bewohnter, atmosphärischer Gastraum.

- [ ] **Schritt 8: Commit**

  ```bash
  git add ruf-der-pilze/scenes/taproom.tscn
  git commit -m "art: taproom props — tables, chairs, bar counter, barrels, candles"
  ```

---

## Task 4: Zimmer in tavern.tscn bestücken

**Files:** Modify `ruf-der-pilze/scenes/tavern.tscn`

Die Taverne hat 9 Zimmer im OG (SpawnPoint0–SpawnPoint8). Zuerst **Zimmer 1 (SpawnPoint0)** vollständig einrichten, dann das Muster für alle weiteren Zimmer wiederholen.

- [ ] **Schritt 1: tavern.tscn öffnen und SpawnPoint0-Zimmer lokalisieren**

  Godot-Editor: `tavern.tscn` öffnen. Im Scene-Panel die SpawnPoint0-Node finden und deren Position notieren.

- [ ] **Schritt 2: Zimmer 1 mit Props bestücken**

  Props relativ zu SpawnPoint0-Position (Offsets anpassen nach Zimmergeometrie):
  - **Bett:** SpawnPoint.position + Vector3(1.2, 0.0, 0.5), an Wand
  - **Kleiner Tisch:** SpawnPoint.position + Vector3(-1.0, 0.0, -0.8)
  - **Stuhl:** neben Tisch, Offset ~0.5m
  - **Kerzenhalter:** auf Tisch, Y = Tischhöhe

- [ ] **Schritt 3: Screenshot prüfen**

  Godot-Editor Viewport oder godot-mcp Screenshot für Zimmer 1.

- [ ] **Schritt 4: Zimmer 2–9 analog bestücken**

  Für SpawnPoint1–SpawnPoint8 dieselben Props einfügen. Positionen relativ zum jeweiligen SpawnPoint.

- [ ] **Schritt 5: Commit**

  ```bash
  git add ruf-der-pilze/scenes/tavern.tscn
  git commit -m "art: tavern OG rooms — bed, table, chair, candle per room (9 rooms)"
  ```

---

## Task 5: Gesamt-Test + STATUS.md

- [ ] **Schritt 1: Spiel starten und Taverne visuell prüfen**

  Server + 2 Clients starten (oder Godot-Editor ausführen):
  - `tavern_lobby.tscn`: Gastraum sieht bewohnt aus
  - `tavern.tscn` nach game_started: EG-Gastraum mit Props, OG-Zimmer mit Bett/Tisch/Kerze
  - Performance: FPS sollte bei >30 bleiben (Godot-Editor Statistiken)

- [ ] **Schritt 2: Schritt 14 als ✅ markieren**

  In `docs/STATUS.md` und `ruf-der-pilze/CLAUDE.md`.

- [ ] **Schritt 3: Commit**

  ```bash
  git add docs/STATUS.md ruf-der-pilze/CLAUDE.md
  git commit -m "docs: mark Schritt 14 complete — Tavern Art Pass"
  ```
