# Prozeduraler Dungeon Generator – Komplette Neuanleitung v4.2

## Überblick

Snap-Together Dungeon Generator für Unreal Engine 5.7 mit Blueprints.
Vorgefertigte Räume docken an Arrow-Component-Sockets aneinander an.
5–100 Level pro Dungeon, Hauptpfad + optionale Abzweigungen (Branches).

**Ablauf:** Generate Dungeon → Level für Level bauen (Entrance/PortalIn → MainPath → PortalOut/Exit) → nach Exit: Branches auf allen Leveln bauen → offene Sockets versiegeln → Spieler platzieren → Fertig.

### Änderungen gegenüber v4 (final)

1. **Runtime-State zentral im Generator** – unverändert übernommen.
2. **Stabile Socket-IDs** – unverändert übernommen.
3. **LevelVerticalOffset als Variable** – unverändert übernommen.
4. **NEU: Detaillierte Update-Logik für AllTrackedSockets** – Jede Stelle, an der ein Socket-State geändert wird, hat jetzt eine Schritt-für-Schritt Anleitung mit Find-by-Predicate + Set Array Elem.
5. **NEU: BranchFrontier-Kopie** – BuildBranches iteriert über eine Kopie, nicht das Original, um Array-Mutation während Iteration zu vermeiden.
6. **NEU: Socket-Auswahl beim Startraum** – Konkrete Logik, welcher Socket auf MainPath geht.
7. **NEU: Retry-Logik komplett definiert** – RetryLevel als eigenes Custom Event.
8. **NEU: FindCompatibleRoom Socket-Matching** – Konkrete Kriterien für "nutzbarer Eingangs-Socket".
9. **NEU: RegisterRoomSockets ohne TargetArray-Parameter** – Arbeitet direkt auf den Generator-Variablen.
10. **NEU: SnapRoomToSocket 180°-Rotation erklärt** – Warum Combine Rotators mit 180° nötig ist.

### Bewusst nicht übernommene Vorschläge

| Vorschlag | Entscheidung | Begründung |
|---|---|---|
| BP_DungeonRoomBase als gemeinsame Elternklasse | Nicht übernommen | UE erlaubt keine Viewport-Änderungen in Child Blueprints. Wir nutzen eigenständige Duplikate + Interface, was flexibler ist für unterschiedliche Raum-Geometrien. |
| Kollision vor Spawn prüfen (CanPlaceRoom) | Nicht übernommen (vorerst) | Spawn-then-Destroy funktioniert für den Prototyp. Optimierung auf Box Trace kommt später wenn die Grundlogik steht. |
| Branches während des MainPath-Baus | Nicht übernommen | Branches nach dem Exit über alle Level ist einfacher zu implementieren und zu debuggen. |
| Erweiterte Data Table (Tags, FootprintExtent, CanBeMainPath etc.) | Nicht übernommen (vorerst) | Die einfache Data Table reicht für den Prototyp. |
| FindCompatibleRoom mit Score-System | Nicht übernommen (vorerst) | Gewichtete Zufallswahl reicht erstmal. |
| E_SocketType (Standard, Large, Stair, Portal) | Nicht übernommen (vorerst) | Alle Räume haben aktuell die gleiche Durchgangsgröße. |
| SealOpenSockets als eigener Schritt | Übernommen | DeadEnds schließen Branches ab. Übrige offene Sockets werden mit WallBlockern verschlossen. |

---

## Teil 1: Datenstrukturen

### 1.1 Enums

**E_RoomType** (existiert bereits, ggf. erweitern):
- Entrance, General, Corridor, PortalIn, PortalOut, Exit, DeadEnd

**E_SocketStatus** (existiert bereits):
- Open, Occupied, Closed

**E_PathType** (NEU erstellen):
- MainPath, Branch, None

### 1.2 Structs

#### S_SocketDefinition (NEU – ersetzt das alte S_SocketData in den Räumen)

Beschreibt einen Socket am Raum. Wird im Construction Script befüllt. Enthält **keinen** Laufzeit-Zustand.

| Feld | Typ | Beschreibung |
|---|---|---|
| SocketId | Name | Eindeutiger Name z.B. "Socket_North", "Socket_South" |
| SocketComponent | Arrow Component Ref | Referenz auf die Arrow Component |
| LocalTransform | Transform | Lokale Position/Rotation relativ zum Actor |

#### S_OpenSocketData (NEU – Runtime-State im Generator)

Das ist der wichtigste Struct. Der Generator verwaltet damit alle offenen Verbindungspunkte. Ersetzt das alte S_SocketData für Laufzeit-Zwecke.

| Feld | Typ | Beschreibung |
|---|---|---|
| OwnerRoom | Actor Object Ref | Der Raum dem dieser Socket gehört |
| SocketId | Name | Eindeutige Socket-ID (z.B. "Socket_North") |
| SocketIndex | Integer | Index in der Arrow-Liste (Fallback) |
| PathType | E_PathType | MainPath, Branch oder None |
| LevelIndex | Integer | Auf welchem Level liegt dieser Socket |
| BranchDepth | Integer | Tiefe der Abzweigung (0 = am MainPath) |
| State | E_SocketStatus | Open, Occupied, Closed |

**WICHTIG:** WorldTransform wird NICHT im Struct gespeichert! Die Position wird immer live über GetSocketWorldTransformById berechnet.

#### S_PlacedRoomData (NEU – Raum-Tracking im Generator)

Speichert Informationen über jeden platzierten Raum zentral im Generator.

| Feld | Typ | Beschreibung |
|---|---|---|
| RoomActor | Actor Object Ref | Referenz auf den gespawnten Actor |
| RoomType | E_RoomType | Typ des Raums |
| PathType | E_PathType | MainPath oder Branch |
| LevelIndex | Integer | Auf welchem Level |
| BranchDepth | Integer | Abzweigungstiefe (0 = MainPath) |

#### S_RoomPoolEntry (existiert bereits, unverändert)

| Feld | Typ | Beschreibung |
|---|---|---|
| RoomClass | Actor Class Ref | Blueprint-Klasse des Raums |
| RoomType | E_RoomType | Typ |
| Weight | Float | Gewichtung für Zufallswahl |
| MinLevel | Integer | Ab welchem Level verfügbar |
| MaxLevel | Integer | Bis welchem Level (0 = unbegrenzt) |

#### DT_RoomPool erstellen (Data Table im Editor)

Die Data Table `DT_RoomPool` ist die zentrale Tabelle, aus der der Generator zur Laufzeit Räume auswählt. Sie basiert auf dem Struct `S_RoomPoolEntry`.

**Voraussetzung:** Der Struct `S_RoomPoolEntry` muss bereits existieren (siehe oben).

**Schritt 1 – Data Table Asset anlegen:**

1. Im Content Browser: Rechtsklick → **Miscellaneous** → **Data Table**
2. Im Popup **"Pick Row Structure"**: Wähle **S_RoomPoolEntry** als Row Structure
3. Bestätige mit **OK**
4. Benenne das neue Asset: **DT_RoomPool**
5. Speichere es z.B. unter `Content/Data/DT_RoomPool` (oder einem Ordner deiner Wahl)

**Schritt 2 – Zeilen hinzufügen:**

Öffne DT_RoomPool per Doppelklick. Die Tabelle ist zunächst leer.

1. Klicke oben links auf **Add** (+ Symbol), um eine neue Zeile hinzuzufügen
2. Vergib einen eindeutigen **Row Name** (z.B. "General_01", "Corridor_01", "DeadEnd_01")
3. Befülle die Felder der Zeile:

| Feld | Was eintragen | Hinweis |
|---|---|---|
| RoomClass | Blueprint-Klasse auswählen (z.B. BP_DungeonRoom_General) | Klick auf das Dropdown → Blueprint-Class wählen |
| RoomType | Passenden Enum-Wert wählen (z.B. General) | Muss zum Blueprint passen |
| Weight | Gewichtung als Float (z.B. 1.0) | Höher = häufiger gewählt |
| MinLevel | Ab welchem Level verfügbar (z.B. 1) | 1 = ab dem ersten Level |
| MaxLevel | Bis welchem Level (z.B. 0) | 0 = unbegrenzt / auf allen Levels |

**Schritt 3 – Empfohlene Einträge für den Prototyp:**

| Row Name | RoomClass | RoomType | Weight | MinLevel | MaxLevel |
|---|---|---|---|---|---|
| General_01 | BP_DungeonRoom_General | General | 1.0 | 1 | 0 |
| Corridor_01 | BP_DungeonRoom_Corridor | Corridor | 1.0 | 1 | 0 |
| DeadEnd_01 | BP_DungeonRoom_DeadEnd | DeadEnd | 1.0 | 1 | 0 |

> **Hinweis:** Entrance, PortalIn, PortalOut und Exit werden **nicht** in die Data Table eingetragen – diese Räume spawnt der Generator direkt per Klasse (hartcodiert in BuildLevel / PlaceEndRoom). Nur Räume, die per Zufallswahl platziert werden (General, Corridor, DeadEnd), gehören hier rein.

> **Tipp:** Du kannst später weitere Zeilen hinzufügen (z.B. General_02, General_03 mit verschiedenen Gewichtungen oder Level-Bereichen), um mehr Vielfalt zu erzeugen.

**Schritt 4 – Im Generator referenzieren:**

Im BP_DungeonGenerator: Die Variable `RoomPoolTable` (Typ: Data Table Reference) auf **DT_RoomPool** setzen. Das geschieht im Details Panel unter dem Default Value:
1. Wähle die Variable `RoomPoolTable` aus
2. Im Details Panel → Default Value → Dropdown → wähle **DT_RoomPool**

### 1.3 Was wird gelöscht/ersetzt

- **S_SocketData** bleibt in den Räumen, wird aber auf **S_SocketDefinition** reduziert (nur noch statische Daten)
- Felder die aus S_SocketData entfernt werden: Status, IsOnMainPath, OwnerRoom, WorldLocation, WorldRotation
- Der gesamte Laufzeit-Zustand wandert in **S_OpenSocketData** und **S_PlacedRoomData** im Generator

---

## Teil 2: Stabile Socket-IDs einführen

### 2.1 Arrow Components benennen

In **jedem** Raum-Blueprint: Benenne die Arrow Components eindeutig.

Beispiel für einen 4-Socket-Raum:
- Arrow Component 1 → Name: **Socket_North**
- Arrow Component 2 → Name: **Socket_East**
- Arrow Component 3 → Name: **Socket_South**
- Arrow Component 4 → Name: **Socket_West**

Beispiel für DeadEnd (1 Socket):
- Arrow Component 1 → Name: **Socket_Entry**

Beispiel für Corridor (2 Sockets):
- Arrow Component 1 → Name: **Socket_Entry**
- Arrow Component 2 → Name: **Socket_Exit**

Die Namen müssen innerhalb eines Raums eindeutig sein, dürfen aber zwischen verschiedenen Raumtypen gleich heißen.

### 2.2 Variablen pro Raum-Blueprint

Jeder Raum-Blueprint braucht nur die wirklich nötigen Variablen. Der Laufzeit-State liegt **nicht** im Raum, sondern im Generator.

**Pflicht-Variablen in jedem Raum:**

| Variable | Typ | Default | Zweck |
|---|---|---|---|
| RoomType | E_RoomType | je nach Raum | Gibt den Typ des Raums zurück |
| SocketDefinitions | Array of S_SocketDefinition | leer | Wird im Construction Script aus den Arrow Components befüllt |

**Optional, nur wenn du sie wirklich brauchst:**

| Variable | Typ | Default | Zweck |
|---|---|---|---|
| RoomMesh / zusätzliche Mesh-Referenzen | Static Mesh Component Ref | – | Nur falls du im Graph direkt darauf zugreifen willst |
| BoundingBox | Box Collision Ref | – | Für Overlap/Kollisionsprüfung |
| DebugName | Name oder String | leer | Optional für Prints und Debugging |

**Nicht mehr im Raum speichern:**

- ~~Sockets~~ als `Array<S_SocketData>`
- ~~ConnectedRooms~~
- ~~IsOnMainPath~~
- ~~BranchDepth~~
- ~~SocketStatus / Occupied / Closed~~
- ~~OwnerRoom~~
- ~~WorldLocation / WorldRotation als gespeicherte Runtime-Werte~~

**RoomType-Defaults je Raum:**

| Blueprint | RoomType Default |
|---|---|
| BP_DungeonRoom_Entrance | Entrance |
| BP_DungeonRoom_General | General |
| BP_DungeonRoom_Corridor | Corridor |
| BP_DungeonRoom_PortalIn | PortalIn |
| BP_DungeonRoom_PortalOut | PortalOut |
| BP_DungeonRoom_Exit | Exit |
| BP_DungeonRoom_DeadEnd | DeadEnd |

### 2.3 Construction Script anpassen (alle Räume)

Das Construction Script befüllt jetzt **S_SocketDefinition** statt S_SocketData:

1. **Construction Script ▶** → **Clear** `SocketDefinitions`
2. → **Get Components by Class** (Arrow Component, Target: self)
3. → **ForEachLoop** (Array: Return Value)
4. **Loop Body ▶** → **Make S_SocketDefinition**:
   - SocketId: Array Element → **Get Display Name** (oder **Get Object Name**) → **Convert to Name** (z.B. "Socket_North")
   - SocketComponent: Array Element (die Arrow Component Referenz selbst)
   - LocalTransform: Array Element → **Get Relative Transform**
5. → **Add** zu SocketDefinitions Array (Variable im Raum, Typ: Array of S_SocketDefinition)
6. ForEachLoop **Completed ▶** → (Ende)

**Blueprint-Nodes Schritt für Schritt:**
```
Construction Script ▶ → Clear (SocketDefinitions)
                     → Get Components by Class (Arrow Component)
                     → ForEachLoop
    Loop Body ▶ → Make S_SocketDefinition
                   ├─ SocketId: Array Element → Get Object Name → To Name
                   ├─ SocketComponent: Array Element
                   └─ LocalTransform: Array Element → Get Relative Transform
                → Add (SocketDefinitions, S_SocketDefinition)
    Completed ▶ → (Ende)
```

### 2.4 GetSocketWorldTransformById implementieren

Die Interface-Funktion sucht einen Socket anhand seiner ID und gibt die aktuelle Weltposition zurück:

**GetSocketWorldTransformById** (NEU im Interface):
- Input: SocketId (Name)
- Output: Location (Vector), Rotation (Rotator), Success (Bool)

Implementierung in jedem Raum:
1. **SocketDefinitions** Array → **ForEachLoop**
2. → **Branch**: Array Element → Break S_SocketDefinition → SocketId → **Equal (Name)** → Input SocketId
3. → True ▶: Array Element → Break S_SocketDefinition → SocketComponent → **GetWorldLocation** → Set Location
4. → Array Element → Break S_SocketDefinition → SocketComponent → **GetWorldRotation** → Set Rotation
5. → **Return** (Location, Rotation, Success: true)
6. → ForEachLoop Completed ▶: **Return** (Location: 0,0,0, Rotation: 0,0,0, Success: **false**)

**WICHTIG:** Wir holen Location/Rotation direkt von der **Arrow Component Referenz** (SocketComponent), nicht aus dem gespeicherten LocalTransform. So bekommen wir immer die aktuelle Weltposition, auch wenn der Actor bewegt wurde.

### 2.5 BPI_DungeonRoom Interface aktualisieren

| Funktion | Inputs | Outputs |
|---|---|---|
| GetSocketDefinitions | – | SocketDefinitions (Array S_SocketDefinition) |
| GetSocketWorldTransformById | SocketId (Name) | Location (Vector), Rotation (Rotator), Success (Bool) |
| GetRoomType | – | RoomType (E_RoomType) |

**Entfernte Funktionen** (Laufzeit-State liegt jetzt im Generator):
- ~~SetIsOnMainPath~~ → wird über S_PlacedRoomData im Generator gesetzt
- ~~GetIsOnMainPath~~ → wird über S_PlacedRoomData im Generator gelesen
- ~~SetBranchDepth~~ → wird über S_PlacedRoomData im Generator gesetzt
- ~~GetBranchDepth~~ → wird über S_PlacedRoomData im Generator gelesen
- ~~GetSockets~~ → ersetzt durch GetSocketDefinitions

---

## Teil 3: BP_DungeonGenerator Variablen

### 3.1 Dungeon-Parameter (Instance Editable)

| Variable | Typ | Default | Beschreibung |
|---|---|---|---|
| Difficulty | Float | 0.5 | 0.0–1.0, bestimmt Größe |
| RandomSeed | Integer | 0 | Seed für Reproduzierbarkeit |
| RoomPoolTable | Data Table Ref | DT_RoomPool | Referenz auf die Raum-Tabelle |
| MinRoomsPerLevel | Integer | 5 | Minimum Räume pro Level |
| MaxRoomsPerLevel | Integer | 15 | Maximum Räume pro Level |
| MinLevels | Integer | 5 | Minimum Dungeon-Level |
| MaxLevels | Integer | 20 | Maximum Dungeon-Level |
| MaxRetries | Integer | 5 | Retry-Limit pro Level |
| LevelVerticalOffset | Float | 1000.0 | Z-Abstand zwischen Level-Ebenen |
| MaxBranchDepthMin | Integer | 1 | Minimale Branch-Tiefe (für Random Range) |
| MaxBranchDepthMax | Integer | 5 | Maximale Branch-Tiefe (für Random Range) |

### 3.2 Laufzeit-Variablen (nicht Instance Editable)

| Variable | Typ | Default | Beschreibung |
|---|---|---|---|
| TotalLevels | Integer | 0 | Berechnete Level-Anzahl |
| CurrentLevel | Integer | 0 | Aktuelles Level |
| MaxRoomsOfLevel | Integer | 0 | Berechnete Räume pro Level |
| CurrentRoomsOnLevel | Integer | 0 | Zähler platzierte Räume |
| PlacedRooms | Array (S_PlacedRoomData) | leer | Alle platzierten Räume mit Metadaten |
| PlacedRoomActors | Array (Actor Obj Ref) | leer | Alle Raum-Actors (für Destroy bei Retry) |
| AllTrackedSockets | Array (S_OpenSocketData) | leer | **Zentrale Wahrheitsquelle** für alle Sockets aller platzierten Räume |
| MainPathFrontier | Array (S_OpenSocketData) | leer | Offene Sockets am MainPath (Arbeitsliste) |
| BranchFrontier | Array (S_OpenSocketData) | leer | Alle Branch-Socket-Kandidaten (Arbeitsliste) |
| StartRoom | Actor Object Ref | None | Aktueller Startraum |
| EndRoom | Actor Object Ref | None | Aktueller Endraum |
| LastPortalOut | Actor Object Ref | None | Letzter PortalOut |
| RetryCount | Integer | 0 | Aktueller Retry-Zähler |
| SpawnedBlockers | Array (Actor Obj Ref) | leer | Alle WallBlocker |
| CurrentSocket | S_OpenSocketData | – | Temporär: aktuell verarbeiteter Socket |
| OpenSocketsBuffer | Array (S_OpenSocketData) | leer | Wiederverwendbarer Puffer für Socket-Verteilung – immer clearen vor Verwendung |
| RandomPickedIndex | Integer | 0 | Wiederverwendbar für zufälligen Socket-Pick |
| RandomStream | Random Stream | – | Initialisiert mit RandomSeed in GenerateDungeon – überall für Zufallszahlen verwenden |

---

## Teil 4: BP_DungeonGenerator – Event Graph

### 4.1 Custom Events erstellen

1. **GenerateDungeon** – Keine Parameter
2. **BuildLevel** – Keine Parameter
3. **BuildMainPath** – Keine Parameter
4. **PlaceEndRoom** – Keine Parameter
5. **BuildBranches** – Keine Parameter
6. **SealOpenSockets** – Keine Parameter
7. **PlacePlayer** – Keine Parameter
8. **RetryLevel** – Keine Parameter (NEU)

### 4.2 BeginPlay

1. **Event BeginPlay ▶** → **GenerateDungeon**

### 4.3 GenerateDungeon

1. **GenerateDungeon ▶**
2. → **Set RandomSeed** (falls Seed == 0: vorher `Random Integer in Range` (1, 999999) → Set RandomSeed)
3. → **Make Random Stream** (RandomSeed) → **SET RandomStream**
4. → **Print String**: "Seed: " + RandomSeed (für Reproduzierbarkeit)
4. → **Lerp (Float)**: A = MinLevels, B = MaxLevels, Alpha = Difficulty → **Round to Int** → **Set TotalLevels**
5. → **Lerp (Float)**: A = MinRoomsPerLevel, B = MaxRoomsPerLevel, Alpha = Difficulty → **Round to Int** → **Set MaxRoomsOfLevel**
6. → **Set CurrentLevel** = 1
7. → **Set CurrentRoomsOnLevel** = 0
8. → **Set RetryCount** = 0
9. → **Clear** PlacedRooms, PlacedRoomActors, AllTrackedSockets, MainPathFrontier, BranchFrontier, SpawnedBlockers
10. → **BuildLevel**

**Exec-Kette:** Alle Setter und Clears müssen in der Exec-Kette verbunden sein!

```
GenerateDungeon ▶ → Set RandomSeed ▶ → Print String ▶ → Lerp+Set TotalLevels ▶
→ Lerp+Set MaxRoomsOfLevel ▶ → Set CurrentLevel ▶ → Set CurrentRoomsOnLevel ▶
→ Set RetryCount ▶ → Clear (alle Arrays) ▶ → BuildLevel
```

### 4.4 BuildLevel

1. **BuildLevel ▶**
2. → **Set CurrentRoomsOnLevel** = 0
3. → **Clear** MainPathFrontier
4. → **Branch**: CurrentLevel == 1?

**True ▶ (Erstes Level – Entrance):**

5. → **SpawnActor** BP_DungeonRoom_Entrance, Location: (0, 0, 0), Rotation: (0, 0, 0)
6. → **Set StartRoom** = Return Value
7. → **Add** Return Value zu PlacedRoomActors
8. → **RegisterRoomSockets** aufrufen (Funktion, Room = Return Value, BranchDepth = 0)
   - Füllt OpenSocketsBuffer mit allen Sockets (PathType: Branch, State: Open)
   - AllTrackedSockets wird noch NICHT befüllt – das passiert nach dem Random Pick

**Socket-Verteilung für den Startraum (Schritt 9):**

9. → OpenSocketsBuffer verteilen (kein Filter nötig – Buffer enthält nur Sockets dieses Raums):
   - **Schritt 9a:** Zufälligen MainPath-Socket aus OpenSocketsBuffer wählen
   - **Schritt 9b:** Gewählten Socket mit PathType: **MainPath** in AllTrackedSockets eintragen → **Add** zu **MainPathFrontier**
   - **Schritt 9c:** Alle übrigen mit PathType: **Branch** in AllTrackedSockets eintragen → **Add** zu **BranchFrontier**

   > **Warum zufällig?** "Ersten nehmen" wäre immer derselbe Socket (abhängig von der Reihenfolge der Arrow Components im Blueprint-Viewport), nicht vom Seed gesteuert. Der Zufalls-Pick sorgt dafür, dass der MainPath-Ausgang bei jedem Seed anders liegen kann.

   **Konkret in Blueprints:**
   ```
   // Schritt 9a – Zufälligen MainPath-Socket wählen
   Branch: OpenSocketsBuffer Length > 0?
     True ▶ → Random Integer in Range from Stream
                (Stream: RandomStream, Min: 0, Max: OpenSocketsBuffer Length - 1)
             → Set RandomPickedIndex

   // Schritt 9b + 9c – Alle Buffer-Einträge in AllTrackedSockets eintragen und verteilen
   OpenSocketsBuffer → ForEachLoop
     Loop Body ▶ → Branch: Array Index == RandomPickedIndex?
       True ▶  → Array Element → Break S_OpenSocketData
               → Make S_OpenSocketData
                   ├─ OwnerRoom, SocketId, SocketIndex, LevelIndex, BranchDepth, State: jeweiliger Pin von Break
                   └─ PathType: MainPath  ← einzige Änderung
               → Add zu AllTrackedSockets
               → Add zu MainPathFrontier
       False ▶ → Array Element → Add zu AllTrackedSockets   (PathType bereits Branch, kein Break/Make nötig)
               → Array Element → Add zu BranchFrontier
   ```

   **Gemeinsame Variablen (Generator-Ebene, überall wiederverwenden):**
   - `OpenSocketsBuffer` – Array of S_OpenSocketData (wird von RegisterRoomSockets geleert und befüllt)
   - `RandomPickedIndex` – Integer

10. → **Make S_PlacedRoomData** (RoomActor: StartRoom, RoomType: Entrance, PathType: MainPath, LevelIndex: CurrentLevel, BranchDepth: 0) → **Add** zu PlacedRooms
11. → **BuildMainPath**

**False ▶ (Level 2+ – PortalIn):**

5. → LastPortalOut → **GetActorLocation** → **Subtract** Vector(0, 0, **LevelVerticalOffset**) → **Set** PortalInLocation
6. → **SpawnActor** BP_DungeonRoom_PortalIn, Location: PortalInLocation, Rotation: (0, 0, 0)
7. → **Set StartRoom** = Return Value
8. → **Add** Return Value zu PlacedRoomActors
9. → **RegisterRoomSockets** aufrufen (Funktion, Room = Return Value, BranchDepth = 0)
   - Füllt OpenSocketsBuffer mit allen Sockets (PathType: Branch, State: Open)

**Socket-Verteilung (identisch zu oben):**

10. → Random Pick aus OpenSocketsBuffer → gewählter Socket mit PathType: MainPath in AllTrackedSockets + MainPathFrontier → Rest mit PathType: Branch in AllTrackedSockets + BranchFrontier (siehe Schritt 9 oben für vollständige Blueprint-Logik)

11. → **Make S_PlacedRoomData** (RoomActor: StartRoom, RoomType: PortalIn, PathType: MainPath, LevelIndex: CurrentLevel, BranchDepth: 0) → **Add** zu PlacedRooms
12. → **BuildMainPath**

### 4.5 RegisterRoomSockets (Hilfsfunktion, NEU)

Diese Funktion liest die Socket-Definitionen eines Raums und füllt **OpenSocketsBuffer** mit S_OpenSocketData-Einträgen. Sie schreibt **nicht** direkt in AllTrackedSockets – das übernimmt der Aufrufer nach dem Random Pick, damit PathType für jeden Socket korrekt gesetzt wird.

**Umsetzung:** Erstelle eine neue Funktion (nicht Custom Event) im BP_DungeonGenerator:

**Inputs:**
- Room (Actor Object Ref)
- BranchDepth (Integer, Default: 0)

**Keine Outputs** (schreibt in OpenSocketsBuffer, clearet ihn vorher).

**Graph:**

1. → **Clear** OpenSocketsBuffer
2. → Room → **GetSocketDefinitions (Message)** → SocketDefinitions Array
3. → **Branch**: SocketDefinitions → **Length** > 0?
4. → False ▶: **Print String** "WARNING: Room has no sockets!" → **Return**
5. → True ▶: **ForEachLoop** über SocketDefinitions
6. **Loop Body ▶** → **Make S_OpenSocketData**:
   - OwnerRoom: Room (Input)
   - SocketId: Array Element → Break S_SocketDefinition → SocketId
   - SocketIndex: ForEachLoop → **Array Index**
   - PathType: **Branch** (immer – wird nach dem Random Pick für den gewählten Socket auf MainPath korrigiert)
   - LevelIndex: CurrentLevel (Generator-Variable)
   - BranchDepth: BranchDepth (Input)
   - State: **Open**
7. → **Add** zu **OpenSocketsBuffer**
8. ForEachLoop **Completed ▶** → **Return**

```
RegisterRoomSockets (Room, BranchDepth)
  → Clear OpenSocketsBuffer
  → Room → GetSocketDefinitions (Message) → SocketDefinitions
  → Branch: Length > 0?
    False ▶ → Print "WARNING: Room has no sockets!" → Return
    True ▶ → ForEachLoop (SocketDefinitions)
      Loop Body ▶ → Make S_OpenSocketData
        ├─ OwnerRoom: Room
        ├─ SocketId: Element.SocketId
        ├─ SocketIndex: Array Index
        ├─ PathType: Branch
        ├─ LevelIndex: CurrentLevel
        ├─ BranchDepth: BranchDepth
        └─ State: Open
      → Add zu OpenSocketsBuffer
    Completed ▶ → Return
```

**WICHTIG:** `AllTrackedSockets` ist die einzige vollständige Socket-Datenbank. `OpenSocketsBuffer` ist nur ein temporärer Zwischenpuffer – nach dem Random Pick werden alle Einträge aus dem Buffer mit korrekt gesetztem PathType in AllTrackedSockets eingetragen. `MainPathFrontier` und `BranchFrontier` sind Arbeits-Arrays für aktuell offene Kandidaten.

### 4.5.1 UpdateSocketState (Hilfsfunktion, NEU)

Diese Funktion wird an vielen Stellen benötigt. Sie findet einen bestimmten Socket in AllTrackedSockets und setzt seinen State.

**Umsetzung:** Erstelle eine neue Funktion im BP_DungeonGenerator:

**Inputs:**
- TargetRoom (Actor Object Ref) – Der Raum dessen Socket geändert wird
- TargetSocketId (Name) – Die Socket-ID die geändert wird
- NewState (E_SocketStatus) – Der neue State (Occupied, Closed, etc.)

**Keine Outputs.**

**Graph:**

1. → **AllTrackedSockets** → **ForEachLoop with Break**
2. **Loop Body ▶** → Array Element → **Break S_OpenSocketData**
3. → **Branch**: OwnerRoom == TargetRoom **AND** SocketId == TargetSocketId?
4. → **True ▶:**
   - Array Element → **Break S_OpenSocketData** → alle Felder einzeln rausholen
   - **Make S_OpenSocketData** mit allen gleichen Werten, aber **State = NewState**
   - **Set Array Elem** (Target: AllTrackedSockets, Index: ForEachLoop Array Index, Item: der neue S_OpenSocketData)
   - → **Break** (ForEachLoop beenden)
5. → **False ▶:** → weiter (nächste Iteration)

```
UpdateSocketState (TargetRoom, TargetSocketId, NewState)
  → AllTrackedSockets → ForEachLoop with Break
    Loop Body ▶ → Break S_OpenSocketData
      → Branch: OwnerRoom == TargetRoom AND SocketId == TargetSocketId?
        True ▶ → Make S_OpenSocketData (alle Felder kopieren, State = NewState)
               → Set Array Elem (AllTrackedSockets, Array Index, neuer Eintrag)
               → Break
        False ▶ → (weiter)
```

**UE Blueprint Details für Set Array Elem:**
- Rechtsklick in den Graph → "Set Array Elem"
- Target: AllTrackedSockets (Variable-Getter, als Referenz)
- Index: ForEachLoop → Array Index
- Item: Der neue S_OpenSocketData Struct
- **Size to Fit: NEIN** (der Index existiert bereits)

### 4.6 BuildMainPath

**Umsetzung als While-Loop:**

**While Loop Condition:**
- **AND**: MainPathFrontier **Length > 0** UND CurrentRoomsOnLevel **< MaxRoomsOfLevel**

**Loop Body ▶:**

1. → MainPathFrontier **Get (Index 0)** → **Set CurrentSocket**
2. → MainPathFrontier **Remove Index 0**
3. → **FindCompatibleRoom** (OpenSocket: CurrentSocket, ExcludeTypes: [Entrance, Exit, PortalIn, PortalOut, DeadEnd])
   - Details siehe **Teil 5.1**
4. → **Branch** (Success)

**False ▶ (kein kompatibler Raum gefunden):**
5. → **Print String** "No compatible room found for socket" (Debug)
6. → Exec-Pin zurück zum **Loop-Eingang** des While-Loop-Macros (nächste Iteration)

**True ▶ (Raum gefunden):**
5. → **SnapRoomToSocket** (OpenSocket: CurrentSocket, NewRoomClass: FoundRoomClass, NewSocketIndex: MatchingSocketIndex, NewSocketId: MatchingSocketId)
   - Details siehe **Teil 5.2**
6. → **Branch** (Success)

**False ▶ (Snap fehlgeschlagen, z.B. Kollision):**
7. → **Print String** "Snap failed (collision)" (Debug)
8. → Exec-Pin zurück zum **Loop-Eingang** des While-Loop-Macros (nächste Iteration)

> **WICHTIG:** Beide Fehlerpfade müssen ihren Exec-Output-Pin zurück an den **Loop-Eingang** des While-Loop-Macros anschließen. Ohne diese Verbindung bricht die Schleife beim ersten Fehler ab anstatt mit dem nächsten Socket weiterzumachen.

**True ▶ (Snap erfolgreich):**

**Schritt 7 – Raum registrieren:**
7. → **Add** SpawnedRoom zu PlacedRoomActors
8. → **CurrentRoomsOnLevel + 1** → **Set CurrentRoomsOnLevel**
9. → **Make S_PlacedRoomData** (RoomActor: SpawnedRoom, RoomType: aus FindCompatibleRoom, PathType: MainPath, LevelIndex: CurrentLevel, BranchDepth: 0) → **Add** zu PlacedRooms

**Schritt 10 – Benutzten Socket auf Occupied setzen:**
10. → **UpdateSocketState** (TargetRoom: CurrentSocket.OwnerRoom, TargetSocketId: CurrentSocket.SocketId, NewState: **Occupied**)

**Schritt 11 – Sockets des neuen Raums registrieren und verteilen (KRITISCH):**

Ohne die folgende Regel verzweigt der MainPath unkontrolliert und wird zu einem Netz statt einem klaren Pfad. Die Regel ist: **Genau 1 Socket geht auf MainPath, der Rest geht auf Branch.**

> **Warum zufällig?** "Ersten nehmen" wäre immer derselbe Socket (abhängig von der Reihenfolge der Arrow Components im Blueprint-Viewport). Der Zufalls-Pick sorgt dafür, dass der MainPath-Ausgang bei jedem Seed anders liegen kann. Das gilt für alle Räume gleichermaßen – beim Startraum gibt es keinen Eingangs-Socket, bei allen anderen ist genau einer belegt.

**MatchingSocketId kennen:**
MatchingSocketId ist die SocketId des Sockets am neuen Raum, der für das Andocken benutzt wurde. Du bekommst sie aus FindCompatibleRoom:
- In FindCompatibleRoom hast du den SocketDefinitions-Array des Kandidaten durchsucht
- MatchingSocketIndex ist der Array-Index des gewählten Sockets
- MatchingSocketId = SocketDefinitions[MatchingSocketIndex].SocketId
- **Erweitere FindCompatibleRoom so, dass es auch MatchingSocketId (Name) zurückgibt** (zusätzlich zu MatchingSocketIndex)

**Umsetzung (gleiches Muster wie Schritt 9, nur mit Eingangs-Socket-Behandlung davor):**

```
// Schritt 11a – Buffer füllen (RegisterRoomSockets cleared OpenSocketsBuffer selbst)
RegisterRoomSockets (Room: SpawnedRoom, BranchDepth: 0)
  → OpenSocketsBuffer enthält alle Sockets mit PathType: Branch, State: Open

// Schritt 11b – Eingangs-Socket aus Buffer herausnehmen und als Occupied in AllTrackedSockets eintragen
OpenSocketsBuffer → ForEachLoop with Break
  Loop Body ▶ → Branch: Element.SocketId == MatchingSocketId?
    True ▶  → Make S_OpenSocketData (alle Felder von Element, State: Occupied, PathType: Branch)
            → Add zu AllTrackedSockets
            → Remove (OpenSocketsBuffer, Array Index)
            → Break

// Schritt 11c – Zufälligen MainPath-Socket aus verbliebenem Buffer wählen
Branch: OpenSocketsBuffer Length > 0?
  False ▶ → Print "WARNING: New room has no free sockets!" → (weiter)
  True ▶  → Random Integer in Range from Stream (0, OpenSocketsBuffer Length - 1)
          → Set RandomPickedIndex

// Schritt 11d – Restlichen Buffer in AllTrackedSockets eintragen und verteilen
OpenSocketsBuffer → ForEachLoop
  Loop Body ▶ → Branch: Array Index == RandomPickedIndex?
    True ▶  → Array Element → Break S_OpenSocketData
            → Make S_OpenSocketData
                ├─ OwnerRoom, SocketId, SocketIndex, LevelIndex, BranchDepth, State: jeweiliger Pin von Break
                └─ PathType: MainPath  ← einzige Änderung
            → Add zu AllTrackedSockets
            → Add zu MainPathFrontier
    False ▶ → Array Element → Add zu AllTrackedSockets   (PathType bereits Branch, kein Break/Make nötig)
            → Array Element → Add zu BranchFrontier
```

**Ergebnis pro Raum:** Genau 1 Socket → Occupied (Eingang), genau 1 zufälliger Socket → MainPathFrontier (Ausgang), Rest → BranchFrontier.

```
Zusammenfassung Socket-Verteilung (gilt für ALLE Räume):

Schritt a – RegisterRoomSockets → OpenSocketsBuffer gefüllt (alle Branch, Open), AllTrackedSockets noch leer für diesen Raum
Schritt b – Eingangs-Socket aus Buffer → AllTrackedSockets (Occupied)    [entfällt beim Startraum]
Schritt c – Random Pick Index aus verbliebenem Buffer bestimmen
Schritt d – Buffer → AllTrackedSockets + Frontiers:
  ├─ Zufälliger Index → PathType: MainPath, MainPathFrontier
  └─ Alle anderen    → PathType: Branch,   BranchFrontier
```

**While Loop Completed ▶** → **PlaceEndRoom**

### 4.7 PlaceEndRoom

1. **PlaceEndRoom ▶**
2. → **Branch**: MainPathFrontier **Length > 0**?

**False ▶ (Kein offener MainPath-Socket mehr):**
3. → **Print String** "No open MainPath socket for end room!"
4. → **RetryLevel** (siehe Teil 4.11)

**True ▶:**
3. → MainPathFrontier **Get (Index 0)** → **Set CurrentSocket**
4. → **Branch**: CurrentLevel == TotalLevels?

**True ▶ (Letztes Level – Exit):**
5. → **FindCompatibleRoom** (OpenSocket: CurrentSocket, ExcludeTypes: [Entrance, PortalIn, PortalOut, General, Corridor, DeadEnd])
   - Damit bleibt nur **Exit** übrig als gültiger Typ
6. → **Branch** (Success)
   - False ▶: **Print String** "No Exit room found!" → **RetryLevel**
7. → True ▶: **SnapRoomToSocket** (OpenSocket: CurrentSocket, NewRoomClass: FoundRoomClass, NewSocketIndex: MatchingSocketIndex, NewSocketId: MatchingSocketId)
8. → **Branch** (Success)
   - False ▶: **Print String** "Exit snap failed!" → **RetryLevel**
9. → True ▶:
10. → **Set EndRoom** = SpawnedRoom
11. → **Add** SpawnedRoom zu PlacedRoomActors
12. → **Make S_PlacedRoomData** (PathType: MainPath, RoomType: Exit, LevelIndex: CurrentLevel, BranchDepth: 0) → **Add** zu PlacedRooms
13. → **UpdateSocketState** (CurrentSocket.OwnerRoom, CurrentSocket.SocketId, **Occupied**)

**Schritt 14 – Alle Sockets des Exit-Raums registrieren:**
14. → **RegisterRoomSockets** (Room: SpawnedRoom, PathType: MainPath, BranchDepth: 0)
   - Registriert alle Sockets des Exit-Raums in AllTrackedSockets mit State: Open
15. → Den Eingangs-Socket des Exit-Raums auf Occupied setzen:
   → **UpdateSocketState** (TargetRoom: SpawnedRoom, TargetSocketId: **MatchingSocketId**, NewState: **Occupied**)
   - MatchingSocketId kommt aus FindCompatibleRoom (Schritt 5)
   - Übrige Sockets des Exit-Raums bleiben Open und werden später von SealOpenSockets mit WallBlockern verschlossen
16. → **BuildBranches**

**False ▶ (Nicht letztes Level – PortalOut):**
5. → **FindCompatibleRoom** (OpenSocket: CurrentSocket, ExcludeTypes: [Entrance, PortalIn, Exit, General, Corridor, DeadEnd])
   - Damit bleibt nur **PortalOut** übrig als gültiger Typ
6. → **Branch** (Success)
   - False ▶: **Print String** "No PortalOut room found!" → **RetryLevel**
7. → True ▶: **SnapRoomToSocket** (OpenSocket: CurrentSocket, NewRoomClass: FoundRoomClass, NewSocketIndex: MatchingSocketIndex, NewSocketId: MatchingSocketId) → **Branch** (Success)
   - False ▶: → **RetryLevel**
8. → True ▶:
9. → **Set EndRoom** = SpawnedRoom
10. → **Set LastPortalOut** = SpawnedRoom
11. → **Add** SpawnedRoom zu PlacedRoomActors
12. → **Make S_PlacedRoomData** (PathType: MainPath, RoomType: PortalOut, LevelIndex: CurrentLevel, BranchDepth: 0) → **Add** zu PlacedRooms
13. → **UpdateSocketState** (CurrentSocket.OwnerRoom, CurrentSocket.SocketId, **Occupied**)

**Schritt 14 – Alle Sockets des PortalOut-Raums registrieren:**
14. → **RegisterRoomSockets** (Room: SpawnedRoom, PathType: MainPath, BranchDepth: 0)
   - Registriert alle Sockets des PortalOut-Raums in AllTrackedSockets mit State: Open
15. → Den Eingangs-Socket des PortalOut-Raums auf Occupied setzen:
   → **UpdateSocketState** (TargetRoom: SpawnedRoom, TargetSocketId: **MatchingSocketId**, NewState: **Occupied**)
   - MatchingSocketId kommt aus FindCompatibleRoom (Schritt 5)
   - Übrige Sockets des PortalOut-Raums bleiben Open → werden von SealOpenSockets verschlossen
16. → **Set CurrentLevel** = CurrentLevel + 1
17. → **BuildLevel** (nächstes Level starten)

**WICHTIG:** Branches werden NICHT nach PortalOut gebaut! Nur nach Exit (letztes Level). Dadurch sammelt BranchFrontier Sockets über ALLE Level hinweg, und BuildBranches baut sie am Ende alle auf einmal.

### 4.8 BuildBranches

Wird NUR nach dem Exit-Raum aufgerufen. Baut Abzweigungen über alle Level hinweg.

1. **BuildBranches ▶**
2. → **Branch**: BranchFrontier **Length > 0**?
   - False ▶: **Print String** "No branch sockets available" → **SealOpenSockets**

**WICHTIG: Array-Kopie erstellen!** BranchFrontier wird während der Iteration verändert (neue Sockets werden hinzugefügt). In UE Blueprints darf man ein Array nicht verändern während man darüber iteriert.

3. → True ▶: BranchFrontier → **Copy** in lokale Variable **BranchWorkList** (Rechtsklick auf BranchFrontier → Get → in neue lokale Variable ziehen, oder: **Set BranchWorkList** = BranchFrontier, dann **Clear** BranchFrontier)

**Konkret:**
```
Set BranchWorkList = BranchFrontier (kopiert das Array)
Clear BranchFrontier (leert das Original – neue Sockets aus Branch-Räumen kommen hier rein)
```

4. → **ForEachLoop** über **BranchWorkList** (NICHT über BranchFrontier!)

**Loop Body ▶ (für jeden Branch-Startpunkt):**

5. → **Random Integer in Range** (MaxBranchDepthMin, MaxBranchDepthMax) → **Set** MaxBranchDepth (lokale Variable)
6. → **Set** CurrentBranchDepth = 0 (lokale Variable)
7. → Array Element → **Set** CurrentBranchSocket (lokale Variable, Typ: S_OpenSocketData)

**Innere While-Loop** (Condition: CurrentBranchDepth < MaxBranchDepth):

8. → **Branch**: CurrentBranchDepth == MaxBranchDepth - 1?

**True ▶ (Letzter Raum der Branch – DeadEnd platzieren):**

9. → **SnapRoomToSocket** (OpenSocket: CurrentBranchSocket, NewRoomClass: BP_DungeonRoom_DeadEnd, NewSocketIndex: 0, NewSocketId: "Socket_Entry")
   - DeadEnd hat immer genau 1 Socket namens "Socket_Entry", daher Index 0 und Id fest
10. → **Branch** (Success)

**False ▶ (DeadEnd Snap fehlgeschlagen):**
11. → **Print String** "DeadEnd snap failed" → **Break** innere While-Loop (Branch abbrechen)

**True ▶ (DeadEnd erfolgreich):**
11. → **Add** SpawnedRoom zu PlacedRoomActors
12. → **Make S_PlacedRoomData** (PathType: Branch, RoomType: DeadEnd, LevelIndex: CurrentBranchSocket.LevelIndex, BranchDepth: CurrentBranchDepth + 1) → **Add** zu PlacedRooms
13. → **UpdateSocketState** (CurrentBranchSocket.OwnerRoom, CurrentBranchSocket.SocketId, **Occupied**)
14. → DeadEnd hat nur 1 Socket (Socket_Entry) → Eingangs-Socket registrieren:
   - **Make S_OpenSocketData** (OwnerRoom: SpawnedRoom, SocketId: "Socket_Entry", SocketIndex: 0, PathType: Branch, LevelIndex: CurrentBranchSocket.LevelIndex, BranchDepth: CurrentBranchDepth + 1, State: **Occupied**) → **Add** zu AllTrackedSockets
15. → **Break** innere While-Loop (Branch fertig)

**False ▶ (Nicht letzter Raum – normaler Branch-Raum):**

9. → **FindCompatibleRoom** (OpenSocket: CurrentBranchSocket, ExcludeTypes: [Entrance, Exit, PortalIn, PortalOut, DeadEnd])
   - Liefert: FoundRoomClass, MatchingSocketIndex, **MatchingSocketId**, FoundRoomType, Success
10. → **Branch** (Success)
   - False ▶: **Print String** "No room for branch" → **Break** innere While-Loop

11. → True ▶: **SnapRoomToSocket** (OpenSocket: CurrentBranchSocket, NewRoomClass: FoundRoomClass, NewSocketIndex: MatchingSocketIndex, NewSocketId: **MatchingSocketId**) → **Branch** (Success)
   - False ▶: **Print String** "Branch snap failed" → **Break** innere While-Loop

12. → True ▶:
13. → **Add** SpawnedRoom zu PlacedRoomActors
14. → **Make S_PlacedRoomData** (PathType: Branch, RoomType: aus FindCompatibleRoom, LevelIndex: CurrentBranchSocket.LevelIndex, BranchDepth: CurrentBranchDepth + 1) → **Add** zu PlacedRooms

15. → **UpdateSocketState** (CurrentBranchSocket.OwnerRoom, CurrentBranchSocket.SocketId, **Occupied**)

16. → Sockets des neuen Branch-Raums registrieren und verteilen:
   - SpawnedRoom → **GetSocketDefinitions (Message)** → SocketDefinitions
   - Lokaler Bool **BranchContinued** = false
   - **ForEachLoop** über SocketDefinitions:
     - **Branch**: SocketId == MatchingSocketId? (Eingangs-Socket, MatchingSocketId kommt aus FindCompatibleRoom in Schritt 9)
       - True ▶: **Make S_OpenSocketData** (State: **Occupied**) → Add zu AllTrackedSockets
       - False ▶: **Branch**: BranchContinued == false?
         - True ▶ (erster freier Socket → Branch weiterführen):
           - **Make S_OpenSocketData** (PathType: Branch, State: Open, BranchDepth: CurrentBranchDepth + 1) → Add zu AllTrackedSockets
           - → **Set CurrentBranchSocket** = dieser neue S_OpenSocketData
           - → **Set BranchContinued** = true
         - False ▶ (weitere Sockets → zur späteren Verarbeitung):
           - **Make S_OpenSocketData** (PathType: Branch, State: Open, BranchDepth: CurrentBranchDepth + 1) → Add zu AllTrackedSockets
           - → **Add** zu **BranchFrontier** (wird in einer späteren Iteration verarbeitet, falls gewünscht)

17. → **CurrentBranchDepth + 1** → Set CurrentBranchDepth
18. → (Innere While-Loop nächste Iteration)

**ForEachLoop Completed ▶:**

19. → **Branch**: BranchFrontier **Length > 0**? (Wurden während des Branch-Baus neue Sockets gesammelt?)
   - True ▶: Optional: Nochmal eine Runde Branch-Bau starten (Rekursion/Loop), ODER: ignorieren und mit SealOpenSockets verschließen
   - False ▶: → **SealOpenSockets**

**Empfehlung für den Prototyp:** Neue BranchFrontier-Einträge aus dem Branch-Bau NICHT weiter verfolgen, sondern direkt zu SealOpenSockets gehen. Das verhindert unkontrolliertes Wachstum. Also nach ForEachLoop Completed immer → **SealOpenSockets**.

### 4.9 SealOpenSockets

Alle übrig gebliebenen offenen Sockets mit WallBlockern verschließen.

Die Funktion nutzt **AllTrackedSockets** als einzige Wahrheitsquelle.
- **Occupied** = Socket wurde als Verbindung zwischen zwei Räumen benutzt
- **Open** = Socket wurde nie verbunden (braucht WallBlocker)
- **Closed** = Socket wurde bereits mit einem WallBlocker verschlossen

1. **SealOpenSockets ▶**

**Schritt 2 – Offene Sockets sammeln:**
2. → Lokales Array **OpenSocketsToSeal** (Typ: Array of S_OpenSocketData) erstellen
3. → **AllTrackedSockets** → **ForEachLoop**
4. → Array Element → Break S_OpenSocketData → State
5. → **Branch**: State == **Open**?
6. → True ▶: **Add** Array Element zu OpenSocketsToSeal
7. → ForEachLoop Completed ▶: weiter mit Schritt 8

```
AllTrackedSockets → ForEachLoop
  Loop Body ▶ → Break S_OpenSocketData
    → Branch: State == Open?
      True ▶ → Add zu OpenSocketsToSeal
  Completed ▶ → (weiter)
```

**Schritt 8 – WallBlocker spawnen:**
8. → **ForEachLoop** über OpenSocketsToSeal
9. → Array Element → Break S_OpenSocketData → OwnerRoom, SocketId
10. → OwnerRoom → **GetSocketWorldTransformById (Message)** (SocketId) → Location, Rotation, Success
11. → **Branch** (Success)
   - False ▶: **Print String** "WARNING: Socket not found for sealing" → weiter
12. → True ▶: **SpawnActor** BP_WallBlocker
   - Location: Location vom Socket
   - Rotation: Rotation vom Socket
13. → **Add** WallBlocker zu SpawnedBlockers
14. → **UpdateSocketState** (OwnerRoom, SocketId, **Closed**)

**ForEachLoop Completed ▶** → **PlacePlayer**

### 4.10 PlacePlayer

1. **PlacePlayer ▶**
2. → **Get Player Character** (Player Index: 0)
3. → **Branch**: IsValid (Player Character)?
   - False ▶: **Print String** "No player character found!"
4. → True ▶: StartRoom → **GetActorLocation** → **Set** StartLocation
5. → **SetActorLocation** (Target: Player Character, New Location: StartLocation)
6. → **Print String** "Dungeon Generation Complete! Levels: " + TotalLevels + " Rooms: " + PlacedRooms Length

### 4.11 RetryLevel (NEU)

Wird aufgerufen wenn BuildMainPath oder PlaceEndRoom fehlschlägt.

1. **RetryLevel ▶**
2. → **RetryCount + 1** → **Set RetryCount**
3. → **Branch**: RetryCount > MaxRetries?

**True ▶ (Zu viele Retries):**
4. → **Print String** "FATAL: Level generation failed after " + MaxRetries + " retries!"
5. → (Hier enden – optional: gesamten Dungeon neu starten mit GenerateDungeon)

**False ▶ (Retry möglich):**
4. → **Print String** "Retrying level " + CurrentLevel + " (Attempt " + RetryCount + ")"

**Schritt 5 – Räume des aktuellen Levels aufräumen:**

Iteriere direkt über **PlacedRooms** (nicht PlacedRoomActors), weil PlacedRooms den LevelIndex enthält:

5. → PlacedRooms → **Rückwärts-ForLoop** (Length - 1 → 0, step -1)
6. → PlacedRooms **Get (Index)** → Break S_PlacedRoomData → LevelIndex, RoomActor
7. → **Branch**: LevelIndex == CurrentLevel?
8. → True ▶: RoomActor → **Destroy Actor** → **Remove Index** (PlacedRooms, Index)
9. → ForLoop Completed ▶:

**Schritt 10 – Weitere Arrays bereinigen:**
10. → PlacedRoomActors: Alle ungültigen Actors entfernen (Rückwärts-ForLoop → IsValid? → False → Remove Index)
11. → AllTrackedSockets: Alle Einträge mit LevelIndex == CurrentLevel entfernen (Rückwärts-ForLoop)
12. → MainPathFrontier → **Clear**
13. → BranchFrontier: Alle Einträge mit LevelIndex == CurrentLevel entfernen (Rückwärts-ForLoop)

**Schritt 14 – WallBlocker aufräumen (falls bereits Branches gebaut wurden):**
14. → SpawnedBlockers → **ForEachLoop** → **Destroy Actor** → **Clear** SpawnedBlockers

**Schritt 15 – Level neu starten:**
15. → **BuildLevel**

**Hinweis zur Array-Bereinigung:** "Alle Einträge mit LevelIndex == X entfernen" ist in Blueprints am einfachsten mit einer **Rückwärts-ForLoop**:
```
PlacedRooms → Length - 1 → ForLoop (LastIndex to 0, step -1)
  Loop Body ▶ → PlacedRooms Get (Index) → Break → LevelIndex
    → Branch: LevelIndex == CurrentLevel?
      True ▶ → Remove Index (PlacedRooms, Index)
```
Rückwärts iterieren verhindert Index-Verschiebung beim Entfernen!

---

## Teil 5: Funktionen

### 5.1 FindCompatibleRoom

**Umsetzung:** Erstelle eine neue Funktion im BP_DungeonGenerator.

**Inputs:**
- OpenSocket (S_OpenSocketData) – Der offene Socket an den angedockt werden soll
- ExcludeTypes (Array of E_RoomType) – Raumtypen die ausgeschlossen werden

**Outputs:**
- FoundRoomClass (Actor Class Ref) – Die Blueprint-Klasse des gewählten Raums
- MatchingSocketIndex (Integer) – Index des Sockets im neuen Raum der als Eingang dient
- MatchingSocketId (Name) – **NEU** – Socket-ID des Eingangs-Sockets (für spätere Zuordnung)
- FoundRoomType (E_RoomType) – **NEU** – Typ des gewählten Raums (für S_PlacedRoomData)
- Success (Bool)

**Schritt 1 – Gültige Kandidaten aus der Data Table filtern:**

**Lokale Variablen (in der Funktion anlegen):**
- **RowNames** (Array of Name) – Zeilennamen aus der Data Table
- **ValidCandidates** (Array of S_RoomPoolEntry) – gefilterte Kandidaten
- **TotalWeight** (Float) – Summe aller Weights
- **RandomPick** (Float) – zufälliger Wert zwischen 0 und TotalWeight
- **RunningWeight** (Float) – laufende Summe beim Iterieren
- **ChosenEntry** (S_RoomPoolEntry) – der gewählte Kandidat
- **TempCandidate** (Actor Object Ref) – temporär gespawnter Raum für Socket-Matching

> **Wichtig:** In UE5 gibt es keinen "Get Data Table Rows"-Node (Plural). Stattdessen holst du zuerst alle Zeilennamen mit **Get Data Table Row Names**, dann iterierst du darüber und holst jede Zeile einzeln mit **Get Data Table Row**.

1. → **Get Data Table Row Names** (Table: RoomPoolTable) → Set **RowNames**
2. → **ForEachLoop** über RowNames
3. → **Get Data Table Row** (Table: RoomPoolTable, Row Name: Array Element) → hat zwei Exec-Pins und einen Data-Pin:
   - **Row Found ▶** (Exec) – Zeile existiert
   - **Row Not Found ▶** (Exec) – Zeile nicht gefunden (einfach ignorieren, weiter zur nächsten Iteration)
   - **Out Row** (S_RoomPoolEntry) – die Zeilendaten
4. → **Row Found ▶**: Out Row → **Break S_RoomPoolEntry** → RoomType, MinLevel, MaxLevel
5. → **Branch**: Drei Bedingungen müssen ALLE true sein (AND):
   - RoomType → **Contains** in ExcludeTypes Array → **NOT** (= RoomType ist NICHT ausgeschlossen)
   - MinLevel **<=** CurrentLevel
   - MaxLevel **>=** CurrentLevel **OR** MaxLevel == 0 (0 = unbegrenzt)
6. → True ▶: Out Row → **Add** zu ValidCandidates
7. → ForEachLoop Completed ▶: **Branch** (ValidCandidates **Length > 0**)
8. → False ▶: **Return** (Success = false)

```
Get Data Table Row Names (RoomPoolTable) → RowNames
ForEachLoop (RowNames)
  Loop Body ▶ → Get Data Table Row (RoomPoolTable, Array Element)
    Row Found ▶ → Break S_RoomPoolEntry → RoomType, MinLevel, MaxLevel
      → Branch: NOT Contains(ExcludeTypes, RoomType)
                 AND MinLevel <= CurrentLevel
                 AND (MaxLevel >= CurrentLevel OR MaxLevel == 0)
        True ▶ → Add zu ValidCandidates
    Row Not Found ▶ → (nichts, nächste Iteration)
  Completed ▶ → Branch: ValidCandidates Length > 0?
    False ▶ → Return (Success = false)
    True ▶ → (weiter mit Schritt 9)
```

**Schritt 9 – Gewichtete Zufallswahl:**

9. → **Set TotalWeight** = 0.0
10. → **ForEachLoop** über ValidCandidates → TotalWeight += Array Element → Weight
11. → **Random Float in Range** (0.0, TotalWeight) → **Set** RandomPick
12. → **Set** RunningWeight = 0.0
13. → **ForEachLoop** über ValidCandidates
14. → RunningWeight += Array Element → Weight
15. → **Branch**: RunningWeight >= RandomPick?
16. → True ▶: Array Element ist der gewählte Kandidat → **Set** ChosenEntry = Array Element → **Break**

```
Gewichtete Zufallswahl:
  TotalWeight = Sum aller Weights
  RandomPick = Random Float (0, TotalWeight)
  RunningWeight = 0
  ForEachLoop:
    RunningWeight += Weight
    Branch: RunningWeight >= RandomPick?
      True ▶ → ChosenEntry = Element → Break
```

**Schritt 17 – Socket-Matching (den passenden Eingangs-Socket am Kandidaten finden):**

Wir müssen herausfinden, welcher Socket des neuen Raums als "Eingang" benutzt wird – also an den offenen Socket des bestehenden Raums andockt.

**Für den Prototyp** gilt folgende einfache Regel: **Nimm den ersten Socket des Kandidaten.** Für den Prototyp reicht das, weil alle Räume gleich große Durchgänge haben und Richtungs-Matching noch nicht implementiert ist.

17. → ChosenEntry → Break S_RoomPoolEntry → RoomClass → **SpawnActor** temporär bei (0, 0, 10000) → **Set** TempCandidate
   - Position weit oben, damit er nicht mit dem Dungeon kollidiert
18. → TempCandidate → **GetSocketDefinitions (Message)** → SocketDefinitions
19. → **Branch**: SocketDefinitions **Length > 0**?
   - False ▶: TempCandidate → **Destroy Actor** → **Return** (Success = false)
20. → True ▶: SocketDefinitions **Get (Index 0)** → Break S_SocketDefinition
21. → TempCandidate → **Destroy Actor**
22. → **Return Node** – die Output-Pins direkt am Return Node verdrahten:
   - FoundRoomClass ← ChosenEntry → Break S_RoomPoolEntry → RoomClass
   - MatchingSocketIndex ← 0 (Integer Literal)
   - MatchingSocketId ← Break S_SocketDefinition → SocketId (aus Schritt 20)
   - FoundRoomType ← ChosenEntry → Break S_RoomPoolEntry → RoomType
   - Success ← true (Boolean Literal)

> **Hinweis:** In UE5 Funktionen haben die Outputs keine separaten Set-Nodes — sie sind direkt als Data-Pins am Return Node. Du ziehst die Daten-Verbindungen (grüne/blaue Drähte) direkt in die Pins des Return Nodes. Die Exec-Kette ist: SpawnActor ▶ → GetSocketDefinitions ▶ → Branch → True ▶ → Destroy Actor ▶ → Return.

**Spätere Erweiterung – Richtungs-Matching:**
Statt pauschal Socket 0 zu nehmen, könnte man die Richtung des offenen Sockets prüfen und den Socket des Kandidaten wählen, der in die entgegengesetzte Richtung zeigt (Nord → Süd, Ost → West). Das ist aber für den Prototyp nicht nötig.

### 5.2 SnapRoomToSocket

Diese Funktion dockt einen neuen Raum an einen offenen Socket eines bestehenden Raums an.

**Umsetzung:** Erstelle eine neue Funktion im BP_DungeonGenerator.

**Inputs:**
- OpenSocket (S_OpenSocketData) – Der offene Socket am bestehenden Raum
- NewRoomClass (Actor Class Ref) – Blueprint-Klasse des neuen Raums
- NewSocketIndex (Integer) – Index des Sockets am neuen Raum der als Eingang dient
- NewSocketId (Name) – **NEU** – Socket-ID des Eingangs-Sockets am neuen Raum (für GetSocketWorldTransformById)

**Outputs:**
- SpawnedRoom (Actor Object Ref)
- Success (Bool)

**Lokale Variablen (in der Funktion anlegen):**
- **SocketWorldPos** (Vector) – Weltposition des offenen Sockets am bestehenden Raum
- **SocketWorldRot** (Rotator) – Weltrotation des offenen Sockets
- **TargetRotation** (Rotator) – Ziel-Rotation für den neuen Raum (mit 180°-Drehung)
- **TempRoom** (Actor Object Ref) – der temporär gespawnte neue Raum
- **TempSocketLocation** (Vector) – Weltposition des Eingangs-Sockets am neuen Raum
- **TempSocketOffset** (Vector) – Offset vom Actor-Origin zum Socket
- **RotatedOffset** (Vector) – TempSocketOffset rotiert um TargetRotation
- **FinalPosition** (Vector) – finale Spawn-Position des neuen Raums

**Schritt 1: Socket-Weltposition holen (via Interface)**

1. → OpenSocket → **Break S_OpenSocketData** → OwnerRoom, SocketId
2. → OwnerRoom → **GetSocketWorldTransformById (Message)** (SocketId) → Location, Rotation, Success
3. → **Branch** (Success)
   - False ▶: **Print String** "ERROR: Socket not found!" → **Return** (SpawnedRoom: None, Success: false)
4. → Location → **Set SocketWorldPos**

**Schritt 2: Ziel-Rotation berechnen (WARUM 180°?)**

Wenn zwei Räume aneinander andocken, müssen ihre Sockets **einander zugewandt** sein. Ein Socket zeigt "nach außen" aus seinem Raum heraus. Der neue Raum muss also so rotiert werden, dass sein Eingangs-Socket in die **entgegengesetzte** Richtung des Dock-Sockets zeigt. Darum drehen wir um 180° auf der Z-Achse (Yaw).

5. → Rotation → **Combine Rotators** (A: Rotation, B: (Pitch: 0, Yaw: 180, Roll: 0)) → **Set TargetRotation**

**Schritt 3: Neuen Raum spawnen**

6. → **SpawnActor** (Class: NewRoomClass, Location: (0, 0, 0), Rotation: (0, 0, 0)) → **Set TempRoom**
   - Wir spawnen bei 0,0,0 und bewegen danach – so können wir den Socket-Offset korrekt berechnen

**Schritt 4: Offset des neuen Sockets berechnen**

Der neue Raum wurde bei (0,0,0) ohne Rotation gespawnt. Jetzt berechnen wir, wo sein Eingangs-Socket relativ zum Actor-Origin liegt:

7. → TempRoom → **GetSocketWorldTransformById (Message)** (NewSocketId) → TempSocketLocation, TempSocketRotation, Success
   - Falls ById fehlschlägt (Success == false): **Print String** "ERROR: NewSocket not found!" → TempRoom → **Destroy Actor** → **Return** (SpawnedRoom: None, Success: false)
8. → TempSocketLocation **- (Subtract Vector)** TempRoom → **GetActorLocation** → **Set TempSocketOffset**
   - Das ist der Vektor vom Actor-Origin zum Socket, in Weltkoordinaten (bei Rotation 0)

**Schritt 5: Offset rotieren**

Da wir den Raum gleich um TargetRotation drehen werden, muss der Offset ebenfalls rotiert werden:

9. → TempSocketOffset → **Rotate Vector** (Rotator: TargetRotation) → **Set RotatedOffset**

**Schritt 6: Finale Position berechnen**

Der Socket des neuen Raums soll genau auf SocketWorldPos liegen. Also:
Finale Position = SocketWorldPos - RotatedOffset

10. → SocketWorldPos **- (Subtract Vector)** RotatedOffset → **Set FinalPosition**

**Schritt 7: Raum positionieren**

11. → TempRoom → **SetActorLocationAndRotation** (Location: FinalPosition, Rotation: TargetRotation, Teleport: **true**)

**Schritt 8: Kollisionsprüfung**

> **WICHTIG:** `Get Overlapping Actors` gibt ein read-only Array zurück – du kannst nicht direkt darauf entfernen. Erst in eine lokale Variable kopieren, dann entfernen.

**Lokale Variable anlegen:** In SnapRoomToSocket → My Blueprint → Local Variables → `OverlapBuffer` (Actor Object Ref, Array)

12. → TempRoom → **Get Overlapping Actors** (kein Class Filter) → **SET OverlapBuffer**
13. → OverlapBuffer → **Remove** (Item: OpenSocket → Break S_OpenSocketData → OwnerRoom) ← Donor-Raum entfernen, er berührt den neuen Raum immer (false positive)
14. → OverlapBuffer → **Length** → **> 0** → **Branch**

> **Hinweis:** TempRoom selbst ist nie in der OverlappingActors-Liste – `Get Overlapping Actors` gibt nur andere Actors zurück die mit dem Target überlappen, nicht das Target selbst. Ein Remove auf TempRoom ist daher unnötig.

**True ▶ (Kollision mit anderem Raum):**
16. → **Print String** "Collision detected, destroying room" (Debug)
17. → TempRoom → **Destroy Actor**
18. → **Return** (SpawnedRoom: None, Success: **false**)

**False ▶ (Keine Kollision – Erfolg):**
16. → **Return** (SpawnedRoom: TempRoom, Success: **true**)

**Exec-Kette (KRITISCH – alle müssen verbunden sein):**
```
SpawnActor ▶ → GetSocketWorldTransformById ▶ → SetActorLocationAndRotation ▶
→ Get Overlapping Actors ▶ → SET OverlapBuffer ▶ → Remove (OwnerRoom) ▶
→ Branch ▶ → (Destroy oder Return)
```

---

## Teil 6: Raum-Blueprints

### 6.1 Vorhandene Räume anpassen

Für jeden Raum-Blueprint (Entrance, General, Corridor, PortalIn, PortalOut, Exit):

1. Arrow Components umbenennen (Socket_North, Socket_South, Socket_East, Socket_West, oder Socket_Entry/Socket_Exit für Corridors)
2. Variable `SocketDefinitions` hinzufügen (Typ: Array of S_SocketDefinition)
3. Variable `RoomType` hinzufügen (Typ: E_RoomType, Default: je nach Raum)
4. Construction Script umbauen (siehe Teil 2.3)
5. Interface-Funktionen implementieren:
   - **GetSocketDefinitions**: SocketDefinitions Variable → Return Node
   - **GetSocketWorldTransformById**: Implementierung siehe Teil 2.4
   - **GetRoomType**: RoomType Variable → Return Node
6. **Entfernen** (falls vorhanden):
   - ~~SetIsOnMainPath~~, ~~GetIsOnMainPath~~
   - ~~SetBranchDepth~~, ~~GetBranchDepth~~
   - ~~GetSockets~~ (ersetzt durch GetSocketDefinitions)
   - Variablen ~~IsOnMainPath~~, ~~BranchDepth~~, ~~ConnectedRooms~~
7. BoundingBox: Etwas kleiner als Boden (10-20 Units eingerückt), flach (nur Bodenhöhe), Collision Preset: **OverlapAllDynamic**

### 6.2 BP_DungeonRoom_DeadEnd erstellen

- Neuer Actor Blueprint erstellen
- **Components:**
  - DefaultSceneRoot
  - RoomMesh (Static Mesh Component – ein Raum mit nur einem Eingang)
  - BoundingBox (Box Collision, kleiner als Boden, flach, OverlapAllDynamic)
  - **Socket_Entry** (Arrow Component – zeigt zum Eingang hinaus)
- **Variablen:** RoomType = DeadEnd, SocketDefinitions (Array of S_SocketDefinition)
- **Construction Script:** Wie alle anderen Räume (Teil 2.3)
- **Interface implementieren:** Wie alle anderen Räume (Teil 6.1 Schritt 5)
- **In DT_RoomPool eintragen:** RoomClass: BP_DungeonRoom_DeadEnd, RoomType: DeadEnd, Weight: 1.0, MinLevel: 1, MaxLevel: 0

### 6.3 BP_WallBlocker erstellen (falls noch nicht vorhanden)

- Neuer Actor Blueprint
- **Components:**
  - DefaultSceneRoot
  - WallMesh (Static Mesh Component – eine Wand die den Durchgang blockiert)
- Kein Interface nötig, keine Variablen nötig
- Wird nur von SealOpenSockets gespawnt

### 6.4 BoundingBox-Regeln

- Etwas kleiner als der Raumboden (10–20 Units eingerückt auf jeder Seite)
- Nur Bodenhöhe (flach) – Wände sollen NICHT kollidieren, sonst scheitert jeder benachbarte Raum
- Collision Preset: **OverlapAllDynamic**
- Collision Enabled: **Query Only** (keine Physik-Simulation)
- Generate Overlap Events: **Ja**

---

## Teil 7: Wichtige Details und Fallstricke

### 7.1 Append-Reihenfolge
- **Target (oberer Pin):** Das Array das befüllt wird
- **Source (unterer Pin):** Die neuen Daten
- Vertauschung überschreibt statt anzuhängen!

### 7.2 Socket-Weltposition live berechnen
**NIEMALS** gespeicherte Positionen verwenden. **IMMER** GetSocketWorldTransformById/ByIndex auf dem OwnerRoom aufrufen. Grund: Wenn ein Actor bewegt wird (z.B. bei SetActorLocationAndRotation), werden gespeicherte Positionen ungültig.

### 7.3 Destroy Actor Target
Beim Retry: Target = **Array Element** aus PlacedRoomActors, **NICHT** self! "self" würde den Generator selbst zerstören.

### 7.4 WallBlocker beim Retry aufräumen
SpawnedBlockers Array durchgehen → Destroy Actor → Array Clear.

### 7.5 PortalIn Positionierung
PortalIn Position = LastPortalOut.GetActorLocation() minus Vector(0, 0, **LevelVerticalOffset**).
Dadurch liegt jedes Level um LevelVerticalOffset tiefer als das vorherige.

### 7.6 Get Components by Class auf frischen Actors
Kann Length 0 zurückgeben direkt nach SpawnActor, besonders wenn das Construction Script noch nicht gelaufen ist. Deshalb immer Interface-Funktionen verwenden (GetSocketWorldTransformById), die auf die SocketDefinitions-Variable zugreifen.

### 7.7 Remove in Exec-Kette
Der Remove-Node bei Get Overlapping Actors muss in der Exec-Kette liegen:
```
SetActorLocationAndRotation ▶ → Get Overlapping Actors ▶ → Remove ▶ → Branch ▶
```
Ohne Exec-Verbindung wird Remove möglicherweise nicht ausgeführt bevor die Branch-Bedingung geprüft wird.

### 7.8 Return Node mit SpawnedRoom verbinden
Im SnapRoomToSocket: Der Success-Return-Node muss **TempRoom** auf dem **SpawnedRoom** Output-Pin haben! Sonst gibt die Funktion None zurück obwohl der Raum erfolgreich gespawnt wurde.

### 7.9 ForEachLoop mit Break vs. ohne Break
- **ForEachLoop** (Standard): Iteriert über ALLE Elemente, kann nicht vorzeitig beendet werden
- **ForEachLoop with Break**: Hat einen zusätzlichen "Break" Exec-Pin um die Schleife vorzeitig zu beenden
- Verwende **with Break** in: UpdateSocketState, FindCompatibleRoom (gewichtete Wahl), GetSocketWorldTransformById
- Verwende Standard in: RegisterRoomSockets, SealOpenSockets, Socket-Verteilung

### 7.10 Struct-Vergleiche in Blueprints
UE Blueprints können Structs nicht direkt mit == vergleichen. Um einen bestimmten Socket in AllTrackedSockets zu finden, vergleiche die **einzelnen Felder** (OwnerRoom == X AND SocketId == Y), nicht den gesamten Struct.

### 7.11 Array-Mutation während Iteration
**NIEMALS** ein Array verändern (Add, Remove, Clear) während du mit ForEachLoop darüber iterierst. Das führt zu undefiniertem Verhalten. Lösung: Vor der Iteration eine **Kopie** des Arrays erstellen und über die Kopie iterieren.

---

## Teil 8: Test-Reihenfolge

### Phase 1: Grundgerüst
1. GenerateDungeon aufrufen → Print: Seed, TotalLevels, MaxRoomsOfLevel
2. BuildLevel → Entrance spawnt bei (0,0,0) → Print "Entrance spawned"
3. Print SocketDefinitions Length → muss > 0 sein
4. Print MainPathFrontier Length → muss genau 1 sein
5. Print AllTrackedSockets Length → muss == Anzahl Arrow Components am Entrance sein

### Phase 2: Positionierung
6. BuildMainPath → Erster Raum wird gespawnt → Print FinalPosition
7. Positionen müssen verschieden sein (nicht alle bei 0,0,0)
8. F8 im Play-Mode → Kamera freigeben → Räume visuell prüfen: Docken sie korrekt aneinander?
9. Print CurrentRoomsOnLevel nach jedem Raum → muss hochzählen

### Phase 3: Level-Übergang
10. PlaceEndRoom → PortalOut spawnt → Print "PortalOut placed"
11. CurrentLevel wird auf 2 erhöht
12. PortalIn spawnt unter PortalOut → Print PortalIn Location (Z muss um LevelVerticalOffset niedriger sein)
13. Zweites Level baut sich → Print Raumanzahl

### Phase 4: Exit und Branches
14. Letztes Level → Exit spawnt → Print "Exit placed"
15. BuildBranches wird aufgerufen → Print BranchFrontier Length vor dem Bau
16. Branches bauen sich → Print je Branch: Tiefe, Raumtyp
17. DeadEnd am Ende jeder Branch → Print "DeadEnd placed"

### Phase 5: Abschluss
18. SealOpenSockets → Print Anzahl versiegelter Sockets
19. WallBlocker an offenen Sockets sichtbar
20. PlacePlayer → Spieler steht im Entrance-Raum → Print "Complete!"

### Phase 6: Retry-Test
21. Künstlich einen Fehler provozieren (z.B. MaxRoomsPerLevel = 1) → RetryLevel muss feuern
22. Print Retry-Zähler → muss hochzählen
23. Nach MaxRetries → Abbruch-Meldung

### Debug-Empfehlungen
- **Print String** mit RandomSeed ganz am Anfang (für Reproduzierbarkeit)
- **Print String** mit FinalPosition in SnapRoomToSocket (sind die Positionen plausibel?)
- **Print String** mit OwnerRoom → IsValid vor GetSocketWorldTransform (Raum noch vorhanden?)
- **Print String** mit Arrow Count nach Get Components by Class (Sockets vorhanden?)
- **DrawDebugBox** für jeden platzierten Raum an GetActorLocation (optional, zeigt Raumgrenzen)
- **Print String** mit AllTrackedSockets Length nach jedem RegisterRoomSockets (wächst korrekt?)

---

## Anhang: Ablauf-Zusammenfassung

```
BeginPlay
  └→ GenerateDungeon
       ├─ Seed, Levels, Rooms berechnen
       └→ BuildLevel (Level 1)
            ├─ Spawn Entrance
            ├─ RegisterRoomSockets → AllTrackedSockets
            ├─ Socket-Verteilung: 1→MainPathFrontier, Rest→BranchFrontier
            └→ BuildMainPath
                 ├─ While (Frontier>0 AND Rooms<Max):
                 │    ├─ FindCompatibleRoom
                 │    ├─ SnapRoomToSocket
                 │    ├─ UpdateSocketState (Occupied)
                 │    └─ Socket-Verteilung: 1→Occupied, 1→MainPath, Rest→Branch
                 └→ PlaceEndRoom
                      ├─ Nicht letztes Level → PortalOut
                      │    ├─ CurrentLevel + 1
                      │    └→ BuildLevel (nächstes Level)
                      │         ├─ Spawn PortalIn (unter LastPortalOut)
                      │         └→ BuildMainPath → PlaceEndRoom → ...
                      └─ Letztes Level → Exit
                           └→ BuildBranches
                                ├─ Kopie von BranchFrontier
                                ├─ ForEach Branch-Socket:
                                │    ├─ While (Depth < MaxDepth):
                                │    │    ├─ Letzter Raum → DeadEnd
                                │    │    └─ Sonst → FindCompatibleRoom + Snap
                                │    └─ Break bei Fehler
                                └→ SealOpenSockets
                                     ├─ Alle Open Sockets → WallBlocker
                                     └→ PlacePlayer
                                          └─ Spieler bei Entrance platzieren
```