Accessibility-Icon an Kopfzeilengröße angleichen

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.gitea/workflows/mindflux.yml

@@ -22,8 +22,15 @@ jobs:
 
       - name: Deploy
         env:
+          MINDFLUX_DB_PASSWORD: ${{ secrets.MINDFLUX_DB_PASSWORD }}
           MINDFLUX_ADMIN_PASSWORD: ${{ secrets.MINDFLUX_ADMIN_PASSWORD }}
           MINDFLUX_ADMIN2_PASSWORD: ${{ secrets.MINDFLUX_ADMIN2_PASSWORD }}
         run: |
+          test -n "$MINDFLUX_DB_PASSWORD" || { echo "MINDFLUX_DB_PASSWORD fehlt" >&2; exit 1; }
+          docker exec -i -e NEW_DB_PASSWORD="$MINDFLUX_DB_PASSWORD" postgres \
+            psql -v ON_ERROR_STOP=1 -U mindflux -d mindfluxdb <<'SQL'
+          \getenv new_db_password NEW_DB_PASSWORD
+          ALTER USER mindflux WITH PASSWORD :'new_db_password';
+          SQL
           docker compose -f docker-compose.yml pull
           docker compose -f docker-compose.yml up -d

CHANGELOG.md

@@ -4,6 +4,197 @@ Alle nennenswerten Änderungen an **Mindflux** werden hier dokumentiert.
 Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.0.0/),
 Versionierung [semantisch](https://semver.org/lang/de/).
 
+## [Unreleased] – 2026-07-12 · Großer Verbesserungs-Sweep (Sicherheit, Daten, Navigation)
+
+Weitgehende Umsetzung des Verbesserungskatalogs aus `mindfluxfuture.md` (Teil 2;
+bewusst zurückgestellte Restpunkte sind dort weiterhin als offen markiert):
+Sicherheit, Datenintegrität, echtes XP/Achievement-System, Navigations-Umbau,
+Docker/CI-Härtung und erste Tests.
+
+### Responsive Darstellung & Barrierefreiheit
+- Logout-Navigation in Dashboard, DevLab, MindMatch, SyntaxSaga und TechTacular auf ein
+  einheitliches Icon mit zugänglichem Namen und Tooltip „Abmelden“ vereinheitlicht.
+- **Globales Accessibility-Widget:** Ein schwebender Rollstuhl-Button öffnet auf jeder Seite
+  ein tastaturbedienbares Panel. Einstellungen werden ausschließlich lokal im Browser gespeichert.
+- Enthalten sind vier Textgrößen, Hochkontrast, farbenblindfreundliche Statusfarben, Monochrom,
+  einen Lesemodus für Dyslexie mit Verdana und angepassten Abständen, unterstrichene Links, reduzierte Animationen,
+  großer Cursor und ein zentraler Reset.
+- Floating-Button an die Mindflux-Palette angepasst; der Schrift-Schalter heißt nun transparent
+  „Lesemodus (Dyslexie)“ und weist auf Verdana plus vergrößerte Abstände hin.
+- Der dauerhaft erreichbare Auslöser besitzt nun reservierten Layoutplatz statt Spielkarten oder
+  Formulare zu überdecken: seitlich auf Desktop und in einer unteren Schutzzone auf kleinen Displays.
+- Accessibility-Zugriff in die jeweilige sticky Kopfzeile neben Theme/Logout verschoben; Seiten
+  ohne Werkzeugleiste erhalten eine eigene reservierte Utility-Zeile statt eines Inhalts-Overlays.
+- Accessibility-Schaltfläche auf dieselben 38 px Außen- und 18 px Iconmaße wie die übrigen
+  Kopfzeilen-Werkzeuge vereinheitlicht.
+- SystemEscape behält seine Terminal-Typografie im Spiel, verwendet für globale Navigation und
+  Werkzeuge aber die einheitliche Mindflux-Sans-Serif-Schrift.
+- TechTacular-Kategoriekarten auf identische Höhe gesetzt und zweizeilige Titel mittig ausgerichtet.
+- Das Panel besitzt Dialogsemantik, sichtbaren Tastaturfokus, Escape-Schließen und verständliche
+  Aktivzustände; Spielzustände oder Benutzerkonten werden dabei nicht verändert.
+- **DevLab-Spielansicht nutzt große Bildschirme aus:** Die bisherige starre Begrenzung auf
+  1100 px wurde durch ein fluides, bis 2200 px breites Viewport-Layout ersetzt. Hauptbereich,
+  Seitenpanel, Abstände und Grundschrift skalieren mit der verfügbaren Bildschirmgröße.
+- Auf Mobilgeräten bleibt das Layout einspaltig und setzt die Grundschrift auf mindestens 16 px.
+
+### Sicherheit
+- **DB-Passwort aus dem Repo entfernt:** `docker-compose.yml` liest jetzt `${MINDFLUX_DB_PASSWORD}`
+  aus einem Gitea-Secret (wie die Admin-Passwörter).
+  Compose bricht bei einem fehlenden oder leeren Secret jetzt sofort mit einer eindeutigen
+  Fehlermeldung ab, statt einen App-Container mit leerem DB-Passwort zu starten.
+  Der Gitea-Runner gleicht das PostgreSQL-Passwort vor jedem Deployment automatisch mit dem
+  Secret ab; für die Rotation ist daher kein separater SSH-Zugang erforderlich.
+  **Produktionsrotation abgeschlossen am 2026-07-12:** Secret angelegt, DB-Rolle aktualisiert
+  und Mindflux über den erfolgreichen Gitea-Workflow-Lauf 43 neu gestartet (Commit `4f5042d`).
+- **Unsicherer Legacy-Endpunkt `/users/save` gelöscht** (speicherte User ohne Hashing, mit frei
+  wählbarer Rolle) inkl. `UserViewController`, `user-form.html`, `user-success.html`.
+- **Logout nur noch per POST** mit CSRF-Token (alle Templates umgestellt).
+- **Login-Brute-Force-Schutz:** Nach 5 Fehlversuchen wird der Benutzername 15 Minuten gesperrt
+  (`LoginAttemptService`, In-Memory).
+- **Registrierung gehärtet:** Passwort-Mindestlänge 8, E-Mail-Formatprüfung, case-insensitiver
+  Unique-Index auf `users.username` (Migration V9) schließt das Registrierungs-Race.
+- **Bootstrap-Admins abgesichert:** Ein Admin wird nur noch angelegt, wenn sein Passwort-Secret
+  tatsächlich gesetzt ist; fehlende optionale Admin-Konfiguration wird protokolliert und sicher
+  übersprungen.
+- Dockerfile läuft nicht mehr als root (`USER mindflux`), zweistufig mit Dependency-Cache;
+  Tests laufen im Image-Build mit. Compose-Healthcheck auf `/actuator/health` (Actuator neu).
+
+### Daten & Backend
+- **Migration V10:** `UNIQUE(lower(email))`, Fremdschlüssel von `game_scores`/`achievements`
+  auf `users(username)` mit `ON DELETE CASCADE ON UPDATE CASCADE`; verwaiste Altdaten werden
+  bereinigt, E-Mail-Dubletten aufgelöst (älteste Zeile behält die Adresse).
+- **Echte XP/Level/Streak statt Dummy-Daten:** `ProgressService` aggregiert aus `game_scores`
+  (XP = Score-Summe, 1000 XP je Level, Tages-Streak mit 1 Tag Karenz); Dashboard-Sidebar zeigt
+  echte Werte.
+- **Achievements sind live:** Katalog aus 6 Regeln (Erster Sieg, 1000er-Club, Highscore-Jäger,
+  Dauerbrenner, Punktesammler, Allrounder), Vergabe automatisch bei jedem gespeicherten Score;
+  Dummy-Daten entfernt, gesperrte Karten zeigen den Katalog.
+- **User-Logik konsolidiert:** Registrierung, REST- und Admin-Anlage laufen über einen
+  `UserService` (eine Stelle für BCrypt, Rollen-Whitelist, Eindeutigkeit);
+  `AdminUserService`/`AdminUserRepository` (Duplikate) entfernt.
+- **Globales Error-Handling:** eigene Fehlerseite (`error.html`) statt Whitelabel, JSON-Fehler
+  mit korrekten Statuscodes für alle APIs, unbekannte URLs liefern eine echte 404-Seite.
+- **N+1-Queries behoben:** TechTacular-Board lädt Kategorien/Fragen/Antworten in 2 Queries
+  (Fetch-Join), Admin-Fragenzähler als eine GROUP-BY-Query.
+- **Logging:** alle `System.out`/`printStackTrace` durch SLF4J ersetzt.
+- `spring-boot-starter-validation` + `-actuator` ergänzt, redundantes `spring-security-crypto`
+  entfernt, Java auf 21 vereinheitlicht (pom + Dockerfile).
+
+### Navigation & UI
+- **Layout-Fragmente eingeführt** (`fragments/layout.html`): App-Sidebar, Profil-Tab-Leiste und
+  Footer sind jetzt gemeinsame Fragmente (erster Schritt gegen die Template-Duplikation).
+- **Sidebar hat einen „Profil"-Eintrag**; der User-Block verlor den irreführenden Dropdown-Pfeil.
+- **Profil-Tab-Leiste auf allen Unterseiten** (Profil · Statistiken · Erfolge · Soziales ·
+  Einstellungen) mit einheitlichen Namen; Rück-Links führen einheitlich zum Dashboard.
+- **Einstellungen aufgeräumt:** Theme-Auswahl funktioniert jetzt wirklich (gekoppelt an
+  `theme.js`/localStorage); funktionslose Sprach-/Benachrichtigungs-Attrappen entfernt;
+  `SettingsController` in den `ProfileController` gemergt; Token-Farbe statt Hardcode.
+- **Spielnamen vereinheitlicht** (englisch, zusammengeschrieben): DevLab, SyntaxSaga sowie
+  SystemEscape, ServiceClash, BugHunter, NetWorker für die geplanten Spiele (Keys in
+  `KNOWN_GAMES`/`ProgressService` mit umbenannt – noch keine Scores vorhanden).
+- **DevLab erscheint jetzt auf der Statistik-Seite** (fehlte in `ProgressService.GAMES`).
+- Tote Templates entfernt: `login.html`, `register.html` (Formular lebt auf der Startseite),
+  `AppStartCheck` u. a. Kleinkram.
+
+### FinalFlux
+- **AP2-Gerüst:** neue Sidebar-Blöcke „AP2 Anwendungsentwicklung" und „AP2 Systemintegration"
+  mit den ersten Themenseiten **Entwurfsmuster** (FIAE) und **Hochverfügbarkeit** (FISI) inkl.
+  FluxChecks – FinalFlux deckt damit den Weg zur gesamten Ausbildung ab (AP1 + AP2).
+
+### Tests (neu – vorher 0)
+- 33 Tests: Score-Formel, XP/Level/Streak-Berechnung, Registrierungsregeln, Achievement-Vergabe,
+  Login-Sperre sowie `@WebMvcTest` der Security-Regeln (Login-Zwang, Admin-Schutz,
+  gelöschter Legacy-Endpunkt). Die CI baut das Image jetzt inklusive Testlauf.
+
+### Dokumentation
+- **`mindfluxfuture.md`:** konsolidierter Verbesserungs- und Ausbaukatalog mit umgesetzten,
+  bewusst zurückgestellten und künftig geplanten Punkten.
+- **`pw_anleitung.md`:** Betriebsanleitung für DB-Secret, automatische Runner-Rotation,
+  manuellen Notfallweg und Verifikation nach dem Deployment.
+
+### Zukunftsfundament & FluxTimer
+- **Plan technisch aktualisiert:** freie Flyway-Reihenfolge V11–V14, persistiertes
+  `exam_scope`-Tagging und verbindlicher S3-Anti-Cheat-Vertrag für alle neuen Spiele.
+- **Spiel-Akzentbasis:** Dark-/Light-Tokens für SystemEscape, BugHunter, ServiceClash und NetWorker.
+- **FluxTimer-MVP:** lokaler Pausentimer mit 5–240 Minuten Intervall, rotierenden Erinnerungen,
+  eigenem Text, Snooze, Probelauf, optionalem Sound und lokaler Browser-Benachrichtigung.
+  Countdown und Overlay laufen über Navigationen weiter; ein eigener Topbar-Button öffnet den
+  Schnellzugriff und die Einstellungen enthalten die vollständige Konfiguration.
+- **Dashboard-Topbar aufgeräumt:** generische Winkehand und dekorative Pulsline entfernt.
+  FluxTimer besitzt statt der Glocke jetzt ein eigenes Uhr-mit-Blitz-Icon im Zeitreise-Look;
+  die Glocke bleibt frei für spätere echte Benachrichtigungen.
+- **Login entschlackt:** das generische Schloss-Emoji aus dem Login-Button entfernt; die klare
+  Beschriftung reicht als Handlungsaufforderung und passt besser zur eigenständigen Designsprache.
+- Datenschutzerklärung um lokale Speicherung und Browser-Benachrichtigung ergänzt.
+
+### SystemEscape (interner Key `codeescape`)
+- **Variable SystemEscape-Runs:** Jedes Szenario besitzt nun acht Räume; ein Durchlauf wählt
+  serverseitig vier davon in zufälliger Reihenfolge. Der Pool wächst damit auf 24 Räume und
+  69 Rätsel, mit 1.680 möglichen geordneten Raumkombinationen je Szenario.
+- Die konkrete Raum- und Rätselauswahl wird im Server-Run festgeschrieben. Checks, Hinweise,
+  Türen, Finish, Maximalpunktzahl und Sterne akzeptieren ausschließlich IDs dieses Runs.
+- Lobby erklärt Poolgröße und Run-Länge; ein neuer Start erzeugt ausdrücklich eine neue Route.
+- **Sichtbarer Name zu SystemEscape geändert:** Der neue Name bildet Netzwerk-, Security-,
+  Hardware-, Backup- und Entwicklungsthemen besser ab. Interner Key, Route und Datenmodell
+  bleiben für bestehende Scores und Migrationen kompatibel bei `codeescape`.
+- **Spielablauf verdeutlicht und Schleusenfehler behoben:** dauerhafte Drei-Schritt-Führung
+  „Rätsel lösen → Fragmente sammeln → Türcode bilden“, nummerierte Fragmentreihenfolge,
+  optionales automatisches Einsetzen und klare Rückmeldungen bei Prüfung, Erfolg und Fehler.
+- **Produktive Türcodes repariert:** ergänzende V11.1-Datenmigration gleicht alle neun Türcodes
+  mit ihren sichtbaren Fragmenten ab. Die Lösereihenfolge der Rätsel bleibt bewusst frei.
+- Schleusen lassen sich serverseitig erst nach Abschluss aller Rätsel öffnen; ein zusätzlicher
+  Test sichert diesen Ablauf und die hilfreiche Fehlermeldung ab.
+- **Neues vollständiges Spiel:** drei Facility-Szenarien mit neun Räumen und 24 IT-Rätseln
+  von AP1 bis AP2 (FIAE/FISI/Cross), Fragment-Inventar, Türcodes, Countdown, Alarmzustand,
+  Hinweise, Reveal, Zeitbonus, Sterne, Highscore und Ergebnis-Debriefing.
+- **Serverautoritativ:** V11-Schema mit `exam_scope`, lösungsfreie Session-DTOs, serverseitig
+  protokollierte Versuche/Hinweise/Reveals/Türen und vollständige Score-Neuberechnung beim Finish.
+  Fremde oder doppelte IDs, überlange Listen und unplausible Zeiten werden abgewiesen.
+- **Vier Mechaniken:** freie Code-Eingabe, Choice, Reihenfolge und Matching; alle Lösungen bleiben
+  bis zur expliziten Auflösung auf dem Server.
+- **Eigene visuelle Welt:** dunkle Facility-/CRT-Optik, Scanlines, Terminal-Dialoge,
+  Fragment-Chips und SystemEscape-Akzent im Dashboard; responsive für mobile Ansichten.
+- **Admin-CRUD:** Szenarien, Räume und Rätsel inklusive JSON-Payload und Prüfungsbereich pflegbar.
+- Dashboard, Security-CSRF-Ausnahme, Score-/XP-/Achievement-System und Admin-Dashboard integriert.
+- Vier neue Service-Tests prüfen Lösungsfreiheit, serverseitige Hint-/Versuchsabrechnung sowie
+  Schutz vor fremden IDs und unplausiblen Laufzeiten.
+
+## [Unreleased] – 2026-06-30 · Login, Registrierung & Konten
+
+Reihe von Fixes und Verbesserungen rund um Anmeldung, Registrierung und
+Konto-Verwaltung – ausgelöst durch einen Login-Bug, bei dem ein frisch
+registriertes Konto sich nicht anmelden konnte.
+
+### Behoben
+- **Login scheiterte an Groß-/Kleinschreibung des Benutzernamens:** Die Registrierung
+  speicherte den Namen klein, der Login suchte aber **case-sensitiv** – wer sich z. B. als
+  „LostAtWonderland" registrierte, kam mit genau dieser Schreibweise nicht hinein. Das wirkte
+  wie ein Passwort-Problem, war aber der Benutzername-Abgleich (das Passwort lag korrekt
+  verschlüsselt in der DB). Login **und** Dublettenprüfung sind jetzt **case-insensitiv**
+  (`findByUsernameIgnoreCase`); Admin-Logins funktionieren unverändert in jeder Schreibweise.
+- **Profilbild wurde beim Bearbeiten im Admin genullt:** Das Benutzer-Edit-Formular sendet kein
+  `profile_picture`, wodurch ein Speichern das Bild löschte. Beim Bearbeiten bleibt das
+  bestehende Profilbild jetzt erhalten.
+- **Dev-Lab-Pfad-Icon „Debugging & Problemlösung" war leer:** Das Symbol `</>` wurde per
+  `innerHTML` als (kaputtes) HTML interpretiert statt als Text gerendert. Der Marker wird jetzt
+  escaped (`esc(p.marker)`, Cache-Buster `v4`); alle drei Trainingspfade zeigen ihr Icon
+  (`{}` · `</>` · `[]`).
+
+### Geändert / Hinzugefügt
+- **Registrierung behält die Schreibweise des Benutzernamens** (vorher klein) und trimmt nur noch.
+- **Passwort-Wiederholung bei der Registrierung:** neues Feld „Passwort wiederholen" mit Client-
+  **und** Server-Prüfung; bei Abweichung wird der Account nicht angelegt (Schutz vor Tippfehlern,
+  da die Passworteingabe verdeckt ist). Eigene Fehlermeldung, die das Signup-Panel direkt öffnet.
+- **Admin-Passwort-Reset (ohne E-Mail):** In der Benutzerverwaltung lässt sich pro Nutzer direkt
+  ein neues Passwort setzen („PW zurücksetzen"); das Bearbeiten-Formular setzt ein eingegebenes
+  Passwort ebenfalls neu (leer = unverändert). Dient als Konto-Recovery (Phase 1).
+
+### Hinweise / offen
+- **„Passwort vergessen" als E-Mail-Self-Service (Phase 2)** ist noch offen: Der Server hat aktuell
+  keinen Mailversand. Geplant über ein SMTP-Relay (z. B. Brevo/Mailjet, EU/DSGVO) bzw. ein
+  vorhandenes Postfach, sobald SMTP-Zugangsdaten vorliegen – Reset dann per zeitlich begrenztem
+  Token-Link. (Ein eigener Mailserver ist wegen Zustellbarkeit/Reputation nicht vorgesehen.)
+
 ## [Unreleased] – 2026-06-30 · Dev Lab
 
 Neues Spiel **Dev Lab**: ein Entwicklerlabor, das mehrere kleine Disziplinen bündelt

Dockerfile

@@ -3,17 +3,34 @@ FROM maven:3.9-eclipse-temurin-21 AS build
 
 WORKDIR /app
 
-COPY . .
+# Dependency-Layer cachen: erst pom.xml auflösen, dann erst den Quellcode kopieren.
+COPY pom.xml .
+RUN mvn -q dependency:go-offline
 
-RUN mvn clean package -DskipTests
+COPY src ./src
+
+# Tests laufen im Build mit – ein roter Test stoppt das Image (CI-Teststufe inklusive).
+RUN mvn -q package
 
 # ---- Runtime Stage ----
 FROM eclipse-temurin:21-jre
 
+# curl für den Container-Healthcheck (siehe docker-compose.yml)
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends curl \
+    && rm -rf /var/lib/apt/lists/*
+
 WORKDIR /app
 
+# Nicht als root laufen; Upload-Verzeichnis für den App-User beschreibbar machen.
+RUN useradd --system --home /app --shell /usr/sbin/nologin mindflux \
+    && mkdir -p /app/uploads \
+    && chown -R mindflux:mindflux /app
+
 COPY --from=build /app/target/*.jar app.jar
 
+USER mindflux
+
 EXPOSE 8080
 
 ENTRYPOINT ["java","-jar","app.jar"]

docker-compose.yml

@@ -5,10 +5,10 @@ services:
     restart: unless-stopped
 
     environment:
-      # --- Datenbank: unverändert wie im bisherigen Deploy ---
+      # --- Datenbank: Passwort kommt aus Gitea-Secret (siehe Workflow), nie ins Repo ---
       SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/mindfluxdb
       SPRING_DATASOURCE_USERNAME: mindflux
-      SPRING_DATASOURCE_PASSWORD: mindflux_pass
+      SPRING_DATASOURCE_PASSWORD: "${MINDFLUX_DB_PASSWORD:?MINDFLUX_DB_PASSWORD muss als Secret gesetzt sein}"
 
       # --- App: lauscht intern auf 8080 (nginx -> mindflux:8080) ---
       SERVER_PORT: "8080"
@@ -23,6 +23,13 @@ services:
       MINDFLUX_ADMIN2_EMAIL: "kevcipher@proton.me"
       MINDFLUX_ADMIN2_PASSWORD: "${MINDFLUX_ADMIN2_PASSWORD}"
 
+    healthcheck:
+      test: ["CMD", "curl", "-fs", "http://localhost:8080/actuator/health"]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+      start_period: 40s
+
     volumes:
       - mindflux_uploads:/app/uploads
 

mindfluxfuture.md

@@ -0,0 +1,543 @@
+# Mindflux – Detailpläne für die 4 geplanten Spiele + Verbesserungsplan
+
+## Kontext
+
+Das Dashboard von Mindflux (`mindflux2`, Spring Boot 3.4.4 / Java 17 / PostgreSQL + Flyway / Thymeleaf / Vanilla-JS) zeigt 9 Spiele. Vier davon sind nur Platzhalter-Karten, die auf `/comingsoon` (`dummy.html`) zeigen und **keinerlei Mechanik, Controller, Tabellen oder Inhalte** besitzen:
+
+1. **SystemEscape** – „Löse IT-Rätsel, sammle Zugriffsfragmente und entkomme dem System."
+2. **Service Clash** – „Der chaotische Admin-Alltag als Spiel – meistere Anfragen & halte Systeme am Laufen!"
+3. **Bug Hunter** – „Finde Fehler im Code, denke wie ein Debugger und löse knifflige Bugs."
+4. **Netzwerker – Das Router-Rätselspiel** – „Verbinde Netzwerke, konfiguriere IPs und löse Routing-Herausforderungen."
+
+Die Infrastruktur wartet bereits auf sie: Die Spiel-Keys `codeescape`, `serviceclash`, `bughunter`, `networker` stehen in der Score-Allowlist (`GameScoreController.KNOWN_GAMES`) und in `ProgressService.GAMES`; die Dashboard-Icons (`lock`, `sword`, `bug`, `network`) existieren in `dashboard.html`. Ziel dieses Plans: detaillierte, umsetzungsreife Designs für alle vier Spiele nach dem etablierten Architektur-Rezept der vorhandenen Spiele (MindMatch, TechTacular, SyntaxSaga, DevLab) sowie ein priorisierter Verbesserungs-/Optimierungskatalog für den Rest der Plattform.
+
+**Zielgruppe & inhaltlicher Anspruch: die GESAMTE Fachinformatiker-Ausbildung.** Nicht nur AP1 – abgedeckt werden muss die komplette Ausbildung bis einschließlich **AP2** (beide Fachrichtungen: Anwendungsentwicklung/FIAE und Systemintegration/FISI). Konsequenzen für alle Spiele und Inhalte:
+
+- **Schwierigkeitsstufen = Ausbildungsprogression.** Die in allen vier Designs vorhandenen Stufen (Junior/Senior/Principal, leicht/mittel/schwer, Welten 1–3, Schicht 1–3) werden inhaltlich gemappt: untere Stufen ≈ 1. Lehrjahr/AP1-Stoff, obere Stufen ≈ AP2-Niveau. Kein Schema-Umbau nötig – die `difficulty`-Felder existieren in allen Datenmodellen bereits; es ist eine **Content-Kuratierungs-Regel**.
+- **AP2-Content pro Spiel (Startrichtung):** SystemEscape → Szenarien zu Verschlüsselung/Zertifikaten, Virtualisierung/Container, Backup-Strategien; BugHunter → Principal-Fälle auf FIAE-AP2-Niveau (Nebenläufigkeit/Threads, Transaktions-/SQL-Fehler, Design-Pattern-Missbrauch, OWASP-Lücken); ServiceClash → Schichten mit Change-Management, Monitoring/Eskalationsketten, Security-Incidents (FISI-AP2); NetWorker → Welten zu VLAN, statischem Routing über mehrere Hops, Firewall-Regeln und (Ausbau) IPv6/Subnetting-Transfer.
+- **Content-Tagging:** Neue Parent-Inhalte erhalten von Anfang an ein persistiertes Feld `exam_scope VARCHAR(20) NOT NULL DEFAULT 'AP1'` mit der Allowlist `AP1 | AP2_FIAE | AP2_FISI | CROSS`. Seeder und Admin validieren dieses Feld; Katalog-DTOs geben es aus. Titelpräfixe sind nur Anzeige, nie Datenquelle. Lobby-Filter können dadurch später ohne Migration ergänzt werden.
+- **FinalFlux erweitern:** Das bestehende Lernmodul ist rein AP1-fokussiert (28 Seiten + FluxChecks). Die Struktur (statische Themenseiten + Frage-JSONs) trägt problemlos einen **AP2-Ast** – als eigener Sidebar-Block „AP2 Anwendungsentwicklung" / „AP2 Systemintegration" (in Teil 2 als Punkt S10 aufgenommen).
+- Die vorhandenen FinalFlux-Inhalte (IP-Berechnung, VLAN, OSI, Wirtschaft) bleiben die AP1-Basis, auf der die Spiele aufsetzen.
+
+**Deliverable:** Dieser Plan liegt als `mindflux2/mindfluxfuture.md` im Repo (neben `STYLEGUIDE.md`/`CHANGELOG.md`).
+
+---
+
+## Namensschema: einheitlich, englisch, zusammengeschrieben
+
+> ✅ **Umgesetzt am 2026-07-12**: Anzeigenamen und Spiel-Keys sind auf das Schema umgestellt (Dashboard-`GAMES`-Array, `KNOWN_GAMES`, `ProgressService`).
+
+Vorgabe: Alle Spielnamen folgen dem MindMatch-Muster – **ein Wort, englisch, CamelCase**. „Netzwerker – Das Router-Rätselspiel" passt nicht ins Schema und wird umbenannt. Neue Namenstabelle (Beschreibungen bleiben deutsch):
+
+| Bisher | Neu (Anzeigename) | Route | Spiel-Key (DB/API) |
+|--------|-------------------|-------|--------------------|
+| MindMatch | **MindMatch** ✓ | `/mindmatch` | `mindmatch` |
+| TechTacular | **TechTacular** ✓ | `/techtacular` | `techtacular` |
+| Dev Lab | **DevLab** | `/devlab` | `devlab` |
+| Syntax Saga | **SyntaxSaga** | `/syntaxsaga` | `syntax-saga` (Key behalten – es existieren bereits Scores) |
+| FinalFlux | **FinalFlux** ✓ | `/finalflux` | – |
+| SystemEscape | **SystemEscape** | `/codeescape` | `codeescape` |
+| Service Clash | **ServiceClash** | `/serviceclash` | `serviceclash` |
+| Bug Hunter | **BugHunter** | `/bughunter` | `bughunter` |
+| Netzwerker – Das Router-Rätselspiel | **NetWorker** | `/networker` | `networker` |
+
+Begründung Keys: Die vorhandenen Routen sind alle klein und zusammengeschrieben (`/mindmatch`, `/syntaxsaga` …) – die neuen Routen folgen dem. Die historischen Plan-Aliasse `escape-room`, `service-clash`, `bug-hunter` und `netzwerker` hatten noch keine Scores und wurden deshalb vor der Implementierung auf `codeescape`, `serviceclash`, `bughunter` und `networker` vereinheitlicht. Nur `syntax-saga` behält seinen Key wegen möglicher Bestandsdaten. Die Tabelle und der Abschnitt „Gemeinsames Architektur-Rezept" sind die verbindliche Quelle; verbliebene Altbegriffe in erklärenden Designpassagen sind keine Routen- oder Schema-Vorgaben.
+
+---
+
+## Visuelle Identität: vier Spiele, vier Welten
+
+> ◐ **Fundament umgesetzt:** Die Dark-/Light-Akzent-Tokens für alle vier Spiele sind in
+> `theme.css` angelegt. Offen bleiben die konkreten Karten-Designs, Spiel-Layouts, Illustrationen
+> und Animationen; diese entstehen jeweils zusammen mit dem betreffenden Spiel.
+
+Vorgabe: Die Spiele sollen **grafisch stark ausgeprägt** sein und sich **sehr deutlich** voneinander unterscheiden – nicht nur mechanisch, sondern auf den ersten Blick. Dazu zwei Maßnahmen:
+
+**1. Kontrollierte Styleguide-Erweiterung – Spiel-Akzente:** `theme.css` bekommt pro Spiel ein Akzent-Token-Paar (z. B. `--esc-accent`, `--bh-accent`, `--sc-accent`, `--nw-accent`, je mit Dark-/Light-Wert). Jedes Spiel-CSS überschreibt im Seiten-Root lokal `--accent`/`--glow-*` mit seinem Spiel-Akzent. Die Grundregeln bleiben: Erfolg = blaues ✓, Fehler = rotes ✗, nie grün als Erfolgsfarbe; beide Themes müssen funktionieren.
+
+**2. Eigenes visuelles Vokabular pro Spiel** (Layout, Illustration, Animation, Typografie-Akzente):
+
+| Spiel | Welt-Metapher | Farbstimmung | Prägende visuelle Elemente |
+|-------|---------------|--------------|---------------------------|
+| **SystemEscape** | Dunkle Facility bei Nacht | Bernstein/Orange auf Tiefschwarz | CRT-Terminals mit Scanline-Overlay, physisches Keypad mit Tasten-Feedback, Raum-„Bühnenbild" als SVG-Illustration (Racks, Türen, flackernde Neonröhre), Fragment-Chips wie Hardware-Token, Alarm-Puls bei Zeitablauf, Tür-Öffnungs-Animation zwischen Räumen |
+| **BugHunter** | Noir-Detektivbüro | Entsättigt + Crimson-Akzente | Fallakten-Optik (Aktendeckel, Büroklammer, „VERTRAULICH"-Stempel), IDE-Look mit Zeilennummern-Gutter und Tab-Reitern, roter Ermittlungsfaden zum markierten Bug, „GELÖST"-Stempel-Animation im Debriefing, Schreibmaschinen-Typo für Briefings |
+| **ServiceClash** | Hektischer Leitstand/Cockpit | Kühles Cyan + Warnrot | Kanban-artige Ticket-Queue mit einfliegenden Karten, große SLA-Ring-Gauges und Gesundheits-Meter, laufender Event-Ticker unten, Wellen-Countdown-Banner, komisch überzeichnete Ticket-Icons (brennender Drucker 🔥), Screen-Shake bei Major Incidents |
+| **NetWorker** | Technische Blaupause | Blueprint-Blau auf Millimeterpapier | Raster-Hintergrund wie Konstruktionszeichnung, Geräte als Schematic-Glyphen, Gummiband-Kabelzug, leuchtende Paket-Punkte, die den echten Trace entlangfliegen und am Fehler-Hop rot zerplatzen, Diagnose-Callouts wie Plan-Anmerkungen |
+
+Dazu je Spiel ein eigenes Karten-Design auf dem Dashboard (Hover-Animation im jeweiligen Spiel-Akzent), damit die Unterscheidbarkeit schon in der Übersicht beginnt. Die Interaktionsformen sind ohnehin grundverschieden: Modal-Rätsel + Keypad (SystemEscape), klickbarer Code-Viewer (BugHunter), Echtzeit-Queue (ServiceClash), frei bespielbare SVG-Canvas (NetWorker).
+
+---
+
+## Das gemeinsame Architektur-Rezept (gilt für alle 4 Spiele)
+
+Jedes neue Spiel folgt exakt dem Muster der vorhandenen Spiele (bester Bauplan: **Dev Lab**, `DevLabService.java` + `devlabgame.js`):
+
+1. **Flyway-Migration** ab `db/migration/V11__…` (V9/V10 sind durch User-/Datenintegrität belegt; `ddl-auto=validate` ⇒ Migration ist Pflicht). Reserviert: V11 SystemEscape (interner Key `codeescape`), V12 BugHunter, V13 NetWorker, V14 ServiceClash; danach FluxNet. SQL-Stil: `BIGINT GENERATED BY DEFAULT AS IDENTITY`, `slug VARCHAR UNIQUE`, `exam_scope VARCHAR(20)`, `sort_order INT DEFAULT 0`, `active BOOLEAN DEFAULT TRUE`, `FK … ON DELETE CASCADE`, Indizes.
+2. **Entities** in `model/` (Parent mit `@OneToMany(cascade=ALL, orphanRemoval=true)`, Lösungs-Logik nur serverseitig auf der Entity).
+3. **Repository** in `repository/` (`findAllByActiveTrueOrderBySortOrderAscIdAsc()`, `findBySlug`, `countBy…Id`).
+4. **Service** in `service/` mit Konstante `GAME = "<key>"`, injiziert `GameScoreService`; `@Transactional(readOnly=true)` für Build/Check, `@Transactional` für `finish`. **Score wird ausschließlich serverseitig berechnet** (`gameScoreService.recordScore(user, GAME, deck, score, moves, seconds)`); Client sendet nur Roh-Antworten.
+5. **Punkte-Konventionen der Plattform:** 1. Versuch volle Punkte, 2. Versuch ×0.6, danach ×0.3, aufgedeckte Lösung = 0; Sterne: Quote ≥0.8 → 3, ≥0.5 → 2, sonst 1; `MAX_ATTEMPTS = 3`.
+6. **DTOs** in `dto/`: lösungsfreie View-DTOs, Request-DTOs, `*Result` (score, maxScore, solved, total, stars, highscore, newHighscore, plays).
+7. **Controller:** `@Controller` (`GET /<spiel>` → Thymeleaf-View) + `@RestController @RequestMapping("/api/<spiel>")` mit `GET /session|board`, `POST /check` (mit `reveal`-Flag), `POST /finish`; `Principal` für den Usernamen.
+8. **Seeder** (`CommandLineRunner` in `config/`, Guard `count() > 0`, liest `resources/<spiel>/content.json`).
+9. **Admin-CRUD** `@Controller @RequestMapping("/admin/<spiel>")` mit Redirect-after-Post + Karte in `templates/admin/dashboard.html`.
+10. **Frontend:** Template in `templates/`, eigenes CSS mit eindeutigem Präfix (nur `theme.css`-Tokens, Erfolg = blaues ✓, Fehler = rotes ✗, **nie grün**), JS als IIFE in `static/js/`, Highscore via `GET /api/games/<key>/stats`, Cache-Busting `?v=N`.
+11. **Integration:** Route in `SecurityConfig`-CSRF-Ignore-Liste aufnehmen, Dashboard-Karte in `dashboard.html` von `/comingsoon` auf die echte Route umstellen. (`KNOWN_GAMES` + `ProgressService` enthalten die Keys bereits.)
+
+### Verbindlicher Sicherheitsvertrag für neue Spiele (S3)
+
+1. Session-/Katalogantworten enthalten nur opaque IDs und lösungsfreie DTOs; Lösung, Reveal-Status und Scoring-Metadaten bleiben serverseitig.
+2. `finish` akzeptiert nur IDs aus der angeforderten Runde und verwirft fremde, doppelte oder nicht zum Parent gehörende IDs.
+3. Punkte, Sterne, Highscore, gelöste Anzahl und Boni werden ausschließlich serverseitig aus kanonischen Daten neu berechnet.
+4. `durationSeconds` muss plausibel sein (`>= 1` und höchstens das konfigurierte Limit plus dokumentierte Toleranz); Listen und Zähler erhalten fachliche Obergrenzen.
+5. Reveal-/Hint-Nutzung wird serverseitig protokolliert oder beim Finish erneut validiert und kann nicht durch Weglassen im Request verborgen werden.
+6. Deterministische Seeds werden spätestens bei ServiceClash mit einem serverseitigen HMAC signiert; der Client darf keinen frei wählbaren Seed zur Wertung einreichen.
+7. Für jedes Spiel entstehen Negativtests: fremde IDs, Duplikate, überlange Listen, unmögliche Zeiten, manipulierte gesperrte Felder und Reveal-vor-Finish.
+
+---
+
+## Teil 1: Spieldesigns
+
+### Plattformweite Barrierefreiheit ✅ Grundwidget umgesetzt
+
+- Globales, per Tastatur erreichbares Accessibility-Panel über einen schwebenden Rollstuhl-Button.
+- Schriftgröße in vier nachvollziehbaren Stufen (100 %, 115 %, 130 %, 150 %), lokal gespeichert
+  und auf Dashboard, Lernseiten sowie allen Spielen identisch angewendet.
+- Enthalten: erhöhter Kontrast, farbenblindfreundliches Statusfarbprofil, Monochrommodus,
+  Lesemodus für Dyslexie mit Verdana und angepassten Abständen, unterstrichene Links, reduzierte Bewegungen, großer
+  Cursor, gut sichtbare Fokusmarkierungen und zentraler Reset.
+- Noch offen bleibt die systematische Prüfung aller Spielmechaniken auf vollständige
+  Tastaturbedienbarkeit sowie ein WCAG-Audit mit Kontrastmessung und Screenreader-Tests.
+- Layouts dürfen bei Textvergrößerung weder Inhalte abschneiden noch horizontales Scrollen der
+  gesamten Seite erzwingen; Codebereiche dürfen weiterhin gezielt horizontal scrollen.
+- Das Panel ergänzt semantisches HTML und WCAG-Prüfungen, ersetzt diese aber nicht.
+
+### Spiel 1: SystemEscape (interner Key: `codeescape`, Migration V11 + Datenfix V11.1) ✅ MVP inklusive Spielführung umgesetzt
+
+**Konzept:** Der Spieler ist in einer digitalen Umgebung eingesperrt (Serverraum, Admin-Büro, Rechenzentrum). Ein **Szenario** besitzt einen Pool aus 8 Räumen; jeder Run zieht daraus 4 Räume in zufälliger Reihenfolge. Jeder Raum enthält 2–3 IT-Rätsel plus ein **Tür-Keypad**. Jedes gelöste Rätsel liefert ein **Code-Fragment**; die Fragmente ergeben zusammen den Türcode zum nächsten Raum. Countdown erzeugt Zeitdruck; ein 2-stufiges Hinweis-System tauscht Punkte gegen Hilfe.
+
+**Lernziele (AP1 → AP2):** Zahlensysteme (Bin/Hex/Dez), Ports & Protokolle, Subnetting, TCP-Handshake/Boot-Reihenfolgen, RAID, Hardware, SQL/Shell-Grundlagen – als Rätsel verpackt statt als Quiz. Schwere Szenarien tragen AP2-Stoff (Verschlüsselung/Zertifikate, Virtualisierung/Container, Backup-Strategien).
+
+**Spielablauf:**
+1. **Lobby:** Szenario-Karten (Titel, Thema, Schwierigkeit, Zeitlimit, persönliche Bestzeit).
+2. **Raum-Ansicht:** Rätsel-Karten im Terminal-Look, Fragment-Inventar, Tür-Keypad. Rätsel öffnen sich im Modal.
+3. **Rätsel-Versuch:** `MAX_ATTEMPTS = 3` wie Dev Lab; danach „Auflösen"-Button. Bei richtig **oder** aufgedeckt liefert der Server das Code-Fragment – Aufdecken blockiert nie den Fortschritt, es nullt nur die Punkte (Plattform-Konvention).
+4. **Tür:** Spieler tippt den zusammengesetzten Code; Server validiert (`POST /door`). Falsch → rotes Blinken, keine Punktstrafe (die laufende Uhr ist die Strafe).
+5. **Flucht/Ergebnis:** `POST /finish` rechnet alles serverseitig nach; Ergebnis-Screen mit Score-Aufschlüsselung (Rätselpunkte, Türboni, Hinweis-Abzug, Zeitbonus), Sternen, Highscore. „Aufgeben"-Button beendet früher (kein Zeitbonus, `escaped=false`).
+
+**Punkteformel (serverseitig in `/finish` nachgerechnet):**
+- Pro Rätsel: `punkte × versuchsfaktor × hinweisfaktor` (Versuch: 1.0/0.6/0.3, aufgedeckt 0; Hinweis: keiner ×1.0, Stufe 1 ×0.8, Stufe 2 ×0.6). Hinweis-Nutzung wird **serverseitig in der HttpSession** protokolliert (der `/hint`-Endpoint merkt sich die höchste gelieferte Stufe pro Rätsel) – der Client kann sie nicht unterschlagen. _(Einzige bewusste Abweichung vom sonst zustandslosen Muster.)_
+- Pro geöffneter Tür: pauschal **+50**.
+- Sterne aus `baseScore/maxScore` (≥0.8→3, ≥0.5→2). **Zeitbonus danach**, nur bei Flucht: `max(0, round(500 × (zeitlimit − sekunden) / zeitlimit))` – die MindMatch-Idee, auf 15-Minuten-Läufe skaliert. Timer auf 0 bricht nicht ab: HUD wechselt in „ALARM"-Zustand (pulsierendes `var(--danger)`), der Bonus ist nur weg.
+- `recordScore(user, "codeescape", szenarioSlug, baseScore + zeitbonus, gelösteRätsel, sekunden)`.
+
+**Datenmodell (`V11__codeescape.sql`):** 3 Tabellen im V8-Stil:
+- `escape_scenarios` (id, slug UNIQUE, title, difficulty, description, time_limit_seconds INT DEFAULT 900, sort_order, active)
+- `escape_rooms` (id, scenario_id FK CASCADE, title, intro, door_prompt, **door_code VARCHAR(50)**, success_text, sort_order)
+- `escape_puzzles` (id, room_id FK CASCADE, puzzle_type VARCHAR(30), prompt, points INT DEFAULT 100, **code_fragment VARCHAR(20)**, sort_order, payload VARCHAR(8000))
+- Indizes auf beide FKs. `code_fragment`/`door_code` als Spalten (nicht im Payload), damit Check/Door sie ohne JSON-Parsing haben und der Admin sie auf einen Blick sieht. Hinweise liegen im Payload als `"hints": [...]`.
+
+**Backend:** Entities `EscapeScenario`/`EscapeRoom`/`EscapePuzzle` (Struktur wie `DevLabGame`/`DevLabTask`, LAZY, `addRoom`/`addPuzzle`-Helper). Repositories mit den Standard-Derived-Queries. `EscapeRoomService` mit `KNOWN_TYPES = Set.of("code","choice","order","match")`:
+- `buildCatalog()` / `buildSession(slug)` – Szenario mit **allen** Räumen, Rätsel per `sanitize()` lösungsfrei (keine Lösungen, Fragmente, Hints, Türcodes). Raum-Sperre ist Client-Gate, abgesichert durch Server-Türvalidierung.
+- `check(puzzleId, reveal, submission)` – Typ `code`: neuer trivialer Checker via `anyEquals(payload.solutions, answer, caseSensitive)`; **`choice`/`order`/`match`: Checker 1:1 aus `DevLabService` kopieren.** Bei `correct || reveal` kommt `"fragment"` in die Antwort.
+- `openDoor(roomId, code)`, `hint(session, puzzleId, level)`, `finish(...)` wie oben; plus Admin-Methoden nach Dev-Lab-Vorbild.
+
+**API (`/api/codeescape`):** `GET /scenarios`, `GET /session/{slug}`, `POST /check` (`{puzzleId, reveal, submission:{answer}}` → `{correct, fragment, successText}`), `POST /door` (`{roomId, code}` → `{open, successText}`), `POST /hint` (`{puzzleId, level}` → `{text, level}`), `POST /finish` (`{slug, durationSeconds, escaped, items:[{puzzleId, submission, attempts, revealed}], doors:[{roomId, code}]}` → `{score, baseScore, maxScore, timeBonus, solvedPuzzles, roomsOpened, escaped, stars, highscore, newHighscore, plays}`).
+
+**Frontend:** `templates/escape-room.html`, `static/js/escaperoom.js` (IIFE-State-Machine `LOBBY → INTRO → ROOM(i) → PUZZLE_MODAL → DOOR_TRY → TRANSITION → … → RESULT`), `static/css/escaperoom.css` mit Präfix `esc-`. **Die `choice`/`order`/`match`-Renderer aus `devlabgame.js` (Vertrag `{render, collect, lock, mark}`) portieren**, nur ein `code`-Renderer (Terminal-Artefakt + Textfeld) kommt neu dazu. Layout: HUD oben (Raumtitel, Raum-Punkte ● ● ○, Timer-Chip), Mitte Rätselkarten, unten Fragment-Chips + Keypad-Button. Nur Theme-Tokens, Erfolg blau ✓, Fehler rot ✗.
+
+**Content & Seeder:** `EscapeRoomSeeder` liest `resources/escaperoom/content.json`. Startumfang: **3 Szenarien** (leicht/mittel/schwer) × 3 Räume × 2–3 Rätsel ≈ 22–25 Rätsel. Themen: „Der verlassene Serverraum" (Netzwerk/Zahlensysteme), „Lockdown im Rechenzentrum" (Hardware/RAID/USV), „Das gehackte Büro" (Security/Passwörter/Verschlüsselung). Beispiel-Rätsel (ausgearbeitet im Design): PIN = Dezimalwert von `0b101001` → „41", SSH-Port-Choice, Dienst↔Port-Matching (Türcode „427"), TCP-Handshake-Reihenfolge, nutzbare Hosts im /26-Netz → „62" (Tresorcode „3E62").
+
+**Admin:** `AdminEscapeRoomController` (`/admin/escape-room`), 3 Drilldown-Templates (Szenario-Liste → Szenario mit Räumen → Raum mit Rätseln; Rätsel-Payload als JSON-Textarea wie Dev Lab).
+
+**Aufwand:** MVP ≈ 5,5 PT (Migration/Entities 0,5 · Service 1,5 · API 0,5 · Frontend 2 · Content 0,5 · Admin+Integration 0,5). Ausbau 1 (+1,5 PT): Bestzeiten in der Lobby, „Perfekter Lauf"-Badge. Ausbau 2 (+1–2 PT): Rätseltypen `regex`/`cloze` (Checker existieren wortgleich in `DevLabService`), 2 weitere Szenarien.
+
+---
+
+### Spiel 2: BugHunter (Key: `bughunter`, Migration V12)
+
+**Konzept:** Der Spieler ist Debugging-Detektiv und arbeitet **Fallakten** ab. Ein Fall („Hunt") ist ein Mini-Projekt aus 2–4 Dateien, das sich falsch verhält; Beweismittel sind simulierte Konsolen-Ausgabe / Stacktrace / Ticket-Text. Pro Bug eine Drei-Phasen-Schleife: **ORTEN** (fehlerhafte Zeile im Tab-Code-Viewer anklicken) → **KLASSIFIZIEREN** (Syntax / Logik / Laufzeit / Sicherheit) → **FIXEN** (korrigierte Zeile aus 4 Kandidaten wählen). Saubere Bugs bauen eine **Combo-Serie** auf. Stufen: Junior / Senior / Principal.
+
+**Abgrenzung zu Dev Lab:** Dev Labs `spot`-Typ ist „finde die eine falsche Zeile". Bug Hunter ist bewusst reicher: Multi-Datei-Navigation, beweisgetriebenes Denken (Stacktrace lesen → Zeile zuordnen), explizite Fehler-Taxonomie (Prüfungsthema!) und Fix-Auswahl – das vollständige Debugging-Denkmodell. Junior-Fälle decken AP1-Stoff ab; Senior/Principal-Fälle gehen auf FIAE-AP2-Niveau (Nebenläufigkeit/Threads, Transaktions-/SQL-Fehler, Design-Pattern-Missbrauch, OWASP-Sicherheitslücken).
+
+**Punkteformel (serverseitig in `/finish`):**
+- Phasengewichte pro Bug: Orten 40 %, Klassifizieren 20 %, Fixen 40 %. Phasen-Award = `gewicht × punkte × versuchsfaktor` (1.0/0.6/0.3, aufgedeckt 0).
+- Sterne aus `baseScore/maxScore` (Genauigkeitsmaß, ohne Combo).
+- **Combo:** Ein Bug ist _sauber_, wenn alle 3 Phasen im 1. Versuch ohne Aufdecken gelingen. Serienposition n bringt `(min(n,4) − 1) × 10 % × punkte` Bonus (2. saubere in Folge +10 %, … 4.+ +30 %); Bonus wird **nach** der Sternberechnung addiert. Kein Timer – Bug Hunter belohnt Präzision, Zeitdruck gehört dem Escape Room.
+- Basispunkte pro Bug nach Stufe: Junior 100, Senior 150, Principal 200. `recordScore(user, "bughunter", huntSlug, baseScore + comboBonus, gelösteBugs, sekunden)`.
+
+**Datenmodell (`V12__bughunter.sql`):**
+- `bughunter_hunts` (id, slug UNIQUE, title, code_language, difficulty DEFAULT 'junior', description, briefing VARCHAR(2000), console_output VARCHAR(4000), sort_order, active)
+- `bughunter_files` (id, hunt_id FK CASCADE, filename, content VARCHAR(8000), sort_order) – eigene Tabelle, damit der Code-Viewer-Inhalt von allen Bugs geteilt wird und im Admin als Textarea editierbar ist
+- `bughunter_bugs` (id, hunt_id FK CASCADE, points DEFAULT 100, sort_order, payload VARCHAR(8000)) – Payload: `{"file","line","category","evidence","fixOptions":[4],"fixIndex","explanation"}`
+- Indizes auf beide FKs.
+
+**Backend:** Entities/Repos nach Dev-Lab-Muster. `BugHunterService` mit `CATEGORIES = Set.of("syntax","logik","laufzeit","sicherheit")`, Gewichten `0.4/0.2/0.4`:
+- `buildSession(slug)`: Briefing + `consoleOutput` + Dateien als `[{filename, lines:[…]}]` (**serverseitig in Zeilen gesplittet**, damit Zeilenindizes kanonisch sind) + Bugs sanitisiert: nur `{bugId, points, evidence}` – **keine Zeile, keine Kategorie, keine Fix-Optionen**.
+- `checkPhase(bugId, phase, reveal, submission)`: `locate` vergleicht file+line, liefert bei Erfolg/Aufdecken `location` zurück; `classify` vergleicht die Kategorie und liefert bei Auflösung erst die **gemischten `fixOptions`** (Phasen-Gate: der Fix-Text würde sonst die Position verraten); `fix` prüft die Wahl (Logik = Dev Labs `checkChoice`) und liefert `fixedLine` + `explanation` fürs Debriefing.
+- `finish(...)`: prüft alle Phasen aus den Roh-Antworten neu, Gewichte + Versuchsfaktoren, Streak/Combo, Sterne, `recordScore`.
+
+**API (`/api/bughunter`):** `GET /hunts`, `GET /session/{slug}`, `POST /check` (`{bugId, phase, reveal, submission}`), `POST /finish` (`{slug, durationSeconds, items:[{bugId, locate:{file,line,attempts,revealed}, classify:{category,…}, fix:{choice,…}}]}` → `{score, baseScore, maxScore, comboBonus, maxCombo, bugsSolved, totalBugs, stars, highscore, newHighscore, plays}`).
+
+**Frontend:** `templates/bug-hunter.html`, `static/js/bughunter.js` (State-Machine `LOBBY → BRIEFING → HUNT {pro Bug: LOCATE → CLASSIFY → FIX → DEBRIEF} → RESULT`), `static/css/bughunter.css` Präfix `bh-`. Layout: **links 60 %** Datei-Tabs + Monospace-Code-Viewer mit Zeilennummern-Gutter (Zeilenklick nur in LOCATE aktiv); **rechts 40 %** Beweis-Karte (Terminal-Style `consoleOutput`, Briefing, Bug-Hinweis), Aktions-Panel (wechselt pro Phase; Kategorie-/Fix-Buttons nutzen das `choice`-Renderer-Muster aus `devlabgame.js`), Combo-Chip + Fortschritt („Bug 2/3"). Debriefing tauscht die Bug-Zeile sichtbar gegen `fixedLine` (blaues Diff-Highlight).
+
+**Content & Seeder:** `BugHunterSeeder` liest `resources/bughunter/content.json`; der komplette Bug-Knoten wird wie bei `DevLabSeeder` per `toString()` zum Payload. Startumfang: **6 Fälle** – 3 Junior (1 Datei, 1–2 Bugs: Off-by-one, `=` vs. `==`, fehlendes `break`), 2 Senior (2 Dateien: NPE via Stacktrace, SQL-Injection, Integer-Division), 1 Principal (3 Dateien, Symptom in Datei A, Ursache in Datei B) ≈ 13–15 Bugs. Drei Beispiel-Fälle sind im Design voll ausgearbeitet („Fall #1: Die falsche Rechnung" – Off-by-one in Java; „Fall #2: Das offene Login" – SQL-Injection in PHP; „Fall #3: Der Absturz um Mitternacht" – NPE mit Stacktrace-Lesen), inkl. Code, Fix-Optionen und Erklärungen.
+
+**Admin:** `AdminBugHunterController` (`/admin/bug-hunter`), 2 Templates (Fall-Liste + Fall-Detail mit Datei-Textareas und Bug-Payload-JSON). Service validiert beim Speichern, dass `file` im Fall existiert und `line` im Zeilenbereich liegt.
+
+**Aufwand:** MVP ≈ 4,5 PT. Ausbau 1 (+1 PT): Freitext-Fix statt Optionen (`anyEquals` mit Whitespace-Normalisierung wie Dev-Lab-`cloze`), „Sauber gelöst"-Badge. Ausbau 2 (+1 PT): „Blitzjagd"-Tagesmodus (3 zufällige Junior-Bugs, 90-s-Soft-Timer).
+
+---
+
+### Spiel 3: ServiceClash (Key: `serviceclash`, Migration V14)
+
+**Konzept: „Deine Schicht am Service Desk."** Der Spieler ist Junior-Admin im First-Level-Support. Tickets treffen auf einer Zeitleiste ein; jedes muss **eingeordnet** (Incident vs. Service Request), **priorisiert** (Hoch/Mittel/Niedrig anhand von Impact-×-Dringlichkeit-Hinweisen im Tickettext) und **gelöst** werden (richtige Erstmaßnahme aus 3–4 Optionen) – bevor sein SLA-Timer abläuft. Unbehandelte Tickets beschädigen die „Systemgesundheit"; bei 0 endet die Schicht vorzeitig.
+
+**Lernziele (AP1 → AP2):** Incident-/Service-Request-Klassifikation (ITIL-light, explizites IHK-Thema), Prioritätsbewertung, korrekte Erstmaßnahmen (Troubleshooting-Reihenfolge, Eskalationsdisziplin, Phishing erkennen statt „lösen"). Höhere Schichten bringen FISI-AP2-Stoff: Change Management, Monitoring-/Eskalationsketten, Security-Incident-Behandlung, Backup-/Restore-Entscheidungen.
+
+**Spielablauf:** Eine **Schicht** = ein Level mit 3 Wellen (Vormittag/Mittag/Nachmittag), je 60–90 Echtzeit-Sekunden mit steigender Spawn-Rate; Gesamtspielzeit 3–5 Minuten, zwischen Wellen 5 s Verschnaufpause. Pro Ticket im Detail-Panel:
+1. **Einordnung** [Incident]/[Service Request] – Single-Shot, falsch = 0 Punkte für diesen Anteil, richtige Antwort wird sofort gezeigt (Lerneffekt). 20 % der Ticket-Basispunkte.
+2. **Priorität** [Hoch]/[Mittel]/[Niedrig] – Single-Shot. 30 %.
+3. **Lösung** – 3–4 Aktionen (servergemischt), Plattform-Versuchsleiter 1.0/0.6/0.3; nach dem 3. Fehlgriff Auflösung + Erklärung, Ticket zählt als „eskaliert" (0 für diesen Anteil). 50 %.
+
+**SLA & Gesundheit:** `slaSeconds` je Priorität. In SLA gelöst → ×1.0, verspätet → ×0.5, nie gelöst → 0 + Gesundheitsschaden. Start 100; SLA-Bruch −10 (Hoch: −20), ungelöst am Schichtende −15. Endbonus: `gesundheit × 2` (max. 200).
+
+**Punkteformel (nur serverseitig):**
+```
+ticketPunkte = B × (0.2·einordnungOk + 0.3·prioOk + 0.5·lösungsLeiter) × slaFaktor
+score        = Σ ticketPunkte + gesundheit×2      (B: Routine 60, Standard 100, Major Incident 150)
+maxScore     = Σ B + 200 ;  Sterne nach Plattform-Konvention
+```
+
+**Der Server-autoritäts-Trick für Echtzeit (Kernidee):** Runden bleiben zustandslos –
+- `GET /session/{slug}`: Server zieht einen **Seed**, generiert daraus deterministisch den Schichtplan (Ticket-Auswahl aus dem Pool, Spawn-Zeitpunkte, Options-Mischung; Payloads sanitisiert ohne Lösungsfelder) und liefert Plan + Seed.
+- Jeder Klick geht an `POST /check` (sofortiges ✓/✗-Feedback; Lösungen verlassen den Server nie).
+- `POST /finish` sendet `{slug, seed, decisions[], durationSeconds}`; der Server **regeneriert die Schicht aus dem Seed und re-simuliert das Entscheidungslog** (Plausibilitätschecks: Zeitstempel ≥ Spawn-Offset, ≤ Schichtdauer, monoton pro Ticket) und berechnet Gesundheit, SLA-Faktoren und Score neu. Härtungs-Ausbau: HMAC-signierter Seed.
+
+**Datenmodell (`V14__serviceclash.sql`):**
+- `service_clash_shifts` (id, slug UNIQUE, title, description, difficulty INT, wave_count INT DEFAULT 3, wave_seconds INT DEFAULT 60, spawn_count INT DEFAULT 12, settings VARCHAR(4000) /* JSON: SLA-Defaults, Health-Regeln, Prio-Stufe an/aus */, sort_order, active)
+- `service_clash_tickets` (id, shift_id FK CASCADE, wave INT, base_points INT DEFAULT 100, sort_order, payload VARCHAR(8000)) + FK-Index
+- Ticket-Payload: `{title, requester, text, kind (normal|phishing), options[], correctIndex✂, category✂, priority✂, slaSeconds, explanation✂, successText}` (✂ = wird von `sanitize()` entfernt).
+
+**Backend:** Entities `ServiceClashShift`/`ServiceClashTicket`, Standard-Repos (`findAllByShiftIdOrderByWaveAscSortOrderAscIdAsc`, `countByShiftId`). `ServiceClashService`: `buildCatalog()`, `buildSession(slug)` (Seed + `generatePlan()`), `check(templateId, step, value, reveal)` mit `step ∈ classify|priority|solve` (Vergleich immer über Options-**Text**, nie Indizes – immun gegen Mischungs-Versatz), `finish(...)` (Plan aus Seed regenerieren, Log re-simulieren, `recordScore(user, "service-clash", slug, score, gelöste, sekunden)`), Admin-Methoden nach Dev-Lab-Vorbild.
+
+**API (`/api/serviceclash`):** `GET /catalog`, `GET /session/{slug}` (liefert `seed`, Wellen-Konfiguration, Ticket-Instanzen `{instanceId, templateId, wave, spawnAtMs, …}`), `POST /check`, `POST /finish` → `{score, maxScore, stars, resolved, total, slaBreaches, health, highscore, newHighscore, plays, tickets[Debrief-Aufschlüsselung]}`.
+
+**Frontend:** `templates/service-clash.html`, `static/js/serviceclash.js` (State-Machine `SHIFT_SELECT → BRIEFING → RUNNING ⇄ WAVE_BREAK → DEBRIEF`; **ein** `setInterval(250 ms)`-Tick: fällige Tickets spawnen, SLA-Ringe aktualisieren), `static/css/service-clash.css` Präfix `sc-`. Layout: Topbar (Schicht-Uhr, Wellen-Pips, Gesundheits-Meter, „Gelöst 4/8"), links die Ticket-Queue (Karten mit SLA-Ring, pulsierender roter Rand bei Überfälligkeit), Mitte das aktive Ticket mit 3-Stufen-Flow, unten ein Event-Log („14:02 Ticket ‚ERP down' eingegangen"). SLA-Ringe: `var(--accent)`, unter 25 % `var(--danger)`.
+
+**Schwierigkeitskurve:** Schicht 1 „Erster Arbeitstag" (8 Tickets, großzügige SLAs, Prio-Stufe deaktiviert), Schicht 2 „Normalbetrieb" (12 Tickets, Prio aktiv, erster Phishing-Köder), Schicht 3 „Patch Day Chaos" (16 Tickets, knappe SLAs, Major Incident mit Folgetickets in Welle 3). **Replay-Wert:** Ticket-Pool größer als `spawnCount` → jede Runde ein anderer Mix (Seed).
+
+**Content & Seeder:** `ServiceClashSeeder` liest `resources/service-clash/content.json`. Startumfang: **3 Schichten × 18–20 Ticket-Vorlagen ≈ 55 Tickets.** Vier Beispiel-Tickets sind voll ausgearbeitet (Drucker-Queue/Incident-mittel, Azubi-Onboarding/Service-Request-niedrig, ERP-Totalausfall/Major-Incident-hoch mit Sofort-Eskalation, Phishing-Mail mit verdächtiger Absenderdomain).
+
+**Admin:** `AdminServiceClashController` (`/admin/service-clash`), Schicht-Liste + Detailseite (Schicht-Formular inkl. Settings-JSON, Ticket-Tabelle, Payload-JSON-Textarea mit Schema-Hinweis; Speichern validiert `correctIndex` gegen `options`).
+
+**Aufwand:** MVP ≈ 7,5 PT (Service inkl. Seed-Plan + Re-Simulation 2 · Frontend 3 · Content 1 · Admin 1 · Rest 0,5+0,5). Ausbau (+3 PT): Major-Incident-Folgeketten, Combo-Serien, HMAC-Seed, Endlosmodus „Überstunden".
+
+---
+
+### Spiel 4: NetWorker (Key: `networker`, Migration V13)
+
+**Konzept:** Netzwerk-Puzzle in der Tradition von Schaltkreis-Spielen. Jedes Level zeigt eine **SVG-Topologie** (PCs, Switch, Router, Server, Cloud). Geräte haben fehlende oder kaputte Konfiguration (IP, Maske, Gateway, Kabel, statische Routen). Ziel: alle **Ping-Ziele** erfüllen („PC1 muss SRV1 erreichen", später auch negativ: „Gast-PC darf den Server NICHT erreichen"). „Pings testen" ruft einen **serverseitigen Netzwerk-Simulator**, der jeden Ping Hop-für-Hop auflöst und Pass/Fail plus didaktische Diagnose liefert („Das Paket verlässt PC1 nicht: Laut Maske liegt das Ziel im eigenen Netz – stimmt die Maske?").
+
+**Lernziele (AP1-Kernstoff → AP2, passt zu vorhandenem FinalFlux-Content IP-Berechnung/VLAN):** IPv4-Adressierung, Subnetzmasken/CIDR, Netz-/Broadcast-Adressen, Gateway-Logik, doppelte IPs, statische Routen; auf AP2-Niveau (FISI): VLAN-Segmentierung mit Negativ-Zielen, Routing über mehrere Hops, Firewall-Regeln, im Ausbau IPv6.
+
+**Spielablauf:** Session = eine **Welt** aus 4–6 Leveln in Folge (Dev-Lab-Session-Form). Fünf Level-Typen bei einheitlichem Datenmodell: `assign` (leere IP/Maske/Gateway-Felder ausfüllen), `cable` (fehlende Verbindungen ziehen), `fix` (1–3 eingebaute Fehler finden: falsche Maske, Gateway außerhalb des Subnetzes, doppelte IP, Host auf Netzadresse), `route` (statische Routen-Zeilen: Zielnetz-CIDR + Next Hop), `vlan` (Ausbau, mit Negativ-Zielen).
+
+**Versuche & Punkte:** Jeder „Pings testen"-Klick mit mindestens einem roten Ziel verbraucht einen Versuch (1.0/0.6/0.3, `MAX_ATTEMPTS=3`, danach „Lösung anzeigen" = 0 Punkte). **Bewertet wird ausschließlich per Simulation, nie per Exact-Match** – viele Konfigurationen sind gültig (jede freie Host-IP funktioniert); die Musterlösung dient nur dem Aufdecken. Levelpunkte 100–200; Sterne am Weltende nach Konvention; `/finish` re-simuliert die final eingereichten Konfigurationen serverseitig. `recordScore(user, "netzwerker", weltSlug, score, gelöste, sekunden)`.
+
+**Datenmodell (`V13__networker.sql`):**
+- `netzwerker_worlds` (id, slug UNIQUE, title, description, difficulty INT, sort_order, active)
+- `netzwerker_levels` (id, world_id FK CASCADE, title, level_type VARCHAR(30) /* assign|cable|fix|route|vlan */, points INT DEFAULT 100, sort_order, payload VARCHAR(8000) /* JSON-Topologie inkl. Musterlösung */) + FK-Index
+
+**Der Simulator – `service/NetSimulator.java` (Herzstück, pures Java ohne Spring, voll unit-testbar):**
+- Records: `Net(nodes, links, routes, vlans)`, `NodeCfg`, `IfaceCfg(ipLong, prefix, gatewayLong)`, `Route(destNet, prefix, nextHop)`.
+- `ping(net, from, to)`: (1) Validierung: unparsebare IP/Maske, Host-Teil 0/alles-1 → `network_address`/`broadcast_address`, doppelte IP im L2-Segment → `duplicate_ip`. (2) Gleiches Subnetz aus Quellsicht (`(ip & maske) == (ziel & maske)`) → L2-BFS über Links durch Switches (nie durch Router; VLAN-gefiltert). (3) Anderes Subnetz → Gateway nötig: gesetzt? im Quell-Subnetz? L2-erreichbar? Dann leitet der Router weiter: Ziel in direkt verbundenem Subnetz → zustellen; sonst statische Routen (Longest-Prefix-Match) → Next Hop → Rekursion mit TTL 8 (`routing_loop`-Schutz). Kein Treffer → `no_route`.
+- Fehlergründe werden im Service auf didaktische deutsche Meldungen gemappt.
+
+**`NetzwerkerService`:** `buildCatalog()`, `buildSession(slug)` (Level per `sanitizeLevel()`: Werte editierbarer Felder, zu ziehende Links, Routen-Lösungszeilen und `solution`-Block entfernt; gesperrte Werte, Positionen, Ziele, Hints gehen mit), `check(levelId, reveal, config)` (`mergeSubmission()` legt eingereichte Werte **nur über editierbare Felder** – Manipulation gesperrter Felder wird ignoriert; alle Ziele durch `NetSimulator.ping`; Antwort mit Trace/Diagnose pro Ziel), `finish(...)`, Admin-CRUD **plus Qualitäts-Gate beim Speichern: die hinterlegte Musterlösung wird durch den Simulator geschickt – Speichern wird abgelehnt, wenn sie nicht alle Ziele erfüllt.**
+
+**API (`/api/networker`):** `GET /catalog`, `GET /session/{slug}`, `POST /check` (`{levelId, reveal, config:{ifaces[], links[], routes[], vlans[]}}` → `{allPassed, validation[], goals:[{id, passed, trace[] | failAt, reason, message}]}`; Masken-Eingabe akzeptiert `24`, `/24` oder `255.255.255.0` – Server normalisiert), `POST /finish` → Dev-Lab-Result-Form.
+
+**Frontend:** `templates/netzwerker.html`, `static/js/netzwerker.js` (State-Machine `WORLD_SELECT → LEVEL_INTRO → EDITING ⇄ CHECKING → LEVEL_DONE → SUMMARY`), `static/css/netzwerker.css` Präfix `nw-`. **SVG-Ansatz:** ein `<svg viewBox="0 0 1000 620">`, Geräte-Glyphen als `<symbol>`-Defs im Strichstil der Dashboard-Icons, Positionen aus dem Payload; Links als `<path>`, Ports als Kreise an der Gerätekante. **Die Paket-Animation ist die Belohnung:** bei Erfolg wandert ein leuchtender Punkt entlang des tatsächlich vom Server gelieferten `trace`-Pfads (`requestAnimationFrame`); bei Fehlschlag stirbt er exakt am `failAt`-Hop mit rotem Burst. Kabelmodus: Port A klicken → Gummiband-Linie → Port B; gezogenes Kabel per Klick löschen. Layout: Canvas links/Mitte, rechts Ziel-Liste (mit Diagnosetexten unter roten Zielen) + Konfigurations-Panel des gewählten Geräts, Footer mit „Pings testen" / „Lösung anzeigen" / Hinweis-Toggle.
+
+**Schwierigkeitskurve (Welten):** 1. „Ein Netz für alle" (Same-Subnet-Basics), 2. „Über den Router" (Gateways, zwei Subnetze, erstes Negativ-Ziel), 3. „Routen & Fehlersuche" (zwei Router, statische Routen, Duplikat-IP-Jagd), 4. (Ausbau) „VLAN-Werkstatt".
+
+**Content & Seeder:** `NetzwerkerSeeder` liest `resources/netzwerker/content.json`. Startumfang: **3 Welten × 5 Level = 15 Level.** Drei Beispiel-Level voll ausgearbeitet: „Erste Verbindung" (assign: PC1 passend zu 192.168.10.20/24 konfigurieren), „Die falsche Maske" (fix: /25-vs-/24-Konflikt, .200 liegt außerhalb des ersten /25-Teilnetzes), „Tor zum Serverraum" (assign: IP+Maske+Gateway über Router zwischen 192.168.1.0/24 und 192.168.2.0/24).
+
+**Admin:** `AdminNetzwerkerController` (`/admin/netzwerker`), Welt-Liste + Detailseite mit Level-Payload-JSON-Textarea (eingeklapptes Schema-Cheatsheet) und dem Musterlösungs-Validierungs-Gate.
+
+**Aufwand:** MVP ≈ 9,5 PT (**NetSimulator + Unit-Tests zuerst: 2,5** · Migration/Entities/Service/API 1,5 · SVG-Frontend 3,5 · Content 1 · Admin 1). Ausbau (+4,5 PT): VLAN-Welt, DHCP-Modus, Sandbox, visueller Level-Editor.
+
+---
+
+### Empfohlene Baureihenfolge & Gesamtaufwand
+
+0. **Vorarbeiten ✅:** Namensschema, Dashboard-Namen und Keys, `devlab` in `ProgressService`, K2,
+   W8, V11–V14-Migrationsreservierung, `exam_scope`-Konvention, S3-Sicherheitsvertrag und
+   Spiel-Akzent-Tokens in `theme.css` sind umgesetzt.
+1. **FluxTimer ✅** – risikoarmer, rein lokaler Ausbau; validiert den globalen UI-Bootstrap und belegt die Glocke vor FluxNet. ≈ 1,5–2 PT
+2. **SystemEscape (V11) ✅** – serverautoritatives Spiel mit 3 Szenarien, 24 Räumen, 69 Rätseln
+   und vier zufälligen Räumen pro Run; Admin-CRUD, `exam_scope`, festgeschriebene Run-Auswahl,
+   dynamische Wertung und Anti-Cheat-Negativtests umgesetzt.
+3. **BugHunter (V12)** – übernimmt Terminal-Styling und Choice-Renderer aus Schritt 2. ≈ 4,5 PT
+4. **NetWorker (V13)** – **Simulator zuerst, testgetrieben** (pures Java, kein UI-Risiko), dann SVG-Frontend. ≈ 9,5 PT
+5. **ServiceClash (V14)** – komplexestes Frontend (Echtzeit-Tick); profitiert von allen Vorarbeiten. ≈ 7,5 PT
+
+**Gesamt-MVP aller vier Spiele: ≈ 28 Personentage.** Der Navigations-Umbau (Abschnitt 2.3) und die restlichen Teil-2-Punkte können parallel oder dazwischen erfolgen; empfohlen ist der Sidebar-/Tab-Umbau **vor** dem vierten Spiel, damit alle neuen Seiten die Fragmente nutzen.
+
+---
+
+## Teil 2: Verbesserungen & Optimierungen am Bestand
+
+> ✅ **Umgesetzt am 2026-07-12** (K1–K3, W1–W8, N1–N6, S1–S8, S10 – Details im CHANGELOG). Offen bleiben: S9/i18n (bewusst zurückgestellt), S3 (Regel für die neuen Spiele) sowie die schrittweise Fragment-Migration der restlichen Spiel-/Admin-Templates. **K1 vollständig abgeschlossen:** Gitea-Secret angelegt, Produktionspasswort rotiert und Runner-Abgleich erfolgreich deployt (Workflow 43, Commit `4f5042d`). Das Verfahren und der manuelle Notfallweg stehen in [`pw_anleitung.md`](pw_anleitung.md).
+
+### 2.1 Kritisch (vor/mit dem nächsten Release beheben)
+
+| # | Problem | Ort | Maßnahme |
+|---|---------|-----|----------|
+| K1 ✅ | **DB-Passwort im Repo** (`SPRING_DATASOURCE_PASSWORD: mindflux_pass`) | `docker-compose.yml:11` | In Gitea-Secret auslagern (wie die Admin-Passwörter bereits); Passwort rotieren. |
+| K2 ✅ | **Unsicherer Legacy-Endpunkt `/users/save`**: speichert User ohne BCrypt-Hashing, ohne Validierung, mit frei wählbarer Rolle (Mass Assignment) – für jeden eingeloggten Nutzer erreichbar | `UserViewController.java:25–29` | `UserViewController` + `user-form.html` + `user-success.html` ersatzlos löschen (toter Legacy-Code). |
+| K3 ✅ | **Keine Tests** – `src/test` existiert nicht, obwohl `spring-boot-starter-test` deklariert ist | `pom.xml:88–93` | Mindestens: Unit-Tests für Score-Berechnungen (`GameScoreService`, `SyntaxSagaService`, `DevLabService.check`-Dispatcher) und einen `@WebMvcTest` für die Security-Regeln (`/admin/**` nur ADMIN). Die Netzwerk-Simulation des neuen Netzwerker-Spiels unbedingt testgetrieben bauen. |
+
+### 2.2 Wichtig (zeitnah)
+
+| # | Problem | Ort | Maßnahme |
+|---|---------|-----|----------|
+| W1 ✅ | **Dev Lab fehlt auf der Statistik-Seite** – Scores werden geschrieben, aber nie angezeigt | `ProgressService.GAMES` (Zeile 18–27) | `GAMES.put("devlab", "Dev Lab");` ergänzen (Reihenfolge wie Dashboard). |
+| W2 ✅ | **XP/Level/Streak sind Dummy-Daten** (`getOverallProgress` hardcoded 432/2400/Level 5) | `ProgressService.java:35–44` | Echte Aggregation aus `game_scores`: XP = Summe aller Scores (oder gedeckelt pro Spiel), Level per Schwellen-Tabelle, richtigen Antworten aus `moves` ableiten. Gleiches Fundament später für Achievements nutzen. |
+| W3 ✅ | **Achievements sind Dummy-Daten**, nicht mit `game_scores` verdrahtet | `AchievementServiceImpl` | Nach `recordScore()` einen Achievement-Check auslösen (z. B. „Erster Sieg", „3 Sterne in Syntax Saga", „5 Spiele an einem Tag"). Ereignisgesteuert im `GameScoreService` (ein Hook-Punkt statt in jedem Spiel). |
+| W4 ✅ | **Kein globales Error-Handling** – Admin-Controller werfen `IllegalArgumentException` → Whitelabel-500; APIs liefern leere DTOs statt 404 | alle Controller | Ein `@ControllerAdvice` (HTML: eigene `error.html`) + `@RestControllerAdvice` (JSON: `{error, message}` mit korrekten Statuscodes). `ResponseStatusException` in Services nutzen. |
+| W5 ✅ | **Keine Bean Validation** – kein `spring-boot-starter-validation`, keine `@Valid`/`@NotBlank`/`@Size`; keine Passwort-Mindestlänge, kein E-Mail-Formatcheck | `pom.xml`, `RegisterController.java:34–42`, `User.java` | Starter ergänzen; DTO-Validierung für Registrierung (Passwort ≥ 8 Zeichen, E-Mail-Format) und die neuen Spiel-APIs. |
+| W6 ✅ | **Registrierungs-Race + tote Templates**: App prüft Username case-insensitiv, DB-UNIQUE ist case-sensitiv → Race mit unbehandeltem 500; `register.html` (ohne `confirmPassword`-Feld) und `login.html` sind tot/kaputt | `RegisterController.java:40`, `V1__initial_schema.sql` | Funktionalen Index `UNIQUE (lower(username))` per Migration; `DataIntegrityViolationException` abfangen → Fehlermeldung; tote Templates `register.html`/`login.html` löschen. |
+| W7 ✅ | **`System.out.println` / `printStackTrace` statt Logging** (~20 Stellen, u. a. `ProfileController.java:144`) | Seeder, `AdminSetup`, `ProfileController`, `AppStartCheck` | Auf SLF4J (`LoggerFactory.getLogger`) umstellen; `e.printStackTrace()` durch `log.error(..., e)` ersetzen. |
+| W8 ✅ | **N+1-Queries**: `TechtacularService.buildBoard` lädt Fragen+Antworten lazy pro Kategorie; `categoryRows` macht ein `count` pro Kategorie | `TechtacularService.java:46–73, 133–137` | `@EntityGraph`/`JOIN FETCH` für Board-Aufbau; Zeilen-Counts als eine `GROUP BY`-Query. Bei Seed-Datenmengen unkritisch, aber das Muster wird sonst in die 4 neuen Spiele kopiert – **daher vor deren Bau beheben bzw. in den neuen Services von Anfang an richtig machen.** |
+
+### 2.3 Navigation & Profil-Bereich (vom Nutzer gemeldet – bestätigt)
+
+Der Verdacht „Profilbutton fehlt / Einstellungen nicht im Profil / irgendwas ist schief" trifft zu. Befund:
+
+| # | Befund | Ort |
+|---|--------|-----|
+| N1 ✅ | **Kein „Profil"-Eintrag in der Dashboard-Sidebar-Navigation.** Das Profil ist nur über den kleinen User-Block unten in der Sidebar erreichbar (`<a class="mf-profile" href="/profile">`), der nicht als Button erkennbar ist – und dessen Chevron-Pfeil (▼) ein Dropdown suggeriert, das nicht existiert. | `dashboard.html:72–82` |
+| N2 ✅ | **Zwei konkurrierende Navigationssysteme:** Die Sidebar führt zu Knowledge Core / Statistiken / Achievements / Einstellungen; die Profilseite hat eine **eigene Tab-Leiste** (Profil / Fortschritt / Erfolge / Soziales / Einstellungen). Benennungen inkonsistent („Statistiken" vs. „Fortschritt", „Achievements" vs. „Erfolge"), Mengen inkonsistent (Knowledge Core fehlt in den Tabs, Soziales fehlt in der Sidebar). | `dashboard.html:45–70` vs. `profile.html:35–41` |
+| N3 ✅ | **Die Tab-Leiste existiert nur auf `profile.html`.** Klickt man einen „Tab" (z. B. Einstellungen), landet man auf einer Seite **ohne** Tabs – die Tab-Metapher bricht sofort. `settings.html` hat nur „⟵ Zurück zum Profil", auch wenn man von der Dashboard-Sidebar kam (asymmetrische Navigation). | Grep `mf-tab-nav`: nur `profile.html` (+ eine Admin-Seite) |
+| N4 ✅ | **`/profile/settings` gehört nicht zum Profil-Code:** Die URL suggeriert Profil-Zugehörigkeit, wird aber von einem separaten `SettingsController` bedient; die Passwort-Änderung dagegen liegt im `ProfileController` (`/profile/change-password`) und redirectet nach `settings`. Zuständigkeiten sind verschränkt. | `SettingsController.java`, `ProfileController.java:154–177` |
+| N5 ✅ | **`settings.html` ist zur Hälfte Attrappe:** Theme-Select (Hinweistext verweist auf den echten Umschalter), Sprach-Select und Benachrichtigungs-Checkboxen haben **keine Funktion/kein Formular**. Real sind nur Passwort ändern und Profil löschen. Zudem hartkodierte Farbe `#c0392b` statt `var(--danger)` (Token-Regel-Verstoß). | `settings.html:40–70, 37` |
+| N6 ✅ | **Sidebar-Widgets sind Dummy-Daten:** LEVEL 12 / 3250/5000 XP / „STREAK 7 Tage" sind hart ins Template geschrieben – deckt sich mit W2 (XP/Level-Dummies im `ProgressService`). | `dashboard.html:84–91` |
+
+**Lösungsansatz (ein zusammenhängender Umbau, verzahnt mit S1/Layout-Fragmenten):**
+1. **Ein Navigationsmodell:** Die Sidebar wird als Thymeleaf-Fragment extrahiert und um einen expliziten Eintrag **„Profil" → `/profile`** ergänzt; der User-Block bleibt als Shortcut, verliert aber den irreführenden Chevron (oder bekommt ein echtes Dropdown mit Profil/Einstellungen/Logout).
+2. **Profil-Bereich konsolidieren:** Die Tab-Leiste wird ebenfalls Fragment und erscheint **auf allen** Profil-Unterseiten (Profil, Statistiken, Erfolge, Soziales, Einstellungen) mit einheitlichen Namen (Empfehlung: „Statistiken" und „Erfolge" überall). Knowledge Core entweder in die Tabs aufnehmen oder bewusst nur in der Sidebar führen – einmal entscheiden.
+3. **Controller aufräumen:** `SettingsController` in den `ProfileController` mergen (oder Settings vollständig auslagern inkl. Passwort-Endpunkt) – eine Zuständigkeit pro Bereich.
+4. **Attrappen entfernen oder verdrahten:** Theme-Select an `theme.js` anbinden (Auswahl persistiert in `localStorage`, ersetzt den Hinweistext); Sprach-Select und Benachrichtigungen **ausbauen**, bis es die Funktionen gibt. `#c0392b` → `var(--danger)`.
+5. N6 wird durch W2 (echte XP/Level aus `game_scores`) gelöst; bis dahin Widgets ausblenden statt Fantasiewerte zeigen.
+
+### 2.4 Sinnvoll (mittelfristig)
+
+| # | Thema | Maßnahme |
+|---|-------|----------|
+| S1 ✅ teilweise | **Template-Duplikation** – 33 Templates ohne ein einziges `th:fragment`; jede Seite dupliziert `<head>`, Sidebar, Footer | `templates/fragments/layout.html` mit `head`, `sidebar`, `footer`-Fragmenten einführen; schrittweise umstellen (zuerst bei den 4 neuen Spielen verwenden, dann Bestand migrieren). |
+| S2 ✅ | **4 parallele User-Anlage-Pfade** mit inkonsistenten Regeln (`RegisterController`, REST-`UserController`, `AdminUserController`, `UserViewController`) | Nach Löschung von K2: Restlogik in einen `UserService` konsolidieren (ein Ort für Encoding, Rollen, Uniqueness). |
+| S3 ✅ Fundament | **Score-Manipulation durch eigene Nutzer möglich** (Roh-Werte fälschbar, Reveal-vor-Finish) | Verbindlicher Sicherheitsvertrag ist oben dokumentiert und gilt für jedes neue Spiel; konkrete Implementierung und Negativtests entstehen jeweils mit dem Spiel. |
+| S4 ✅ | **Infrastruktur**: kein Actuator/Healthcheck, Dockerfile läuft als root, kein Dependency-Layer-Caching, CI ohne Tests, Java-Versionskonflikt (pom: 17, Dockerfile: 21) | `spring-boot-starter-actuator` (+ `HEALTHCHECK` in compose), `USER`-Directive, Dockerfile zweistufig mit `dependency:go-offline`-Layer, Test-Stage in `.gitea/workflows/mindflux.yml`, Java-Version angleichen (empfohlen: beide auf 21). |
+| S5 ✅ | **Datenmodell**: `game_scores`/`achievements` referenzieren `username` ohne FK; `email` ohne UNIQUE | FK auf `users(username)` + `UNIQUE(email)` per Migration ergänzen (vorher Dubletten bereinigen). |
+| S6 ✅ | **Logout per GET** (`SecurityConfig.java:36`) – kleiner Logout-CSRF-Vektor | Auf POST-Logout mit CSRF-Token umstellen (kleines Formular im Sidebar-Footer). |
+| S7 ✅ | **Kein Brute-Force-Schutz** auf `/login` | Einfacher In-Memory-Rate-Limiter (z. B. Bucket pro IP/Username) oder Verzögerung nach Fehlversuchen. |
+| S8 ✅ | **Toter Code**: `AppStartCheck`, `ProfileController.getFileExtension`, Legacy-CSS (`auth.css`, …) | Aufräumen (niedrige Priorität, aber billig). |
+| S9 ☐ | **i18n**: alles hart deutsch | Nur angehen, falls Mehrsprachigkeit je geplant ist – sonst bewusst so lassen (Zielgruppe ist deutsch). |
+| S10 ✅ | **FinalFlux auf die gesamte Ausbildung erweitern (AP2)** – aktuell rein AP1-fokussiert | Eigener AP2-Ast mit Sidebar-Blöcken „AP2 Anwendungsentwicklung" und „AP2 Systemintegration"; gleiche Struktur wie bisher (statische Themenseiten unter `static/finalflux/` + FluxCheck-Frage-JSONs). Startthemen FIAE: Entwurfsmuster, Testverfahren, SQL-Vertiefung, Softwarequalität; FISI: Netzwerksicherheit, Monitoring, Hochverfügbarkeit, Automatisierung. |
+
+---
+
+## Teil 3: FluxNet – Community & Soziales
+
+> Ersetzt den `/soziales`-Platzhalter („Straßen? Wo wir hingehen, brauchen wir keine Straßen!"). Ziel: User können sich befreunden, intern miteinander schreiben, gemeinsam lernen und Achievements vergleichen – **vollständig selbst gehostet, ohne einen einzigen externen Dienst**, und DSGVO-konform von Grund auf.
+
+### 3.1 Funktionsumfang
+
+| Funktion | Beschreibung |
+|----------|--------------|
+| **Freundschaften** | Anfrage per Username-Suche senden → Gegenseite bestätigt/lehnt ab. Nur bestätigte Freunde sehen einander im FluxNet. |
+| **Interner Messenger** | 1:1-Direktnachrichten zwischen bestätigten Freunden. Ungelesen-Badge am Glocken-Icon der Topbar. Kein Gruppenchat in Phase 1. |
+| **Blockieren** | Blockiert = keine Anfragen, keine Nachrichten, keine Profileinsicht – in beide Richtungen serverseitig geprüft. Bestehende Freundschaft wird getrennt. Der Blockierte erhält **keine** Benachrichtigung (still). Entblocken jederzeit über die Einstellungen. |
+| **Achievements vergleichen** | Freundesprofil zeigt den Achievement-Katalog nebeneinander (meine/seine freigeschalteten) und die Spiel-Highscores im Vergleich – nur, was die Privacy-Einstellungen des anderen erlauben. |
+| **Gemeinsam lernen** | Phase 2: **Lern-Duell** – einen Freund zu Spiel + Deck herausfordern, beide spielen binnen Frist, der Server vergleicht die echten `game_scores`-Ergebnisse. Phase 3: gemeinsame Lernräume (identisches Board für beide über die Seed-Mechanik aus dem ServiceClash-Design). |
+
+### 3.2 Datenmodell (nächste freie Flyway-Migrationen)
+
+Alle Tabellen mit FK auf `users(username)` und `ON DELETE CASCADE ON UPDATE CASCADE` (Muster aus V10) – damit greift das Löschkonzept automatisch.
+
+```sql
+CREATE TABLE privacy_settings (
+    username           VARCHAR(100) PRIMARY KEY REFERENCES users (username) ON DELETE CASCADE ON UPDATE CASCADE,
+    community_enabled  BOOLEAN NOT NULL DEFAULT FALSE,   -- DSGVO: Opt-in!
+    profile_visibility VARCHAR(20) NOT NULL DEFAULT 'FRIENDS',  -- FRIENDS | ALL
+    show_achievements  BOOLEAN NOT NULL DEFAULT TRUE,
+    show_stats         BOOLEAN NOT NULL DEFAULT TRUE,
+    allow_requests     BOOLEAN NOT NULL DEFAULT TRUE
+);
+
+CREATE TABLE friendships (
+    id                 BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    requester          VARCHAR(100) NOT NULL REFERENCES users (username) ON DELETE CASCADE ON UPDATE CASCADE,
+    addressee          VARCHAR(100) NOT NULL REFERENCES users (username) ON DELETE CASCADE ON UPDATE CASCADE,
+    status             VARCHAR(20)  NOT NULL DEFAULT 'PENDING',  -- PENDING | ACCEPTED
+    created_at         TIMESTAMP    NOT NULL,
+    responded_at       TIMESTAMP,
+    CONSTRAINT uq_friend_pair UNIQUE (requester, addressee),
+    CONSTRAINT chk_no_self CHECK (requester <> addressee)
+);
+
+CREATE TABLE user_blocks (
+    id         BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    blocker    VARCHAR(100) NOT NULL REFERENCES users (username) ON DELETE CASCADE ON UPDATE CASCADE,
+    blocked    VARCHAR(100) NOT NULL REFERENCES users (username) ON DELETE CASCADE ON UPDATE CASCADE,
+    created_at TIMESTAMP    NOT NULL,
+    CONSTRAINT uq_block_pair UNIQUE (blocker, blocked)
+);
+
+CREATE TABLE messages (
+    id        BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    sender    VARCHAR(100)  NOT NULL REFERENCES users (username) ON DELETE CASCADE ON UPDATE CASCADE,
+    recipient VARCHAR(100)  NOT NULL REFERENCES users (username) ON DELETE CASCADE ON UPDATE CASCADE,
+    body      VARCHAR(2000) NOT NULL,
+    sent_at   TIMESTAMP     NOT NULL,
+    read_at   TIMESTAMP,
+    reported  BOOLEAN       NOT NULL DEFAULT FALSE
+);
+CREATE INDEX idx_messages_unread ON messages (recipient, read_at);
+CREATE INDEX idx_messages_pair   ON messages (sender, recipient, sent_at);
+
+CREATE TABLE challenges (
+    id         BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    challenger VARCHAR(100) NOT NULL REFERENCES users (username) ON DELETE CASCADE ON UPDATE CASCADE,
+    challenged VARCHAR(100) NOT NULL REFERENCES users (username) ON DELETE CASCADE ON UPDATE CASCADE,
+    game       VARCHAR(50)  NOT NULL,
+    deck       VARCHAR(100),
+    status     VARCHAR(20)  NOT NULL DEFAULT 'OPEN',  -- OPEN | DONE | EXPIRED | DECLINED
+    created_at TIMESTAMP    NOT NULL,
+    expires_at TIMESTAMP    NOT NULL
+);
+```
+
+Eine Freundschaft zwischen A und B liegt genau einmal vor (Anfrage-Richtung = requester); Abfragen prüfen beide Richtungen (`(requester=?1 AND addressee=?2) OR (requester=?2 AND addressee=?1)`).
+
+### 3.3 Backend (bewährtes Schichtmuster)
+
+- **Services:** `FriendshipService` (anfragen/annehmen/ablehnen/entfernen), `MessageService` (senden, Verlauf paginiert laden, als gelesen markieren, eigene Nachricht löschen, melden), `BlockService` (blocken/entblocken, `isBlockedEitherWay(a, b)`), `PrivacyService` (Opt-in, Sichtbarkeiten).
+- **Zentrale Guard-Methode**, die JEDE soziale Aktion durchläuft: Community aktiviert (beide Seiten)? Block in irgendeiner Richtung? Freundschaft bestätigt (für Nachrichten/Profile)? → sonst 403/404, ohne dem Angreifer zu verraten, ob der Zielnutzer existiert oder blockt.
+- **Controller:** `SozialesController` (View `/soziales`, Freundesprofil `/soziales/profil/{username}`) + `@RestController /api/social/**` (Endpunkte: `GET /friends`, `POST /friends/request|accept|decline|remove`, `GET /messages/{friend}?after=`, `POST /messages`, `POST /messages/{id}/report`, `DELETE /messages/{id}`, `GET /unread-count`, `POST /block`, `DELETE /block/{username}`, `GET/PUT /privacy`). Route in die CSRF-Ignore-Liste der `SecurityConfig` aufnehmen (Muster der Spiel-APIs).
+- **Moderation:** gemeldete Nachrichten landen in einer Admin-Ansicht (`/admin/fluxnet`) – der Admin sieht **ausschließlich gemeldete** Nachrichten (Verhältnismäßigkeit), kann löschen und Nutzer verwarnen/sperren.
+
+### 3.4 Messenger-Transport: voll intern, keine externen Dienste
+
+- **Phase 1 – Polling:** offener Chat pollt alle 5 s `GET /api/social/messages/{friend}?after=<letzteId>`, das Ungelesen-Badge alle 30 s `GET /api/social/unread-count`. Passt exakt zur zustandslosen Vanilla-JS-Architektur, braucht null neue Infrastruktur und skaliert für die Zielgruppe locker.
+- **Phase 2 – Server-Sent Events:** `GET /api/social/stream` mit Spring `SseEmitter` (im `MessageService` wird bei `send()` an offene Emitter des Empfängers publiziert). Weiterhin 100 % selbst gehostet. nginx: `proxy_buffering off;` + langes `proxy_read_timeout` für den Stream-Pfad.
+- **Bewusst NICHT:** WebSocket/STOMP (Overkill für 1:1-Chat) und Web-Push/FCM/Service-Worker-Push – Letzteres liefe zwingend über die Push-Infrastruktur der Browserhersteller (Google/Mozilla/Apple) und wäre damit ein externer Dienst.
+
+### 3.5 DSGVO-Konzept
+
+| Prinzip | Umsetzung |
+|---------|-----------|
+| **Opt-in (Art. 6, 25)** | `community_enabled = FALSE` als Default. Beim ersten Besuch von `/soziales`: Aktivierungsdialog mit klarem Hinweistext (welche Daten sichtbar werden, an wen). Ohne Aktivierung ist der Nutzer für andere unsichtbar und unauffindbar. Deaktivierung jederzeit in den Einstellungen (versteckt Profil, pausiert Eingang von Anfragen/Nachrichten). |
+| **Datenminimierung (Art. 5)** | Nur Username-Referenzen und Nachrichtentexte – keine neuen Pflicht-Personendaten, keine Telefonnummern, keine Kontakte-Uploads. |
+| **Privacy by Default (Art. 25)** | Sichtbarkeit ab Werk „nur Freunde"; Nachrichten nur zwischen bestätigten Freunden (verhindert nebenbei Spam). |
+| **Löschung (Art. 17)** | Konto-Löschung kaskadiert per FK automatisch über Freundschaften, Blocks, Nachrichten und Challenges – nichts bleibt zurück. Einzelne eigene Nachrichten kann der Nutzer selbst löschen. |
+| **Auskunft/Portabilität (Art. 15/20)** | Ausbau Phase 3: „Meine Daten exportieren"-Button (JSON-Dump der eigenen Profil-, Freundes-, Nachrichten- und Score-Daten). |
+| **Vertraulichkeit (Art. 32)** | Transport via TLS (nginx). Speicherung serverseitig im Klartext in der eigenen Postgres – bewusste, dokumentierte Entscheidung (Moderationsfähigkeit); keine Weitergabe an Dritte, kein externer Dienst, keine Analytik. |
+| **Transparenz (Art. 13)** | `datenschutz.html` um den Abschnitt FluxNet erweitern (Zwecke, Speicherdauer, Empfängerkreis „nur befreundete Nutzer", Moderationsregel); `nutzungsbedingungen.html` um Verhaltensregeln + Melde-/Sperrprozess. |
+| **Betroffenenschutz** | Blockieren ist still (kein „X hat dich blockiert"); Melden einer Nachricht legt nur DIESE Nachricht dem Admin vor. |
+
+### 3.6 Frontend
+
+- `soziales.html` wird zum **FluxNet-Hub** (der Profil-Tab „Soziales" existiert schon): links Freundesliste (mit Online-Reihenfolge nach letzter Aktivität) + offene Anfragen + Username-Suche; rechts Chat-Panel des gewählten Freundes (Verlauf, Eingabefeld, „Nachricht melden/löschen" im Kontextmenü).
+- Freundesprofil: Avatar, Level, Streak, Achievement-Vergleich (zwei Spalten, gemeinsame freigeschaltete hervorgehoben), Highscore-Tabelle je Spiel, Buttons „Herausfordern" / „Blockieren".
+- Neue Dateien: `static/js/fluxnet.js` (IIFE, Polling-Logik, Render-Funktionen), `static/css/fluxnet.css` (Präfix `fn-`, nur Theme-Tokens, Erfolg blau ✓ / Fehler rot ✗). Ungelesen-Badge am Glocken-Icon der Dashboard-Topbar (zusammen mit dem FluxTimer-Popover aus Teil 4).
+
+### 3.7 Phasen & Aufwand
+
+1. **Phase 1 (≈ 7 PT):** Migrationen, Privacy-Opt-in, Freundschaften, Blockieren, Polling-Messenger, Ungelesen-Badge, Rechtstexte, Tests (Guard-Logik!).
+2. **Phase 2 (≈ 4 PT):** SSE-Stream, Lern-Duelle, Freundesprofil mit Achievement-/Statistik-Vergleich, Melden + Admin-Moderationsansicht.
+3. **Phase 3 (≈ 4 PT):** gemeinsame Lernräume (Seed-Boards), Datenexport (Art. 15/20), Feinschliff (Emoji-Reaktionen, Streak-Anstupsen).
+
+---
+
+## Teil 4: FluxTimer – Der Pausen-Lerntimer
+
+> ✅ **MVP umgesetzt:** lokaler Zustand, globaler Countdown, Einstellungen, eigener Uhr-mit-Blitz-
+> Schnellzugriff in der Topbar, In-App-Overlay, Snooze, Probelauf sowie optionale Browser-
+> Benachrichtigung und Web-Audio-Signal. Die Glocke bleibt für FluxNet-/Systembenachrichtigungen
+> reserviert. Eine serverseitige Synchronisation bleibt bewusst optional.
+
+> Opt-in-Erinnerungstimer im Look der Zeitschaltkreise des DeLorean: Nach frei wählbarer Zeit erinnert Mindflux ans Aufstehen, Trinken, Essen – oder was immer man einträgt. Standardmäßig **deaktiviert**, jederzeit abschaltbar, komplett frei einstellbar.
+
+### 4.1 Funktionsumfang
+
+- **Aktivieren/Deaktivieren ✅** per Toggle in den Einstellungen und über das eigene
+  Uhr-mit-Blitz-Icon der Dashboard-Topbar.
+- **Intervall frei wählbar:** freie Minuteneingabe, sinnvolle Grenzen 5–240 Minuten (Default-Vorschlag 45).
+- **Erinnerungsarten wählbar** (Mehrfachauswahl, Rotation): Aufstehen 🧍 · Trinken 💧 · Essen 🍎 · Augenpause 👀 · **eigener Text** (Freitextfeld).
+- **Snooze** (+5 Minuten) und „Pause erledigt“ (startet das Intervall neu).
+- **Probelauf-Button** in den Einstellungen (löst die Erinnerung sofort testweise aus).
+- Optional zuschaltbar: Browser-Benachrichtigung (mit Permission-Abfrage) und dezenter Sound.
+
+### 4.2 Technik: rein clientseitig, kein externer Dienst, DSGVO-minimal
+
+- **`static/js/fluxtimer.js`** (IIFE), über das Layout-Fragment auf allen eingeloggten Seiten eingebunden.
+- **Zustand in `localStorage`:** `fluxtimer = { enabled, intervalMinutes, reminders: ["aufstehen","trinken",…], customText, sound, notify, nextFireAt, lastFiredAt }`. Beim Seitenwechsel/Reload wird die Restzeit aus `nextFireAt` weitergeführt – der Timer „überlebt“ Navigation, ohne dass der Server irgendetwas weiß. **Kein Personenbezug, keine Serverdaten, nichts einwilligungspflichtig** (localStorage-Nutzung wird in der Datenschutzerklärung als technisch notwendig/funktional erwähnt).
+- **Auslösung dreistufig:** (1) immer das In-App-Overlay (siehe 4.3); (2) optional lokale Browser-`Notification` – wird **lokal im Tab erzeugt**, kein Push-Server beteiligt; (3) optional kurzer Sound (Web Audio, eingebettet, kein CDN).
+- **Bewusst kein Service-Worker-Web-Push:** Echte Push-Nachrichten bei geschlossenem Tab liefen zwingend über die Push-Gateways der Browserhersteller – das wäre ein externer Dienst und für einen Pausen-Timer unnötig (wenn kein Mindflux-Tab offen ist, lernt man gerade nicht in Mindflux).
+- **Ausbau (optional, +0,5 PT):** `user_settings`-Tabelle für geräteübergreifende Einstellungen; localStorage bleibt der schnelle Cache.
+
+### 4.3 BTTF-Optik („Zeitschaltkreise“)
+
+- **Panel im Zeitschaltkreis-Look:** drei Anzeigezeilen in Segmentanzeigen-Typografie (Monospace + Glow):
+  - `NÄCHSTE PAUSE` – rot/bernsteinfarbene Anzeige (Countdown hh:mm:ss)
+  - `JETZT` – Akzentfarbe des Themes (laufende Uhrzeit)
+  - `LETZTE PAUSE` – gedimmt (wann zuletzt pausiert wurde)
+- **Beim Auslösen:** kurzer Flux-Blitz (CSS-Animation über dem Overlay), 88-mph-Anspielung und Sprüche im BTTF-Ton, rotierend je Erinnerungsart – z. B. „Großer Scott! Zeit, etwas zu trinken.“ · „88 mph erreicht – kurz aufstehen, McFly!“ · „Dein Fluxkompensator braucht einen Snack.“
+- **Styleguide-konform:** alle Farben über Theme-Tokens (die Rot-/Bernsteintöne als neue `--fluxtimer-*`-Tokens in `theme.css`, Dark/Light getestet); Grün bleibt tabu als Erfolgsfarbe. CSS in `static/css/fluxtimer.css` (Präfix `ft-`), Cache-Busting `?v=1`.
+
+### 4.4 UI-Einstiegspunkte & Dateien
+
+| Ort | Änderung |
+|-----|----------|
+| `settings.html` ✅ | Sektion „FluxTimer“: Toggle, Minuten-Eingabe, Erinnerungs-Checkboxen, Freitext, Benachrichtigung/Sound-Optionen, Probelauf-Button |
+| `dashboard.html` (Topbar) ✅ | Eigenes Uhr-mit-Blitz-Icon öffnet das Popover mit Status, Countdown, Schnell-Toggle und Link zu den Einstellungen; Glocke bleibt frei |
+| `theme.js` ✅ | Zentraler, idempotenter Asset-Bootstrap, damit der Timer über Seitennavigationen weiterläuft |
+| `static/js/fluxtimer.js`, `static/css/fluxtimer.css` ✅ | Timer-Logik + Zeitschaltkreis-Optik |
+
+### 4.5 Aufwand
+
+≈ 1,5–2 PT (JS-Logik + Settings-UI + Popover + CSS/Animationen), +0,5 PT für die optionale serverseitige Persistenz.
+
+---
+
+## Schlüsseldateien als Bauplan-Referenz
+
+| Datei | Rolle |
+|-------|------|
+| `src/main/java/com/example/mindflux/service/DevLabService.java` | Struktureller Bauplan für alle vier Services: `sanitize`/`check*`/`finish`/`awardedPoints`/`stars` + Text-Normalisierungs-Helfer (Checker für `choice`/`order`/`match`/`regex`/`cloze` teils 1:1 kopierbar) |
+| `src/main/resources/static/js/devlabgame.js` | Renderer-Vertrag `{render, collect, lock, mark}`, Versuchsleiter-Frontend-Muster |
+| `src/main/resources/db/migration/V8__devlab.sql` | SQL-Stilvorlage für V9–V12 |
+| `src/main/java/com/example/mindflux/config/SecurityConfig.java` (Zeile 43) | CSRF-Ignore-Liste: `/api/codeescape/**`, `/api/bughunter/**`, `/api/serviceclash/**`, `/api/networker/**` ergänzen |
+| `src/main/resources/templates/dashboard.html` (Zeilen 186–196) | `GAMES`-Array: Namen aufs neue Schema umstellen (DevLab, SyntaxSaga, SystemEscape, ServiceClash, BugHunter, NetWorker) und die verbliebenen `'/comingsoon'`-Hrefs gegen echte Routen tauschen (Icons `lock`/`sword`/`bug`/`network` existieren bereits) |
+| `GameScoreController.KNOWN_GAMES` + `ProgressService.GAMES` | Vier reservierte Keys aufs neue Schema umbenennen (`codeescape`, `serviceclash`, `bughunter`, `networker`), `devlab` in `ProgressService` ergänzen (W1) |
+| `src/main/java/com/example/mindflux/service/GameScoreService.java` | `recordScore(...)`-Anschlusspunkt aller Spiele |
+| `STYLEGUIDE.md`, `CHANGELOG.md` | Design-Regeln (blau ✓ / rot ✗, nie grün; Theme-Tokens; `?v=N`) und Pflege der Historie |
+
+## Verifikation
+
+**Pro Spiel (nach Implementierung):**
+1. `mvn test` – insbesondere `NetSimulatorTest` (Same-Subnet, Gateway, Longest-Prefix-Routen, Loop-Guard, Netz-/Broadcast-Adresse, Duplikat-IP) und `ServiceClashServiceTest` (Seed-Determinismus: gleicher Seed ⇒ identischer Plan; Re-Simulations-Scoring).
+2. App starten (`docker-compose` oder lokal, Port 8282), einloggen und den vollen Spielfluss durchspielen: Lobby → Runde → absichtlich falsche Antworten (Versuchsleiter 1.0/0.6/0.3 prüfen) → Aufdecken (0 Punkte) → Abschluss → Score/Sterne/Highscore-Anzeige.
+3. Server-Autorität prüfen: `POST /finish` mit manipulierten Daten (fremde IDs, unmögliche Zeitstempel) darf keinen überhöhten Score ergeben; View-DTOs im Netzwerk-Tab dürfen keine Lösungsfelder enthalten.
+4. Highscore-Chip via `GET /api/games/<key>/stats`; Eintrag erscheint auf `/progress`.
+5. Admin-CRUD: Anlegen/Ändern/Löschen inkl. Payload-Validierung (Netzwerker: Musterlösungs-Gate; Bug Hunter: `file`/`line`-Konsistenz; Service Clash: `correctIndex` in `options`).
+6. Dark/Light-Theme umschalten und mobile Breite prüfen (Theme-Tokens, kein Grün).
+
+**Namensschema & visuelle Differenzierung:** Dashboard zeigt alle neun Spiele mit einheitlichen CamelCase-Namen; jede der vier neuen Spielseiten hat ihren eigenen Akzent und ihr eigenes visuelles Vokabular – nebeneinander geöffnet müssen sie sofort unterscheidbar sein (Dark und Light prüfen).
+
+**Navigation (Abschnitt 2.3):** Von jeder Profil-Unterseite aus sind alle anderen per Tab-Leiste erreichbar; „Profil" ist als Sidebar-Eintrag vorhanden; `settings.html` enthält keine funktionslosen Bedienelemente mehr; kein irreführender Chevron ohne Dropdown.
+
+**Für die Verbesserungen (Teil 2):** Nach K1/K2: Neustart via docker-compose mit Secret-basiertem Passwort; `/users/save` liefert 404. Nach W1: DevLab erscheint auf `/progress`. Nach W4: bewusst kaputte Requests → saubere Fehlerseite/JSON-Fehler statt Whitelabel-500. Nach W6: doppelte Registrierung (Groß-/Kleinschreibung) liefert Fehlermeldung statt 500.

pom.xml

@@ -19,7 +19,8 @@
   <description>Mindflux – Lernplattform zur Prüfungsvorbereitung</description>
 
   <properties>
-    <java.version>17</java.version>
+    <!-- Angeglichen an die Dockerfile-Laufzeit (Temurin 21) -->
+    <java.version>21</java.version>
   </properties>
 
   <dependencies>
@@ -53,10 +54,16 @@
       <artifactId>spring-boot-starter-security</artifactId>
     </dependency>
 
-    <!-- Passwort-Verschlüsselung (BCrypt) -->
+    <!-- Bean Validation (@Valid, @NotBlank, @Email ...) -->
     <dependency>
-      <groupId>org.springframework.security</groupId>
-      <artifactId>spring-security-crypto</artifactId>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-validation</artifactId>
+    </dependency>
+
+    <!-- Health/Monitoring (Container-Healthcheck auf /actuator/health) -->
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-actuator</artifactId>
     </dependency>
 
     <!-- PostgreSQL Datenbanktreiber -->
@@ -91,6 +98,12 @@
       <artifactId>spring-boot-starter-test</artifactId>
       <scope>test</scope>
     </dependency>
+
+    <dependency>
+      <groupId>org.springframework.security</groupId>
+      <artifactId>spring-security-test</artifactId>
+      <scope>test</scope>
+    </dependency>
 </dependencies>
 
 

pw_anleitung.md

@@ -0,0 +1,89 @@
+# Anleitung: DB-Passwort rotieren & Gitea-Secret anlegen
+
+> **Status 2026-07-12:** In Produktion abgeschlossen. Das Secret ist angelegt, die DB-Rolle
+> wurde rotiert und Workflow 43 erfolgreich ausgeführt. Diese Anleitung bleibt als Betriebs-
+> und Notfalldokumentation erhalten.
+
+**Warum?** Das alte Datenbank-Passwort `mindflux_pass` stand im Klartext in `docker-compose.yml` – und bleibt über die Git-Historie für immer einsehbar. Es gilt daher als **kompromittiert** und muss ersetzt werden.
+
+Die Technik ist bereits vorbereitet:
+- `docker-compose.yml` liest das Passwort jetzt aus `${MINDFLUX_DB_PASSWORD}` (kein Klartext mehr im Repo).
+- Der Gitea-Workflow (`.gitea/workflows/mindflux.yml`) reicht das Secret `MINDFLUX_DB_PASSWORD` beim Deploy durch – genau wie die Admin-Passwörter.
+
+**Wichtig:** Bis das Secret angelegt ist, bricht das nächste Deployment mit der Meldung
+`MINDFLUX_DB_PASSWORD muss als Secret gesetzt sein` ab. So wird kein App-Container mit
+einem leeren Datenbank-Passwort gestartet. Die folgenden 5 Schritte dauern ca. 5 Minuten.
+
+---
+
+## Schritt 1: Starkes Passwort erzeugen
+
+PowerShell (Windows):
+
+```powershell
+-join ((48..57) + (65..90) + (97..122) | Get-Random -Count 32 | ForEach-Object { [char]$_ })
+```
+
+Oder auf dem Server (Linux):
+
+```bash
+openssl rand -base64 24
+```
+
+Das Ergebnis kopieren – es wird in Schritt 2 **und** Schritt 3 gebraucht. Nirgendwo einchecken, nicht in Dateien im Repo speichern.
+
+## Schritt 2: Gitea-Secret anlegen
+
+1. Gitea öffnen → das **mindflux-Repository** aufrufen.
+2. **Einstellungen** → **Actions** → **Secrets** (derselbe Ort, an dem schon `MINDFLUX_ADMIN_PASSWORD` und `MINDFLUX_ADMIN2_PASSWORD` liegen).
+3. **„Neues Secret hinzufügen"**:
+   - **Name:** `MINDFLUX_DB_PASSWORD` (exakt so – der Workflow referenziert diesen Namen)
+   - **Wert:** das neue Passwort aus Schritt 1
+4. Speichern.
+
+## Schritt 3: Passwort in der Produktions-Datenbank ändern
+
+Der Gitea-Workflow gleicht das Passwort vor jedem Deployment automatisch mit dem Secret ab.
+Beim ersten Deployment nach der Rotation führt der Runner das entsprechende `ALTER USER` aus;
+ein separater SSH-Zugang ist deshalb nicht erforderlich.
+
+Der folgende Befehl ist nur noch ein manueller Notfallweg, falls der Runner-Schritt einmal
+nicht verfügbar sein sollte:
+
+Auf dem Server (dort, wo der Postgres-Container läuft – er heißt im Backend-Netz `postgres`):
+
+```bash
+docker exec -it postgres psql -U mindflux -d mindfluxdb -c "ALTER USER mindflux WITH PASSWORD 'HIER_DAS_NEUE_PASSWORT';"
+```
+
+> Falls der Container anders heißt: mit `docker ps` nachsehen. DB-User ist `mindflux`, Datenbank `mindfluxdb` (siehe `docker-compose.yml`).
+>
+> Achtung bei Sonderzeichen: Das Passwort steht in einfachen Anführungszeichen im SQL – ein `'` im Passwort müsste verdoppelt werden (`''`). Am einfachsten: Passwort ohne `'` erzeugen (die Generatoren aus Schritt 1 tun das).
+
+## Schritt 4: Deployment auslösen
+
+Einfach einen Push auf `main` machen (oder den Workflow in Gitea manuell erneut ausführen). Der Deploy-Schritt exportiert das Secret und startet den Container neu:
+
+```bash
+docker compose -f docker-compose.yml pull
+docker compose -f docker-compose.yml up -d
+```
+
+> Zwischen Schritt 3 und dem Neustart gibt es ein kurzes Fenster, in dem der noch laufende alte Container seine bestehenden DB-Verbindungen behält – das ist unkritisch. Sollte die App nach dem Neustart nicht hochkommen, prüfen ob Secret-Wert (Schritt 2) und DB-Passwort (Schritt 3) wirklich identisch sind, dann erneut `docker compose up -d`.
+
+## Schritt 5: Verifizieren
+
+```bash
+docker ps          # Container "mindflux" muss nach ~40 s "healthy" zeigen (Actuator-Healthcheck)
+docker logs mindflux --tail 30   # keine "password authentication failed"-Fehler
+```
+
+Danach im Browser einloggen – wenn Login und Dashboard funktionieren, ist die Rotation abgeschlossen. ✅
+
+---
+
+## Hinweise
+
+- **Lokale Entwicklung:** lokal wird das Passwort über die Umgebungsvariable `MINDFLUX_DB_PASSWORD` bzw. eine (nicht eingecheckte) `.env`-Datei gesetzt (`application.properties` importiert sie automatisch). Die lokale Datenbank kann ein eigenes, anderes Passwort haben.
+- **Warum die Historie nicht bereinigen?** Das alte Passwort ließe sich nur per Force-Push/History-Rewrite aus Git entfernen – aufwendig und riskant. Rotation ist der richtige Weg: Das alte Passwort darf ruhig bekannt sein, wenn es nirgends mehr gilt.
+- Die Postgres-Instanz ist nur im internen `backend_network` erreichbar (kein öffentlicher Port) – die Rotation ist trotzdem Pflicht (Defense in Depth).

src/main/java/com/example/mindflux/AppStartCheck.java

@@ -1,12 +0,0 @@
-package com.example.mindflux;
-
-import org.springframework.boot.CommandLineRunner;
-import org.springframework.stereotype.Component;
-
-@Component
-public class AppStartCheck implements CommandLineRunner {
-    @Override
-    public void run(String... args) {
-        System.out.println("✅ App läuft. Sicherheitsmodul sollte aktiv sein.");
-    }
-}

src/main/java/com/example/mindflux/config/AdminSetup.java

@@ -2,6 +2,8 @@ package com.example.mindflux.config;
 
 import com.example.mindflux.model.User;
 import com.example.mindflux.repository.UserRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.context.annotation.Bean;
@@ -11,6 +13,8 @@ import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 @Configuration
 public class AdminSetup {
 
+    private static final Logger log = LoggerFactory.getLogger(AdminSetup.class);
+
     @Value("${MINDFLUX_ADMIN_USERNAME:admin}")
     private String adminUsername;
 
@@ -44,7 +48,7 @@ public class AdminSetup {
             return; // Admin-Slot nicht konfiguriert -> still überspringen.
         }
         if (password == null || password.isBlank()) {
-            System.out.println("Kein Bootstrap-Admin erstellt: Passwort für '" + username + "' ist nicht gesetzt.");
+            log.warn("Kein Bootstrap-Admin erstellt: Passwort für '{}' ist nicht gesetzt.", username);
             return;
         }
         if (userRepo.findByUsername(username).isEmpty()) {
@@ -54,7 +58,7 @@ public class AdminSetup {
             admin.setPassword(passwordEncoder.encode(password));
             admin.setRole("ADMIN");
             userRepo.save(admin);
-            System.out.println("Bootstrap-Admin erstellt: " + username);
+            log.info("Bootstrap-Admin erstellt: {}", username);
         }
     }
 }

src/main/java/com/example/mindflux/config/AuthenticationEventListener.java

@@ -0,0 +1,28 @@
+package com.example.mindflux.config;
+
+import com.example.mindflux.service.LoginAttemptService;
+import org.springframework.context.event.EventListener;
+import org.springframework.security.authentication.event.AuthenticationFailureBadCredentialsEvent;
+import org.springframework.security.authentication.event.AuthenticationSuccessEvent;
+import org.springframework.stereotype.Component;
+
+/** Füttert den Login-Rate-Limiter mit den Auth-Ereignissen von Spring Security. */
+@Component
+public class AuthenticationEventListener {
+
+    private final LoginAttemptService loginAttemptService;
+
+    public AuthenticationEventListener(LoginAttemptService loginAttemptService) {
+        this.loginAttemptService = loginAttemptService;
+    }
+
+    @EventListener
+    public void onFailure(AuthenticationFailureBadCredentialsEvent event) {
+        loginAttemptService.loginFailed(event.getAuthentication().getName());
+    }
+
+    @EventListener
+    public void onSuccess(AuthenticationSuccessEvent event) {
+        loginAttemptService.loginSucceeded(event.getAuthentication().getName());
+    }
+}

src/main/java/com/example/mindflux/config/CodeEscapeSeeder.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.config; import com.example.mindflux.model.*;import com.example.mindflux.repository.EscapeScenarioRepository;import com.fasterxml.jackson.databind.*;import org.slf4j.*;import org.springframework.boot.CommandLineRunner;import org.springframework.core.io.ClassPathResource;import org.springframework.stereotype.Component;import org.springframework.transaction.annotation.Transactional;
+@Component public class CodeEscapeSeeder implements CommandLineRunner {private static final Logger log=LoggerFactory.getLogger(CodeEscapeSeeder.class);private final EscapeScenarioRepository repo;private final ObjectMapper mapper;public CodeEscapeSeeder(EscapeScenarioRepository r,ObjectMapper m){repo=r;mapper=m;}@Override @Transactional public void run(String...a){if(repo.count()>0)return;try{JsonNode root=mapper.readTree(new ClassPathResource("codeescape/content.json").getInputStream());int si=0,pc=0;for(JsonNode sn:root.path("scenarios")){EscapeScenario s=new EscapeScenario(sn.path("slug").asText(),sn.path("title").asText(),sn.path("difficulty").asText(),sn.path("examScope").asText("AP1"),sn.path("description").asText(),sn.path("timeLimitSeconds").asInt(900),si++);int ri=0;for(JsonNode rn:sn.path("rooms")){EscapeRoom r=new EscapeRoom(rn.path("title").asText(),rn.path("intro").asText(),rn.path("doorPrompt").asText(),rn.path("doorCode").asText(),rn.path("successText").asText(),ri++);int pi=0;for(JsonNode pn:rn.path("puzzles")){r.addPuzzle(new EscapePuzzle(pn.path("type").asText(),pn.path("prompt").asText(),pn.path("points").asInt(100),pn.path("fragment").asText(),pi++,mapper.writeValueAsString(pn.path("payload"))));pc++;}s.addRoom(r);}repo.save(s);}log.info("CodeEscape: {} Szenarien / {} Rätsel geladen.",si,pc);}catch(Exception e){log.error("CodeEscape-Seed fehlgeschlagen",e);}}}

src/main/java/com/example/mindflux/config/DevLabSeeder.java

@@ -5,6 +5,8 @@ import com.example.mindflux.model.DevLabTask;
 import com.example.mindflux.repository.DevLabGameRepository;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.stereotype.Component;
@@ -20,6 +22,8 @@ import java.util.Set;
 @Component
 public class DevLabSeeder implements CommandLineRunner {
 
+    private static final Logger log = LoggerFactory.getLogger(DevLabSeeder.class);
+
     private static final int MAX_PAYLOAD = 8000;
 
     private final DevLabGameRepository gameRepository;
@@ -40,7 +44,7 @@ public class DevLabSeeder implements CommandLineRunner {
             JsonNode root = objectMapper.readTree(new ClassPathResource("devlab/content.json").getInputStream());
             JsonNode games = root.get("games");
             if (games == null || !games.isArray()) {
-                System.out.println("⚠️ Dev-Lab-Seed: content.json ohne 'games'.");
+                log.warn("Dev-Lab-Seed: content.json ohne 'games'.");
                 return;
             }
 
@@ -87,10 +91,10 @@ public class DevLabSeeder implements CommandLineRunner {
                     gameCount++;
                 }
             }
-            System.out.println("✅ Dev Lab: " + gameCount + " Spiele / " + taskCount + " Aufgaben geladen"
-                    + (skipped > 0 ? " (" + skipped + " zu groß, übersprungen)" : "") + ".");
+            log.info("DevLab: {} Spiele / {} Aufgaben geladen{}.", gameCount, taskCount,
+                    skipped > 0 ? " (" + skipped + " zu groß, übersprungen)" : "");
         } catch (Exception e) {
-            System.out.println("⚠️ Dev-Lab-Seed übersprungen: " + e.getMessage());
+            log.warn("Dev-Lab-Seed übersprungen: {}", e.getMessage(), e);
         }
     }
 

src/main/java/com/example/mindflux/config/SecurityConfig.java

@@ -2,15 +2,16 @@ package com.example.mindflux.config;
 
 import com.example.mindflux.model.User;
 import com.example.mindflux.repository.UserRepository;
+import com.example.mindflux.service.LoginAttemptService;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.LockedException;
 import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.core.userdetails.*;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.web.SecurityFilterChain;
-import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
 
 @Configuration
 public class SecurityConfig {
@@ -20,36 +21,42 @@ public class SecurityConfig {
         http
             .authorizeHttpRequests(auth -> auth
                 .requestMatchers("/", "/login", "/register", "/impressum", "/nutzungsbedingungen", "/datenschutz", "/richtlinien", "/css/**", "/js/**", "/img/**").permitAll()
-                .requestMatchers("/admin/**").hasRole("ADMIN") // NEU: Adminbereich absichern
+                .requestMatchers("/actuator/health").permitAll() // Container-Healthcheck
+                .requestMatchers("/admin/**").hasRole("ADMIN")
                 .requestMatchers("/api/users/**").hasRole("ADMIN")
                 .anyRequest().authenticated()
             )
             .formLogin(form -> form
-                .loginPage("/") // login.html liegt auf "/"
+                .loginPage("/") // Login-Formular liegt auf der Startseite (index.html)
                 .loginProcessingUrl("/login")
                 .defaultSuccessUrl("/dashboard", true)
                 .failureUrl("/?error") // zeigt Loginfehler an
                 .permitAll()
             )
             .logout(logout -> logout
-                // Logout-Links in den Templates sind GET -> GET-Logout erlauben, sonst 404/Fehler unter CSRF
-                .logoutRequestMatcher(new AntPathRequestMatcher("/logout", "GET"))
+                // Logout nur per POST (CSRF-geschützt); die Templates nutzen kleine Formulare.
+                .logoutUrl("/logout")
                 .logoutSuccessUrl("/?logout")
                 .permitAll()
             )
             .csrf(csrf -> csrf
                 // Spiele-APIs werden per fetch (application/json) ohne Token aufgerufen -> ausnehmen.
                 // Reine JSON-Endpunkte sind nicht über klassische HTML-Formulare CSRF-ausnutzbar.
-                .ignoringRequestMatchers("/api/games/**", "/api/techtacular/**", "/api/mindmatch/**", "/api/syntaxsaga/**", "/api/devlab/**")
+                .ignoringRequestMatchers("/api/games/**", "/api/techtacular/**", "/api/mindmatch/**", "/api/syntaxsaga/**", "/api/devlab/**", "/api/codeescape/**")
             );
 
         return http.build();
     }
 
     @Bean
-    public UserDetailsService userDetailsService(UserRepository userRepo) {
+    public UserDetailsService userDetailsService(UserRepository userRepo, LoginAttemptService loginAttemptService) {
         return username -> {
-            User user = userRepo.findByUsername(username)
+            // Brute-Force-Schutz: Nach zu vielen Fehlversuchen vorübergehend sperren.
+            if (loginAttemptService.isBlocked(username)) {
+                throw new LockedException("Zu viele Fehlversuche – bitte später erneut versuchen.");
+            }
+
+            User user = userRepo.findByUsernameIgnoreCase(username)
                     .orElseThrow(() -> new UsernameNotFoundException("Benutzer nicht gefunden"));
 
             return org.springframework.security.core.userdetails.User

src/main/java/com/example/mindflux/config/SyntaxSagaSeeder.java

@@ -6,6 +6,8 @@ import com.example.mindflux.model.SyntaxSagaSolution;
 import com.example.mindflux.repository.SyntaxSagaMissionRepository;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.stereotype.Component;
@@ -22,6 +24,8 @@ import java.util.Set;
 @Component
 public class SyntaxSagaSeeder implements CommandLineRunner {
 
+    private static final Logger log = LoggerFactory.getLogger(SyntaxSagaSeeder.class);
+
     private static final Set<String> DIFFICULTIES = Set.of("junior", "professional", "senior");
 
     private final SyntaxSagaMissionRepository missionRepository;
@@ -43,7 +47,7 @@ public class SyntaxSagaSeeder implements CommandLineRunner {
                     new ClassPathResource("syntaxsaga/content.json").getInputStream());
             JsonNode missions = root.get("missions");
             if (missions == null || !missions.isArray()) {
-                System.out.println("⚠️ Syntax-Saga-Seed: content.json ohne 'missions'.");
+                log.warn("Syntax-Saga-Seed: content.json ohne 'missions'.");
                 return;
             }
 
@@ -104,9 +108,9 @@ public class SyntaxSagaSeeder implements CommandLineRunner {
                     missionCount++;
                 }
             }
-            System.out.println("✅ Syntax Saga: " + missionCount + " Missionen / " + gapCount + " Lücken geladen.");
+            log.info("SyntaxSaga: {} Missionen / {} Lücken geladen.", missionCount, gapCount);
         } catch (Exception e) {
-            System.out.println("⚠️ Syntax-Saga-Seed übersprungen: " + e.getMessage());
+            log.warn("Syntax-Saga-Seed übersprungen: {}", e.getMessage(), e);
         }
     }
 

src/main/java/com/example/mindflux/config/SystemEscapePoolSeeder.java

@@ -0,0 +1,25 @@
+package com.example.mindflux.config;
+import com.example.mindflux.model.*;import com.example.mindflux.repository.EscapeScenarioRepository;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.node.ObjectNode;import org.springframework.boot.context.event.ApplicationReadyEvent;import org.springframework.context.event.EventListener;import org.springframework.stereotype.Component;import org.springframework.transaction.annotation.Transactional;import java.util.*;
+@Component public class SystemEscapePoolSeeder{
+ private final EscapeScenarioRepository repo;private final ObjectMapper mapper;public SystemEscapePoolSeeder(EscapeScenarioRepository r,ObjectMapper m){repo=r;mapper=m;}
+ @EventListener(ApplicationReadyEvent.class) @Transactional public void expand()throws Exception{
+  add("verlassener-serverraum","DNS-Kammer","Ein Resolver hält die nächste Schleuse gesperrt.",q("DNS-Record für IPv4-Adresse?","A","A"),q("DNS-Record für Mailserver?","MX","MX"),q("DNS-Standardport?","53","53"));
+  add("verlassener-serverraum","VLAN-Brücke","Getrennte Segmente müssen korrekt verbunden werden.",q("VLAN-Tagging-Standard IEEE 802.?","1Q","1Q"),q("Gerät zwischen IP-Netzen?","Router","RTR"),q("VLAN ohne Tag am Trunk?","Native VLAN","NAT"));
+  add("verlassener-serverraum","Routing-Schacht","Das Gateway erwartet drei Routing-Grundlagen.",q("Route für alle unbekannten Ziele?","Default Route","DEF"),q("IPv4-Loopback-Adresse?","127.0.0.1","127"),q("Befehl zum Weg eines Pakets?","traceroute","TRC"));
+  add("verlassener-serverraum","Firewall-Gang","Nur korrekt gefilterter Verkehr öffnet den Gang.",q("Prinzip: alles verbieten, nur Nötiges erlauben?","Default Deny","DENY"),q("Firewall mit Verbindungszustand?","Stateful","STATE"),q("HTTPS-Protokoll über TCP-Port?","443","443"));
+  add("verlassener-serverraum","Monitoring-Zentrale","Metriken und Ereignisse liefern die Fragmente.",q("Protokoll für Geräteüberwachung?","SNMP","SNMP"),q("Zentrales Systemprotokoll?","Syslog","LOG"),q("ICMP-Werkzeug für Erreichbarkeit?","ping","PING"));
+  add("notfall-im-rechenzentrum","Identity-Vault","Der Identitätsdienst verlangt sichere Grundlagen.",q("Zweiter Faktor neben Passwort?","MFA","MFA"),q("Zentraler Verzeichnisdienst von Microsoft?","Active Directory","AD"),q("Minimal notwendige Rechte?","Least Privilege","LP"));
+  add("notfall-im-rechenzentrum","Container-Dock","Isolierte Workloads blockieren den Ausgang.",q("Container teilen den Kernel des?","Hosts","HOST"),q("Deklarative Container-Zusammenstellung?","Compose","COMP"),q("Persistenter Containerspeicher?","Volume","VOL"));
+  add("notfall-im-rechenzentrum","Patch-Leitstand","Ein ungepatchtes System hält die Tür verriegelt.",q("Bewertung bekannter Schwachstellen?","CVSS","CVSS"),q("Kennung einer veröffentlichten Schwachstelle?","CVE","CVE"),q("Testumgebung vor Produktion?","Staging","STG"));
+  add("notfall-im-rechenzentrum","Cluster-Korridor","Hochverfügbarkeit muss wiederhergestellt werden.",q("Automatischer Rollenwechsel bei Ausfall?","Failover","FAIL"),q("Verteilung von Anfragen?","Load Balancing","LB"),q("Prüfung der Dienstverfügbarkeit?","Health Check","HC"));
+  add("notfall-im-rechenzentrum","Storage-Array","Das Speichernetz fordert drei Begriffe.",q("Blockzugriff über IP?","iSCSI","ISCSI"),q("Dateifreigabe für Linux/Unix?","NFS","NFS"),q("Redundanz ist kein Ersatz für ein?","Backup","BAK"));
+  add("blackout-protokoll","PKI-Tresor","Die Zertifikatskette muss rekonstruiert werden.",q("Widerrufsliste für Zertifikate?","CRL","CRL"),q("Online-Prüfung eines Zertifikatsstatus?","OCSP","OCSP"),q("Oberste Vertrauensinstanz?","Root CA","ROOT"));
+  add("blackout-protokoll","API-Gateway","Die Schnittstelle akzeptiert nur sichere Antworten.",q("HTTP-Methode zum Lesen?","GET","GET"),q("Statuscode für nicht autorisiert?","401","401"),q("Datenformat mit Objekten und Arrays?","JSON","JSON"));
+  add("blackout-protokoll","Git-Archiv","Die Versionshistorie enthält den nächsten Schlüssel.",q("Lokale Änderungen vorm Commit vormerken?","git add","ADD"),q("Neuen Entwicklungszweig anlegen?","git branch","BR"),q("Historie eines Repositories anzeigen?","git log","LOG"));
+  add("blackout-protokoll","Datenbank-Kern","Transaktionen und Indizes sichern den Weg.",q("SQL-Befehl zum Lesen?","SELECT","SEL"),q("Index mit eindeutigen Werten?","UNIQUE","UNQ"),q("Transaktion zurücknehmen?","ROLLBACK","RB"));
+  add("blackout-protokoll","Zero-Trust-Schleuse","Jeder Zugriff muss erneut bewiesen werden.",q("Zero-Trust-Grundsatz: never trust, always?","verify","VERIFY"),q("Netze in kleine Zonen teilen?","Microsegmentation","MICRO"),q("Zugriffsentscheidung anhand von Rollen?","RBAC","RBAC"));
+ }
+ private Q q(String p,String a,String f){return new Q(p,a,f);}
+ private void add(String slug,String title,String intro,Q...qs)throws Exception{EscapeScenario s=repo.findBySlug(slug).orElse(null);if(s==null||s.getRooms().stream().anyMatch(r->r.getTitle().equals(title)))return;String code=Arrays.stream(qs).map(Q::fragment).reduce("",String::concat);EscapeRoom r=new EscapeRoom(title,intro,"Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.",code,"Die Schleuse entriegelt und gibt den nächsten Abschnitt frei.",s.getRooms().size());int i=0;for(Q q:qs){ObjectNode p=mapper.createObjectNode();p.put("instruction",q.prompt());p.putArray("solutions").add(q.answer());p.putArray("hints").add("Ordne den gesuchten Begriff dem IT-Kontext zu.").add("Der gesuchte Wert lautet: "+q.answer()+".");p.put("explanation",q.answer()+" ist die korrekte Lösung.");r.addPuzzle(new EscapePuzzle("code",q.prompt(),120,q.fragment(),i++,mapper.writeValueAsString(p)));}s.addRoom(r);repo.save(s);}
+ private record Q(String prompt,String answer,String fragment){}
+}

src/main/java/com/example/mindflux/config/TechtacularSeeder.java

@@ -6,6 +6,8 @@ import com.example.mindflux.model.TechtacularQuestion;
 import com.example.mindflux.repository.TechtacularCategoryRepository;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.stereotype.Component;
@@ -22,6 +24,8 @@ import java.util.Set;
 @Component
 public class TechtacularSeeder implements CommandLineRunner {
 
+    private static final Logger log = LoggerFactory.getLogger(TechtacularSeeder.class);
+
     private final TechtacularCategoryRepository categoryRepository;
     private final ObjectMapper objectMapper;
 
@@ -40,7 +44,7 @@ public class TechtacularSeeder implements CommandLineRunner {
             JsonNode root = objectMapper.readTree(new ClassPathResource("techtacular/content.json").getInputStream());
             JsonNode categories = root.get("categories");
             if (categories == null || !categories.isArray()) {
-                System.out.println("⚠️ TechTacular-Seed: content.json ohne 'categories'.");
+                log.warn("TechTacular-Seed: content.json ohne 'categories'.");
                 return;
             }
 
@@ -95,9 +99,9 @@ public class TechtacularSeeder implements CommandLineRunner {
                     catCount++;
                 }
             }
-            System.out.println("✅ TechTacular: " + catCount + " Kategorien / " + clueCount + " Hinweise geladen.");
+            log.info("TechTacular: {} Kategorien / {} Hinweise geladen.", catCount, clueCount);
         } catch (Exception e) {
-            System.out.println("⚠️ TechTacular-Seed übersprungen: " + e.getMessage());
+            log.warn("TechTacular-Seed übersprungen: {}", e.getMessage(), e);
         }
     }
 

src/main/java/com/example/mindflux/controller/AchievementController.java

@@ -19,18 +19,8 @@ public class AchievementController {
     @GetMapping("/profile/achievements")
     public String showAchievements(Model model, Principal principal) {
         String username = principal.getName();
+        // Kompletter Katalog: verdiente Achievements mit Datum, restliche als gesperrte Karten.
         List<Achievement> achievements = achievementService.getAchievementsForUser(username);
-
-        // 🔥 Dummy-Daten nur für Tests!
-        if (achievements == null || achievements.isEmpty()) {
-            achievements = List.of(
-                new Achievement("Hangman Hero", "Gewinne 10 Runden Hangman", "hangman.png", true),
-                new Achievement("Memory Meister", "Erreiche 1000 Punkte im Memory", "memory.png", false),
-                new Achievement("Quizkönig", "Beantworte 50 Fragen richtig", "quiz.png", true),
-                new Achievement("Early Bird", "Lerne vor 7 Uhr morgens", "earlybird.png", false)
-            );
-        }
-
         model.addAttribute("achievements", achievements);
 
         return "achievements"; // lädt achievements.html

src/main/java/com/example/mindflux/controller/AdminCodeEscapeController.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.controller; import com.example.mindflux.service.CodeEscapeService;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.*;
+@Controller @RequestMapping("/admin/codeescape") public class AdminCodeEscapeController {private final CodeEscapeService service;public AdminCodeEscapeController(CodeEscapeService s){service=s;}@GetMapping public String list(Model m){m.addAttribute("scenarios",service.all());return"admin/codeescape";}@PostMapping("/add")public String add(@RequestParam String title,@RequestParam String difficulty,@RequestParam String examScope,@RequestParam(required=false)String description,@RequestParam(defaultValue="900")int timeLimitSeconds){Long id=service.addScenario(title,difficulty,examScope,description,timeLimitSeconds);return"redirect:/admin/codeescape/"+id;}@GetMapping("/{id}")public String scenario(@PathVariable Long id,Model m){m.addAttribute("scenario",service.scenario(id));return"admin/codeescape-scenario";}@PostMapping("/{id}/rooms")public String room(@PathVariable Long id,@RequestParam String title,@RequestParam String intro,@RequestParam String doorPrompt,@RequestParam String doorCode,@RequestParam String successText){service.addRoom(id,title,intro,doorPrompt,doorCode,successText);return"redirect:/admin/codeescape/"+id;}@GetMapping("/rooms/{id}")public String roomPage(@PathVariable Long id,Model m){m.addAttribute("room",service.room(id));return"admin/codeescape-room";}@PostMapping("/rooms/{id}/puzzles")public String puzzle(@PathVariable Long id,@RequestParam String type,@RequestParam String prompt,@RequestParam int points,@RequestParam String codeFragment,@RequestParam String payload){service.addPuzzle(id,type,prompt,points,codeFragment,payload);return"redirect:/admin/codeescape/rooms/"+id;}@PostMapping("/{id}/toggle")public String toggle(@PathVariable Long id){service.toggle(id);return"redirect:/admin/codeescape";}@PostMapping("/{id}/delete")public String del(@PathVariable Long id){service.deleteScenario(id);return"redirect:/admin/codeescape";}@PostMapping("/rooms/{id}/delete")public String delRoom(@PathVariable Long id){var r=service.room(id);Long sid=r.getScenario().getId();service.deleteRoom(id);return"redirect:/admin/codeescape/"+sid;}@PostMapping("/puzzles/{id}/delete")public String delPuzzle(@PathVariable Long id,@RequestParam Long roomId){service.deletePuzzle(id);return"redirect:/admin/codeescape/rooms/"+roomId;}}

src/main/java/com/example/mindflux/controller/AdminUserController.java

@@ -1,8 +1,7 @@
 package com.example.mindflux.controller;
 
 import com.example.mindflux.model.User;
-import com.example.mindflux.service.AdminUserService;
-import org.springframework.beans.factory.annotation.Autowired;
+import com.example.mindflux.service.UserService;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
@@ -12,16 +11,18 @@ import org.springframework.web.bind.annotation.*;
 @RequestMapping("/admin")
 public class AdminUserController {
 
-    @Autowired
-    private AdminUserService userService;
+    private final UserService userService;
+    private final PasswordEncoder passwordEncoder;
 
-    @Autowired
-    private PasswordEncoder passwordEncoder;
+    public AdminUserController(UserService userService, PasswordEncoder passwordEncoder) {
+        this.userService = userService;
+        this.passwordEncoder = passwordEncoder;
+    }
 
-    // ⬅️ Neu: Dashboard-Startseite
+    // ⬅️ Dashboard-Startseite
     @GetMapping("")
     public String adminDashboard() {
-        return "admin/dashboard"; // du brauchst: templates/admin/dashboard.html
+        return "admin/dashboard";
     }
 
     // ⬅️ Benutzerverwaltung
@@ -39,21 +40,43 @@ public class AdminUserController {
 
     @PostMapping("/users/save")
     public String saveUser(@ModelAttribute("user") User user) {
-        if (user.getId() != null && (user.getPassword() == null || user.getPassword().isBlank())) {
+        if (user.getId() != null) {
             User existingUser = userService.findById(user.getId())
                     .orElseThrow(() -> new IllegalArgumentException("Ungültige User-ID: " + user.getId()));
-            user.setPassword(existingUser.getPassword());
+            userService.assertUsernameAvailable(user.getUsername(), user.getId());
+            user.setRole(userService.validateRole(user.getRole()));
+            // Passwort: leer = unverändert übernehmen, sonst neu verschlüsseln (Admin-Reset)
+            if (user.getPassword() == null || user.getPassword().isBlank()) {
+                user.setPassword(existingUser.getPassword());
+            } else {
+                user.setPassword(passwordEncoder.encode(user.getPassword()));
+            }
+            // Profilbild steht nicht im Formular -> bestehendes erhalten, nicht überschreiben
+            user.setProfilePicture(existingUser.getProfilePicture());
+            userService.save(user);
         } else {
-            user.setPassword(passwordEncoder.encode(user.getPassword()));
+            // Neuanlage zentral über den UserService (Validierung, Eindeutigkeit, Encoding)
+            userService.createUser(user.getUsername(), user.getEmail(), user.getPassword(), user.getRole());
         }
+        return "redirect:/admin/users";
+    }
 
-        userService.save(user);
+    /** Direktes Zurücksetzen des Passworts eines Nutzers (Admin-Recovery, ohne E-Mail). */
+    @PostMapping("/users/{id}/reset-password")
+    public String resetPassword(@PathVariable Long id, @RequestParam String newPassword) {
+        if (newPassword != null && !newPassword.isBlank()) {
+            User user = userService.findById(id)
+                    .orElseThrow(() -> new IllegalArgumentException("Ungültige User-ID: " + id));
+            user.setPassword(passwordEncoder.encode(newPassword.trim()));
+            userService.save(user);
+        }
         return "redirect:/admin/users";
     }
 
     @GetMapping("/users/edit/{id}")
     public String editUserForm(@PathVariable Long id, Model model) {
-        User user = userService.findById(id).orElseThrow(() -> new IllegalArgumentException("Ungültige User-ID: " + id));
+        User user = userService.findById(id)
+                .orElseThrow(() -> new IllegalArgumentException("Ungültige User-ID: " + id));
         model.addAttribute("user", user);
         return "admin/users/form";
     }

src/main/java/com/example/mindflux/controller/ApiExceptionHandler.java

@@ -0,0 +1,75 @@
+package com.example.mindflux.controller;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Fehlerbehandlung für alle JSON-APIs: liefert statt Whitelabel-HTML einen
+ * konsistenten JSON-Körper mit korrektem Statuscode.
+ */
+@RestControllerAdvice(annotations = RestController.class)
+@Order(Ordered.HIGHEST_PRECEDENCE)
+public class ApiExceptionHandler {
+
+    private static final Logger log = LoggerFactory.getLogger(ApiExceptionHandler.class);
+
+    @ExceptionHandler(ResponseStatusException.class)
+    public ResponseEntity<Map<String, Object>> handleStatus(ResponseStatusException e) {
+        return body(e.getStatusCode().value(), e.getReason());
+    }
+
+    @ExceptionHandler(IllegalArgumentException.class)
+    public ResponseEntity<Map<String, Object>> handleBadRequest(IllegalArgumentException e) {
+        return body(400, e.getMessage());
+    }
+
+    @ExceptionHandler(HttpMessageNotReadableException.class)
+    public ResponseEntity<Map<String, Object>> handleUnreadable(HttpMessageNotReadableException e) {
+        return body(400, "Ungültiger Request-Body.");
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<Map<String, Object>> handleValidation(MethodArgumentNotValidException e) {
+        String details = e.getBindingResult().getFieldErrors().stream()
+                .map(f -> f.getField() + ": " + fieldMessage(f))
+                .collect(Collectors.joining("; "));
+        return body(400, details.isBlank() ? "Validierung fehlgeschlagen." : details);
+    }
+
+    /** Security-Fehler NICHT schlucken – die behandelt Spring Security selbst (403/Login). */
+    @ExceptionHandler(AccessDeniedException.class)
+    public void rethrowAccessDenied(AccessDeniedException e) {
+        throw e;
+    }
+
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<Map<String, Object>> handleServerError(Exception e) {
+        log.error("Unbehandelter API-Fehler", e);
+        return body(500, "Interner Fehler. Bitte später erneut versuchen.");
+    }
+
+    private static String fieldMessage(FieldError f) {
+        return f.getDefaultMessage() == null ? "ungültig" : f.getDefaultMessage();
+    }
+
+    private ResponseEntity<Map<String, Object>> body(int status, String message) {
+        return ResponseEntity.status(status).body(Map.of(
+                "error", true,
+                "status", status,
+                "message", message == null || message.isBlank() ? "Fehler" : message));
+    }
+}

src/main/java/com/example/mindflux/controller/CodeEscapeApiController.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.controller; import com.example.mindflux.dto.*;import com.example.mindflux.service.CodeEscapeService;import com.fasterxml.jackson.databind.JsonNode;import jakarta.servlet.http.HttpSession;import org.springframework.web.bind.annotation.*;import java.security.Principal;
+@RestController @RequestMapping("/api/codeescape") public class CodeEscapeApiController {private final CodeEscapeService service;public CodeEscapeApiController(CodeEscapeService s){service=s;}@GetMapping("/scenarios")public JsonNode catalog(){return service.catalog();}@GetMapping("/session/{slug}")public JsonNode session(@PathVariable String slug,HttpSession s){return service.session(slug,s);}@PostMapping("/check")public JsonNode check(@RequestBody EscapeCheckRequest r,HttpSession s){return service.check(r.getPuzzleId(),r.isReveal(),r.getSubmission(),s);}@PostMapping("/door")public JsonNode door(@RequestBody EscapeDoorRequest r,HttpSession s){return service.door(r.getRoomId(),r.getCode(),s);}@PostMapping("/hint")public JsonNode hint(@RequestBody EscapeHintRequest r,HttpSession s){return service.hint(r.getPuzzleId(),r.getLevel(),s);}@PostMapping("/finish")public EscapeResult finish(@RequestBody EscapeFinishRequest r,Principal p,HttpSession s){return service.finish(p.getName(),r,s);}}

src/main/java/com/example/mindflux/controller/CodeEscapeController.java

@@ -0,0 +1 @@
+package com.example.mindflux.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping; @Controller public class CodeEscapeController{@GetMapping("/codeescape")public String page(){return "codeescape";}}

src/main/java/com/example/mindflux/controller/DashboardController.java

@@ -1,13 +1,25 @@
 package com.example.mindflux.controller;
 
+import com.example.mindflux.service.ProgressService;
 import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.GetMapping;
 
+import java.security.Principal;
+
 @Controller
 public class DashboardController {
 
+    private final ProgressService progressService;
+
+    public DashboardController(ProgressService progressService) {
+        this.progressService = progressService;
+    }
+
     @GetMapping("/dashboard")
-    public String showDashboard() {
-        return "dashboard"; // lädt dashboard.html aus templates
+    public String showDashboard(Model model, Principal principal) {
+        // Echte XP/Level/Streak-Werte für die Sidebar-Widgets (statt Dummy-Daten im Template).
+        model.addAttribute("overall", progressService.getOverallProgress(principal.getName()));
+        return "dashboard";
     }
 }

src/main/java/com/example/mindflux/controller/GameScoreController.java

@@ -21,8 +21,8 @@ public class GameScoreController {
 
     /** Bekannte Spiele (entsprechen den Dashboard-Routen). */
     private static final Set<String> KNOWN_GAMES = Set.of(
-            "mindmatch", "techtacular", "syntax-saga", "devlab", "escape-room",
-            "service-clash", "bug-hunter", "netzwerker");
+            "mindmatch", "techtacular", "syntax-saga", "devlab", "codeescape",
+            "serviceclash", "bughunter", "networker");
 
     private final GameScoreService gameScoreService;
 

src/main/java/com/example/mindflux/controller/GlobalExceptionHandler.java

@@ -0,0 +1,60 @@
+package com.example.mindflux.controller;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.servlet.resource.NoResourceFoundException;
+
+/**
+ * Fängt Fehler aus den HTML-Controllern ab und zeigt eine gestaltete Fehlerseite
+ * statt der Whitelabel-Seite. Die JSON-APIs behandelt der ApiExceptionHandler
+ * (höhere Präzedenz, greift nur für @RestController).
+ */
+@ControllerAdvice
+@Order(Ordered.LOWEST_PRECEDENCE)
+public class GlobalExceptionHandler {
+
+    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
+
+    /** Ungültige IDs/Parameter (z. B. Admin-Formulare) -> 400 mit lesbarer Meldung. */
+    @ExceptionHandler(IllegalArgumentException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public String handleBadRequest(IllegalArgumentException e, Model model) {
+        model.addAttribute("status", 400);
+        model.addAttribute("friendlyMessage",
+                e.getMessage() == null ? "Ungültige Anfrage." : e.getMessage());
+        return "error";
+    }
+
+    /** Unbekannte URL -> echte 404-Seite (darf nicht im Catch-all als 500 landen). */
+    @ExceptionHandler(NoResourceFoundException.class)
+    @ResponseStatus(HttpStatus.NOT_FOUND)
+    public String handleNotFound(NoResourceFoundException e, Model model) {
+        model.addAttribute("status", 404);
+        model.addAttribute("friendlyMessage", "Diese Seite existiert nicht (mehr).");
+        return "error";
+    }
+
+    /** Security-Fehler NICHT schlucken – die behandelt Spring Security selbst (403/Login). */
+    @ExceptionHandler(AccessDeniedException.class)
+    public void rethrowAccessDenied(AccessDeniedException e) {
+        throw e;
+    }
+
+    @ExceptionHandler(Exception.class)
+    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+    public String handleServerError(Exception e, Model model) {
+        log.error("Unbehandelter Fehler", e);
+        model.addAttribute("status", 500);
+        model.addAttribute("friendlyMessage",
+                "Ein unerwarteter Fehler ist aufgetreten. Bitte versuche es erneut.");
+        return "error";
+    }
+}

src/main/java/com/example/mindflux/controller/ProfileController.java

@@ -2,6 +2,8 @@ package com.example.mindflux.controller;
 
 import com.example.mindflux.model.User;
 import com.example.mindflux.service.UserService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
@@ -29,6 +31,8 @@ import java.util.UUID;
 @Controller
 public class ProfileController {
 
+    private static final Logger log = LoggerFactory.getLogger(ProfileController.class);
+
     @Autowired
     private UserService userService;
 
@@ -61,19 +65,17 @@ public class ProfileController {
             if (profilePicture != null && !profilePicture.trim().isEmpty()) {
                 try {
                     Path picturePath = Paths.get(System.getProperty("user.dir"), "uploads", "profiles", profilePicture);
-                    System.out.println("Versuche zu löschen: " + picturePath.toAbsolutePath());
-
                     if (Files.exists(picturePath)) {
                         Files.delete(picturePath);
-                        System.out.println("Datei erfolgreich gelöscht: " + picturePath.getFileName());
+                        log.info("Profilbild gelöscht: {}", picturePath.getFileName());
                     } else {
-                        System.out.println("Datei existiert nicht: " + picturePath.toAbsolutePath());
+                        log.warn("Profilbild-Datei existiert nicht: {}", picturePath.toAbsolutePath());
                     }
                 } catch (IOException e) {
-                    System.err.println("Fehler beim Löschen der Datei: " + e.getMessage());
+                    log.error("Fehler beim Löschen der Profilbild-Datei", e);
                 }
             } else {
-                System.out.println("Kein Profilbild gesetzt, nichts zu löschen.");
+                log.debug("Kein Profilbild gesetzt, nichts zu löschen.");
             }
 
             existingUser.setProfilePicture(null); // Wichtig: auch wenn Datei nicht existiert
@@ -83,6 +85,12 @@ public class ProfileController {
         return "redirect:/profile?success=true";
     }
 
+    /** Einstellungen gehören zum Profilbereich – eine Zuständigkeit, ein Controller. */
+    @GetMapping("/profile/settings")
+    public String settings() {
+        return "settings";
+    }
+
     @GetMapping("/profile/knowledge")
     public String knowledgeCenter(Model model, Principal principal) {
         String username = principal.getName();
@@ -107,7 +115,7 @@ public class ProfileController {
                     BufferedImage original = ImageIO.read(file.getInputStream());
                     if (original == null) {
                         // Keine lesbare Bilddatei -> Upload ignorieren, restliches Profil trotzdem speichern.
-                        System.out.println("Profilbild-Upload ignoriert: keine lesbare Bilddatei.");
+                        log.warn("Profilbild-Upload ignoriert: keine lesbare Bilddatei.");
                     } else {
                         // Auf max. Kantenlänge herunterskalieren (kein Hochskalieren).
                         final int MAX_DIM = 400;
@@ -141,7 +149,7 @@ public class ProfileController {
                         existingUser.setProfilePicture(fileName);
                     }
                 } catch (IOException e) {
-                    e.printStackTrace();
+                    log.error("Fehler beim Speichern des Profilbilds", e);
                 }
             }
 
@@ -189,7 +197,7 @@ public class ProfileController {
                     Path picturePath = Paths.get(System.getProperty("user.dir"), "uploads", "profiles", profilePicture);
                     Files.deleteIfExists(picturePath);
                 } catch (IOException e) {
-                    System.err.println("Fehler beim Löschen des Profilbilds: " + e.getMessage());
+                    log.error("Fehler beim Löschen des Profilbilds", e);
                 }
             }
         }
@@ -198,12 +206,4 @@ public class ProfileController {
         new SecurityContextLogoutHandler().logout(request, response, authentication);
         return "redirect:/?logout";
     }
-
-    // Hilfsmethode: Dateiendung extrahieren
-    private String getFileExtension(String filename) {
-        if (filename == null || filename.lastIndexOf(".") == -1) {
-            return "";
-        }
-        return filename.substring(filename.lastIndexOf("."));
-    }
 }

src/main/java/com/example/mindflux/controller/RegisterController.java

@@ -1,44 +1,39 @@
 package com.example.mindflux.controller;
 
-import com.example.mindflux.model.User;
+import com.example.mindflux.service.RegistrationResult;
 import com.example.mindflux.service.UserService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Controller;
-import org.springframework.ui.Model;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
 
 @Controller
 public class RegisterController {
 
-    @Autowired
-    private UserService userService;
+    private final UserService userService;
 
-    @Autowired
-    private PasswordEncoder passwordEncoder;
+    public RegisterController(UserService userService) {
+        this.userService = userService;
+    }
 
     @GetMapping("/register")
-    public String showRegistrationForm(Model model) {
-        model.addAttribute("user", new User());
-        return "register";
+    public String showRegistrationForm() {
+        // Die eigenständige Registrierungsseite wurde entfernt – das Formular lebt auf der Startseite.
+        return "redirect:/";
     }
 
     @PostMapping("/register")
-    public String processRegistration(@ModelAttribute("user") User user, Model model) {
-        // Benutzername klein schreiben, um Doppelungen zu vermeiden
-        user.setUsername(user.getUsername().toLowerCase());
-
-        // Prüfen, ob Benutzername schon existiert
-        if (userService.findByUsername(user.getUsername()) != null) {
-            // Zurück zur kombinierten Login/Signup-Seite mit geöffnetem Signup-Panel
-            return "redirect:/?registerError";
-        }
-
-        // Passwort verschlüsseln
-        user.setPassword(passwordEncoder.encode(user.getPassword()));
-        user.setRole("USER"); // Standardrolle
-        userService.save(user);
-
-        return "redirect:/?registerSuccess"; // zurück zum Login mit Erfolgsmeldung
+    public String processRegistration(@RequestParam String username,
+                                      @RequestParam String email,
+                                      @RequestParam String password,
+                                      @RequestParam(required = false) String confirmPassword) {
+        RegistrationResult result = userService.register(username, email, password, confirmPassword);
+        return switch (result) {
+            case SUCCESS -> "redirect:/?registerSuccess";
+            case PASSWORD_MISMATCH -> "redirect:/?passwordMismatch";
+            case PASSWORD_TOO_SHORT -> "redirect:/?passwordPolicy";
+            case EMAIL_INVALID -> "redirect:/?emailInvalid";
+            case USERNAME_INVALID, USERNAME_TAKEN -> "redirect:/?registerError";
+        };
     }
-}
+}

src/main/java/com/example/mindflux/controller/SettingsController.java

@@ -1,13 +0,0 @@
-package com.example.mindflux.controller;
-
-import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.GetMapping;
-
-@Controller
-public class SettingsController {
-
-    @GetMapping("/profile/settings")
-    public String showSettingsPage() {
-        return "settings"; // lädt templates/settings.html
-    }
-}

src/main/java/com/example/mindflux/controller/UserController.java

@@ -1,67 +1,72 @@
 package com.example.mindflux.controller;
 
 import com.example.mindflux.model.User;
-import com.example.mindflux.repository.UserRepository;
-import org.springframework.beans.factory.annotation.Autowired;
+import com.example.mindflux.service.UserService;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
-import java.util.Optional;
 
 @RestController
 @RequestMapping("/api/users")
 public class UserController {
 
-    @Autowired
-    private UserRepository userRepository;
+    private final UserService userService;
+    private final PasswordEncoder passwordEncoder;
 
-    @Autowired
-    private PasswordEncoder passwordEncoder;
+    public UserController(UserService userService, PasswordEncoder passwordEncoder) {
+        this.userService = userService;
+        this.passwordEncoder = passwordEncoder;
+    }
 
-    // 📥 User erstellen
+    // 📥 User erstellen (Validierung, Eindeutigkeit und Encoding zentral im UserService)
     @PostMapping
     public User createUser(@RequestBody User user) {
-        user.setPassword(passwordEncoder.encode(user.getPassword()));
-        return userRepository.save(user);
+        return userService.createUser(user.getUsername(), user.getEmail(), user.getPassword(), user.getRole());
     }
 
     // 📋 Alle User anzeigen
     @GetMapping
     public List<User> getAllUsers() {
-        return userRepository.findAll();
+        return userService.findAll();
     }
 
     // 📍 Einzelnen User anzeigen
     @GetMapping("/{id}")
     public ResponseEntity<User> getUserById(@PathVariable Long id) {
-        Optional<User> user = userRepository.findById(id);
-        return user.map(ResponseEntity::ok)
-                   .orElseGet(() -> ResponseEntity.notFound().build());
+        return userService.findById(id)
+                .map(ResponseEntity::ok)
+                .orElseGet(() -> ResponseEntity.notFound().build());
     }
 
     // ✏️ User aktualisieren
     @PutMapping("/{id}")
     public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User updatedUser) {
-        return userRepository.findById(id).map(user -> {
-            user.setUsername(updatedUser.getUsername());
+        return userService.findById(id).map(user -> {
+            String newName = updatedUser.getUsername() == null ? "" : updatedUser.getUsername().trim();
+            if (newName.isBlank()) {
+                throw new IllegalArgumentException("Ungültiger Benutzername.");
+            }
+            userService.assertUsernameAvailable(newName, id);
+            user.setUsername(newName);
             if (updatedUser.getPassword() != null && !updatedUser.getPassword().isBlank()) {
                 user.setPassword(passwordEncoder.encode(updatedUser.getPassword()));
             }
             user.setEmail(updatedUser.getEmail());
-            user.setRole(updatedUser.getRole());
-            return ResponseEntity.ok(userRepository.save(user));
+            user.setRole(userService.validateRole(updatedUser.getRole()));
+            userService.save(user);
+            return ResponseEntity.ok(user);
         }).orElseGet(() -> ResponseEntity.notFound().build());
     }
 
-    // 🗑️ User löschen
+    // 🗑️ User löschen (inkl. zugehöriger Scores/Achievements)
     @DeleteMapping("/{id}")
     public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
-        if (userRepository.existsById(id)) {
-            userRepository.deleteById(id);
-            return ResponseEntity.noContent().build();
+        if (userService.findById(id).isEmpty()) {
+            return ResponseEntity.notFound().build();
         }
-        return ResponseEntity.notFound().build();
+        userService.deleteById(id);
+        return ResponseEntity.noContent().build();
     }
 }

src/main/java/com/example/mindflux/controller/UserViewController.java

@@ -1,31 +0,0 @@
-package com.example.mindflux.controller;
-
-import com.example.mindflux.model.User;
-import com.example.mindflux.repository.UserRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Controller;
-import org.springframework.ui.Model;
-import org.springframework.web.bind.annotation.*;
-
-@Controller
-@RequestMapping("/users")
-public class UserViewController {
-
-    @Autowired
-    private UserRepository userRepository;
-
-    // Formular anzeigen
-    @GetMapping("/form")
-    public String showForm(Model model) {
-        model.addAttribute("user", new User());
-        return "user-form";
-    }
-
-    // Benutzer speichern
-    @PostMapping("/save")
-    public String saveUser(@ModelAttribute User user) {
-        userRepository.save(user);
-        return "user-success"; // statt redirect
-    }
-
-}

src/main/java/com/example/mindflux/dto/EscapeCheckRequest.java

@@ -0,0 +1 @@
+package com.example.mindflux.dto; import com.fasterxml.jackson.databind.JsonNode; public class EscapeCheckRequest {private Long puzzleId;private boolean reveal;private JsonNode submission;public Long getPuzzleId(){return puzzleId;}public void setPuzzleId(Long v){puzzleId=v;}public boolean isReveal(){return reveal;}public void setReveal(boolean v){reveal=v;}public JsonNode getSubmission(){return submission;}public void setSubmission(JsonNode v){submission=v;}}

src/main/java/com/example/mindflux/dto/EscapeDoorRequest.java

@@ -0,0 +1 @@
+package com.example.mindflux.dto; public class EscapeDoorRequest {private Long roomId;private String code;public Long getRoomId(){return roomId;}public void setRoomId(Long v){roomId=v;}public String getCode(){return code;}public void setCode(String v){code=v;}}

src/main/java/com/example/mindflux/dto/EscapeFinishRequest.java

@@ -0,0 +1 @@
+package com.example.mindflux.dto; import com.fasterxml.jackson.databind.JsonNode; import java.util.*; public class EscapeFinishRequest {private String slug;private int durationSeconds;private boolean escaped;private List<Item> items=new ArrayList<>();private List<Door> doors=new ArrayList<>();public String getSlug(){return slug;}public void setSlug(String v){slug=v;}public int getDurationSeconds(){return durationSeconds;}public void setDurationSeconds(int v){durationSeconds=v;}public boolean isEscaped(){return escaped;}public void setEscaped(boolean v){escaped=v;}public List<Item> getItems(){return items;}public void setItems(List<Item> v){items=v;}public List<Door> getDoors(){return doors;}public void setDoors(List<Door> v){doors=v;}public static class Item{private Long puzzleId;private JsonNode submission;public Long getPuzzleId(){return puzzleId;}public void setPuzzleId(Long v){puzzleId=v;}public JsonNode getSubmission(){return submission;}public void setSubmission(JsonNode v){submission=v;}}public static class Door{private Long roomId;private String code;public Long getRoomId(){return roomId;}public void setRoomId(Long v){roomId=v;}public String getCode(){return code;}public void setCode(String v){code=v;}}}

src/main/java/com/example/mindflux/dto/EscapeHintRequest.java

@@ -0,0 +1 @@
+package com.example.mindflux.dto; public class EscapeHintRequest {private Long puzzleId;private int level;public Long getPuzzleId(){return puzzleId;}public void setPuzzleId(Long v){puzzleId=v;}public int getLevel(){return level;}public void setLevel(int v){level=v;}}

src/main/java/com/example/mindflux/dto/EscapeResult.java

@@ -0,0 +1 @@
+package com.example.mindflux.dto; public record EscapeResult(int score,int baseScore,int maxScore,int timeBonus,int solvedPuzzles,int roomsOpened,boolean escaped,int stars,int highscore,boolean newHighscore,long plays){}

src/main/java/com/example/mindflux/dto/ProgressData.java

@@ -6,6 +6,15 @@ public class ProgressData {
     private int xpForNextLevel;
     private int userLevel;
     private int progressPercent;
+    private int streakDays;
+
+    public int getStreakDays() {
+        return streakDays;
+    }
+
+    public void setStreakDays(int streakDays) {
+        this.streakDays = streakDays;
+    }
 
     public int getCorrectAnswers() {
         return correctAnswers;

src/main/java/com/example/mindflux/model/EscapePuzzle.java

@@ -0,0 +1,7 @@
+package com.example.mindflux.model;
+import jakarta.persistence.*;
+@Entity @Table(name="escape_puzzles") public class EscapePuzzle {
+ @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id; @ManyToOne(fetch=FetchType.LAZY) @JoinColumn(name="room_id") private EscapeRoom room;
+ @Column(name="puzzle_type") private String type; private String prompt; private int points=100; @Column(name="code_fragment") private String codeFragment; @Column(name="sort_order") private int sortOrder; private String payload;
+ public EscapePuzzle(){} public EscapePuzzle(String t,String p,int pts,String f,int o,String j){type=t;prompt=p;points=pts;codeFragment=f;sortOrder=o;payload=j;} public Long getId(){return id;} public void setId(Long v){id=v;} public EscapeRoom getRoom(){return room;} public void setRoom(EscapeRoom v){room=v;} public String getType(){return type;} public void setType(String v){type=v;} public String getPrompt(){return prompt;} public void setPrompt(String v){prompt=v;} public int getPoints(){return points;} public void setPoints(int v){points=v;} public String getCodeFragment(){return codeFragment;} public void setCodeFragment(String v){codeFragment=v;} public int getSortOrder(){return sortOrder;} public void setSortOrder(int v){sortOrder=v;} public String getPayload(){return payload;} public void setPayload(String v){payload=v;}
+}

src/main/java/com/example/mindflux/model/EscapeRoom.java

@@ -0,0 +1,9 @@
+package com.example.mindflux.model;
+import jakarta.persistence.*; import java.util.*;
+@Entity @Table(name="escape_rooms")
+public class EscapeRoom {
+ @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id; @ManyToOne(fetch=FetchType.LAZY) @JoinColumn(name="scenario_id") private EscapeScenario scenario;
+ private String title; private String intro; @Column(name="door_prompt") private String doorPrompt; @Column(name="door_code") private String doorCode; @Column(name="success_text") private String successText; @Column(name="sort_order") private int sortOrder;
+ @OneToMany(mappedBy="room",cascade=CascadeType.ALL,orphanRemoval=true) @OrderBy("sortOrder ASC, id ASC") private List<EscapePuzzle> puzzles=new ArrayList<>();
+ public EscapeRoom(){} public EscapeRoom(String t,String i,String p,String c,String s,int o){title=t;intro=i;doorPrompt=p;doorCode=c;successText=s;sortOrder=o;} public void addPuzzle(EscapePuzzle p){p.setRoom(this);puzzles.add(p);} public Long getId(){return id;} public void setId(Long v){id=v;} public EscapeScenario getScenario(){return scenario;} public void setScenario(EscapeScenario v){scenario=v;} public String getTitle(){return title;} public void setTitle(String v){title=v;} public String getIntro(){return intro;} public void setIntro(String v){intro=v;} public String getDoorPrompt(){return doorPrompt;} public void setDoorPrompt(String v){doorPrompt=v;} public String getDoorCode(){return doorCode;} public void setDoorCode(String v){doorCode=v;} public String getSuccessText(){return successText;} public void setSuccessText(String v){successText=v;} public int getSortOrder(){return sortOrder;} public void setSortOrder(int v){sortOrder=v;} public List<EscapePuzzle> getPuzzles(){return puzzles;}
+}

src/main/java/com/example/mindflux/model/EscapeScenario.java

@@ -0,0 +1,13 @@
+package com.example.mindflux.model;
+import jakarta.persistence.*; import java.util.*;
+@Entity @Table(name="escape_scenarios")
+public class EscapeScenario {
+ @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id;
+ @Column(unique=true,nullable=false) private String slug; private String title; private String difficulty;
+ @Column(name="exam_scope") private String examScope="AP1"; private String description;
+ @Column(name="time_limit_seconds") private int timeLimitSeconds=900;
+ @Column(name="sort_order") private int sortOrder; private boolean active=true;
+ @OneToMany(mappedBy="scenario",cascade=CascadeType.ALL,orphanRemoval=true) @OrderBy("sortOrder ASC, id ASC") private List<EscapeRoom> rooms=new ArrayList<>();
+ public EscapeScenario(){} public EscapeScenario(String slug,String title,String difficulty,String examScope,String description,int limit,int order){this.slug=slug;this.title=title;this.difficulty=difficulty;this.examScope=examScope;this.description=description;this.timeLimitSeconds=limit;this.sortOrder=order;}
+ public void addRoom(EscapeRoom r){r.setScenario(this);rooms.add(r);} public Long getId(){return id;} public void setId(Long v){id=v;} public String getSlug(){return slug;} public void setSlug(String v){slug=v;} public String getTitle(){return title;} public void setTitle(String v){title=v;} public String getDifficulty(){return difficulty;} public void setDifficulty(String v){difficulty=v;} public String getExamScope(){return examScope;} public void setExamScope(String v){examScope=v;} public String getDescription(){return description;} public void setDescription(String v){description=v;} public int getTimeLimitSeconds(){return timeLimitSeconds;} public void setTimeLimitSeconds(int v){timeLimitSeconds=v;} public int getSortOrder(){return sortOrder;} public void setSortOrder(int v){sortOrder=v;} public boolean isActive(){return active;} public void setActive(boolean v){active=v;} public List<EscapeRoom> getRooms(){return rooms;}
+}

src/main/java/com/example/mindflux/repository/AdminUserRepository.java

@@ -1,7 +0,0 @@
-package com.example.mindflux.repository;
-
-import com.example.mindflux.model.User;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-public interface AdminUserRepository extends JpaRepository<User, Long> {
-}

src/main/java/com/example/mindflux/repository/EscapePuzzleRepository.java

@@ -0,0 +1 @@
+package com.example.mindflux.repository; import com.example.mindflux.model.EscapePuzzle; import org.springframework.data.jpa.repository.JpaRepository; public interface EscapePuzzleRepository extends JpaRepository<EscapePuzzle,Long>{long countByRoomId(Long id);}

src/main/java/com/example/mindflux/repository/EscapeRoomRepository.java

@@ -0,0 +1 @@
+package com.example.mindflux.repository; import com.example.mindflux.model.EscapeRoom; import org.springframework.data.jpa.repository.JpaRepository; public interface EscapeRoomRepository extends JpaRepository<EscapeRoom,Long>{long countByScenarioId(Long id);}

src/main/java/com/example/mindflux/repository/EscapeScenarioRepository.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.repository; import com.example.mindflux.model.EscapeScenario; import org.springframework.data.jpa.repository.JpaRepository; import java.util.*;
+public interface EscapeScenarioRepository extends JpaRepository<EscapeScenario,Long>{List<EscapeScenario> findAllByActiveTrueOrderBySortOrderAscIdAsc();List<EscapeScenario> findAllByOrderBySortOrderAscIdAsc();Optional<EscapeScenario> findBySlug(String slug);boolean existsBySlug(String slug);}

src/main/java/com/example/mindflux/repository/GameScoreRepository.java

@@ -2,7 +2,10 @@ package com.example.mindflux.repository;
 
 import com.example.mindflux.model.GameScore;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 
+import java.util.List;
 import java.util.Optional;
 
 public interface GameScoreRepository extends JpaRepository<GameScore, Long> {
@@ -18,4 +21,24 @@ public interface GameScoreRepository extends JpaRepository<GameScore, Long> {
 
     /** Alle Spielstände eines Spielers löschen (z. B. beim Löschen des Kontos). */
     void deleteByUsername(String username);
+
+    /** Gesamtsumme aller Scores eines Spielers (XP-Basis). */
+    @Query("select coalesce(sum(g.score), 0) from GameScore g where g.username = :username")
+    long sumScoreByUsername(@Param("username") String username);
+
+    /** Summe der moves-Werte (je nach Spiel gelöste Aufgaben/richtige Antworten). */
+    @Query("select coalesce(sum(g.moves), 0) from GameScore g where g.username = :username")
+    long sumMovesByUsername(@Param("username") String username);
+
+    /** Gesamtzahl gespielter Runden über alle Spiele. */
+    long countByUsername(String username);
+
+    /** Anzahl verschiedener Spiele, die der Spieler gespielt hat. */
+    @Query("select count(distinct g.game) from GameScore g where g.username = :username")
+    long countDistinctGamesByUsername(@Param("username") String username);
+
+    /** Alle Spieltage (distinct, absteigend) – Basis für die Streak-Berechnung. */
+    @Query(value = "select distinct cast(played_at as date) from game_scores where username = :username order by 1 desc",
+           nativeQuery = true)
+    List<java.sql.Date> findDistinctPlayDaysDesc(@Param("username") String username);
 }

src/main/java/com/example/mindflux/repository/TechtacularCategoryRepository.java

@@ -2,6 +2,7 @@ package com.example.mindflux.repository;
 
 import com.example.mindflux.model.TechtacularCategory;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
 
 import java.util.List;
 
@@ -12,4 +13,8 @@ public interface TechtacularCategoryRepository extends JpaRepository<Techtacular
     List<TechtacularCategory> findAllByOrderBySortOrderAscIdAsc();
 
     boolean existsBySlug(String slug);
+
+    /** Aktive Kategorien inkl. Fragen in einem Rutsch (vermeidet N+1 beim Board-Aufbau). */
+    @Query("select distinct c from TechtacularCategory c join fetch c.questions where c.active = true")
+    List<TechtacularCategory> findActiveWithQuestions();
 }

src/main/java/com/example/mindflux/repository/TechtacularQuestionRepository.java

@@ -2,8 +2,22 @@ package com.example.mindflux.repository;
 
 import com.example.mindflux.model.TechtacularQuestion;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+
+import java.util.List;
 
 public interface TechtacularQuestionRepository extends JpaRepository<TechtacularQuestion, Long> {
 
     long countByCategoryId(Long categoryId);
+
+    /**
+     * Initialisiert die Antwort-Collections aller Fragen aktiver Kategorien im selben
+     * Persistence Context (zweite Query des 2-Query-Musters gegen N+1 beim Board-Aufbau).
+     */
+    @Query("select distinct q from TechtacularQuestion q join fetch q.answers where q.category.active = true")
+    List<TechtacularQuestion> findActiveWithAnswers();
+
+    /** Fragenanzahl je Kategorie als eine GROUP-BY-Query statt eines Counts pro Zeile. */
+    @Query("select q.category.id, count(q) from TechtacularQuestion q group by q.category.id")
+    List<Object[]> countGroupedByCategory();
 }

src/main/java/com/example/mindflux/repository/UserRepository.java

@@ -9,6 +9,9 @@ public interface UserRepository extends JpaRepository<User, Long> {
     // Benutzer anhand des Benutzernamens suchen
     Optional<User> findByUsername(String username);
 
+    // Case-insensitive Suche: Login und Registrierung sollen unabhängig von Groß-/Kleinschreibung greifen
+    Optional<User> findByUsernameIgnoreCase(String username);
+
     // Benutzer anhand des Benutzernamens löschen
     void deleteByUsername(String username);
 }

src/main/java/com/example/mindflux/service/AchievementService.java

@@ -5,5 +5,13 @@ import com.example.mindflux.model.Achievement;
 import java.util.List;
 
 public interface AchievementService {
+
+    /** Kompletter Katalog: verdiente Achievements mit Datum, restliche als gesperrt. */
     List<Achievement> getAchievementsForUser(String username);
-}
+
+    /**
+     * Prüft nach einem gespeicherten Spielergebnis alle Regeln und vergibt neue
+     * Achievements idempotent. Wird aus GameScoreService.recordScore() aufgerufen.
+     */
+    void checkAndAward(String username, String game, int score, boolean newHighscore, long playsInGame);
+}

src/main/java/com/example/mindflux/service/AchievementServiceImpl.java

@@ -2,19 +2,82 @@ package com.example.mindflux.service;
 
 import com.example.mindflux.model.Achievement;
 import com.example.mindflux.repository.AchievementRepository;
-import org.springframework.beans.factory.annotation.Autowired;
+import com.example.mindflux.repository.GameScoreRepository;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 @Service
 public class AchievementServiceImpl implements AchievementService {
 
-    @Autowired
-    private AchievementRepository achievementRepository;
+    /** Katalog aller Achievements (Titel -> Beschreibung), in Anzeige-Reihenfolge. */
+    static final Map<String, String> CATALOG = new LinkedHashMap<>();
+    static {
+        CATALOG.put("Erster Sieg", "Schließe dein erstes Spiel ab.");
+        CATALOG.put("1000er-Club", "Erziele 1000 Punkte in einer einzigen Runde.");
+        CATALOG.put("Highscore-Jäger", "Verbessere deinen eigenen Highscore.");
+        CATALOG.put("Dauerbrenner", "Spiele dasselbe Spiel zehnmal.");
+        CATALOG.put("Punktesammler", "Sammle insgesamt 5000 Punkte.");
+        CATALOG.put("Allrounder", "Spiele vier verschiedene Spiele.");
+    }
+
+    private final AchievementRepository achievementRepository;
+    private final GameScoreRepository gameScoreRepository;
+
+    public AchievementServiceImpl(AchievementRepository achievementRepository,
+                                  GameScoreRepository gameScoreRepository) {
+        this.achievementRepository = achievementRepository;
+        this.gameScoreRepository = gameScoreRepository;
+    }
 
     @Override
     public List<Achievement> getAchievementsForUser(String username) {
-        return achievementRepository.findByUsername(username);
+        List<Achievement> earned = achievementRepository.findByUsername(username);
+        Map<String, Achievement> earnedByTitle = earned.stream()
+                .collect(Collectors.toMap(Achievement::getTitle, a -> a, (a, b) -> a));
+
+        List<Achievement> result = new ArrayList<>();
+        // Katalog in fester Reihenfolge: verdient mit Datum, sonst als gesperrte Karte.
+        CATALOG.forEach((title, description) -> {
+            Achievement achievement = earnedByTitle.remove(title);
+            result.add(achievement != null ? achievement
+                    : new Achievement(title, description, null, false));
+        });
+        // Ältere/zusätzliche verdiente Achievements außerhalb des Katalogs behalten.
+        result.addAll(earnedByTitle.values());
+        return result;
     }
-}
+
+    @Override
+    @Transactional
+    public void checkAndAward(String username, String game, int score, boolean newHighscore, long playsInGame) {
+        Set<String> existing = achievementRepository.findByUsername(username).stream()
+                .map(Achievement::getTitle)
+                .collect(Collectors.toSet());
+
+        award(existing, username, "Erster Sieg",
+                gameScoreRepository.countByUsername(username) >= 1);
+        award(existing, username, "1000er-Club", score >= 1000);
+        award(existing, username, "Highscore-Jäger", newHighscore && playsInGame > 1);
+        award(existing, username, "Dauerbrenner", playsInGame >= 10);
+        award(existing, username, "Punktesammler",
+                gameScoreRepository.sumScoreByUsername(username) >= 5000);
+        award(existing, username, "Allrounder",
+                gameScoreRepository.countDistinctGamesByUsername(username) >= 4);
+    }
+
+    private void award(Set<String> existing, String username, String title, boolean condition) {
+        if (!condition || existing.contains(title)) {
+            return;
+        }
+        Achievement achievement = new Achievement(title, CATALOG.get(title), null, true);
+        achievement.setUsername(username);
+        achievementRepository.save(achievement);
+    }
+}

src/main/java/com/example/mindflux/service/AdminUserService.java

@@ -1,32 +0,0 @@
-package com.example.mindflux.service;
-
-import com.example.mindflux.model.User;
-import com.example.mindflux.repository.AdminUserRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.util.List;
-import java.util.Optional;
-
-@Service
-public class AdminUserService {
-
-    @Autowired
-    private AdminUserRepository userRepository;
-
-    public List<User> findAll() {
-        return userRepository.findAll();
-    }
-
-    public Optional<User> findById(Long id) {
-        return userRepository.findById(id);
-    }
-
-    public User save(User user) {
-        return userRepository.save(user);
-    }
-
-    public void deleteById(Long id) {
-        userRepository.deleteById(id);
-    }
-}

src/main/java/com/example/mindflux/service/CodeEscapeService.java

@@ -0,0 +1,26 @@
+package com.example.mindflux.service;
+import com.example.mindflux.dto.*; import com.example.mindflux.model.*; import com.example.mindflux.repository.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.node.*; import jakarta.servlet.http.HttpSession; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.util.*;
+@Service public class CodeEscapeService {
+ public static final String GAME="codeescape"; private static final Set<String>TYPES=Set.of("code","choice","order","match"),SCOPES=Set.of("AP1","AP2_FIAE","AP2_FISI","CROSS"); private static final int MAX_ITEMS=40;
+ private final EscapeScenarioRepository scenarios;private final EscapeRoomRepository rooms;private final EscapePuzzleRepository puzzles;private final GameScoreService scores;private final ObjectMapper mapper;
+ public CodeEscapeService(EscapeScenarioRepository s,EscapeRoomRepository r,EscapePuzzleRepository p,GameScoreService g,ObjectMapper m){scenarios=s;rooms=r;puzzles=p;scores=g;mapper=m;}
+ public static class RunState implements java.io.Serializable {public Long scenarioId;public String slug;public final List<Long>roomIds=new ArrayList<>();public final Set<Long>puzzleIds=new HashSet<>();public final Map<Long,Integer> attempts=new HashMap<>(),hints=new HashMap<>();public final Set<Long> revealed=new HashSet<>(),resolved=new HashSet<>(),opened=new LinkedHashSet<>();}
+ private RunState state(HttpSession session){Object o=session.getAttribute("codeescape.run");if(o instanceof RunState s&&s.scenarioId!=null)return s;throw new IllegalArgumentException("Kein aktiver SystemEscape-Run.");}
+ @Transactional(readOnly=true) public JsonNode catalog(){ArrayNode a=mapper.createArrayNode();for(EscapeScenario s:scenarios.findAllByActiveTrueOrderBySortOrderAscIdAsc()){if(s.getRooms().isEmpty())continue;ObjectNode n=a.addObject();n.put("slug",s.getSlug());n.put("title",s.getTitle());n.put("difficulty",s.getDifficulty());n.put("examScope",s.getExamScope());n.put("description",s.getDescription());n.put("timeLimitSeconds",s.getTimeLimitSeconds());n.put("roomCount",Math.min(4,s.getRooms().size()));n.put("poolSize",s.getRooms().size());}return mapper.createObjectNode().set("scenarios",a);}
+ @Transactional(readOnly=true) public JsonNode session(String slug,HttpSession http){EscapeScenario s=scenarios.findBySlug(slug).filter(EscapeScenario::isActive).orElseThrow(()->new IllegalArgumentException("Szenario nicht gefunden."));List<EscapeRoom>selected=new ArrayList<>(s.getRooms());Collections.shuffle(selected);selected=selected.subList(0,Math.min(4,selected.size()));RunState st=new RunState();st.scenarioId=s.getId();st.slug=s.getSlug();selected.forEach(r->{st.roomIds.add(r.getId());r.getPuzzles().forEach(p->st.puzzleIds.add(p.getId()));});http.setAttribute("codeescape.run",st);ObjectNode root=mapper.createObjectNode();root.put("slug",s.getSlug());root.put("title",s.getTitle());root.put("difficulty",s.getDifficulty());root.put("examScope",s.getExamScope());root.put("description",s.getDescription());root.put("timeLimitSeconds",s.getTimeLimitSeconds());root.put("poolSize",s.getRooms().size());ArrayNode rs=root.putArray("rooms");int max=0;for(EscapeRoom r:selected){ObjectNode rv=rs.addObject();rv.put("roomId",r.getId());rv.put("title",r.getTitle());rv.put("intro",r.getIntro());rv.put("doorPrompt",r.getDoorPrompt());ArrayNode ps=rv.putArray("puzzles");for(EscapePuzzle p:r.getPuzzles()){ObjectNode pv=sanitize(p);if(pv!=null){ps.add(pv);max+=p.getPoints();}}}root.put("maxScore",max+selected.size()*50);return root;}
+ private ObjectNode sanitize(EscapePuzzle p){JsonNode j=parse(p.getPayload());if(j==null||!TYPES.contains(p.getType()))return null;ObjectNode v=mapper.createObjectNode();v.put("puzzleId",p.getId());v.put("type",p.getType());v.put("prompt",p.getPrompt());v.put("points",p.getPoints());copy(j,v,"narrative");copy(j,v,"instruction");switch(p.getType()){case"code"->copy(j,v,"placeholder");case"choice"->v.set("options",shuffle(strings(j,"options")));case"order"->v.set("items",shuffle(strings(j,"items")));case"match"->{ArrayNode l=v.putArray("left"),r=v.putArray("right");List<String>rr=new ArrayList<>();for(JsonNode pair:array(j,"pairs"))if(pair.isArray()&&pair.size()>1){l.add(pair.get(0).asText());rr.add(pair.get(1).asText());}Collections.shuffle(rr);rr.forEach(r::add);}}return v;}
+ @Transactional(readOnly=true) public JsonNode check(Long id,boolean reveal,JsonNode submission,HttpSession session){RunState st=state(session);if(!st.puzzleIds.contains(id))throw new IllegalArgumentException("Rätsel gehört nicht zu diesem Run.");EscapePuzzle p=puzzles.findById(id).orElseThrow(()->new IllegalArgumentException("Rätsel nicht gefunden."));int attempts=st.attempts.merge(id,1,Integer::sum);if(attempts>3&&!reveal)throw new IllegalArgumentException("Maximale Versuchszahl erreicht.");boolean correct=matches(p,submission);if(reveal)st.revealed.add(id);if(correct||reveal)st.resolved.add(id);ObjectNode out=mapper.createObjectNode();out.put("correct",correct);out.put("resolved",correct||reveal);out.put("attempts",attempts);if(correct||reveal)out.put("fragment",p.getCodeFragment());if(reveal){JsonNode j=parse(p.getPayload());if(j!=null&&j.has("explanation"))out.put("explanation",j.get("explanation").asText());}return out;}
+ @Transactional(readOnly=true) public JsonNode hint(Long id,int level,HttpSession session){RunState st=state(session);if(!st.puzzleIds.contains(id))throw new IllegalArgumentException("Rätsel gehört nicht zu diesem Run.");EscapePuzzle p=puzzles.findById(id).orElseThrow(()->new IllegalArgumentException("Rätsel nicht gefunden."));int lv=Math.max(1,Math.min(2,level));st.hints.merge(id,lv,Math::max);List<String>h=strings(parse(p.getPayload()),"hints");ObjectNode o=mapper.createObjectNode();o.put("level",lv);o.put("text",h.isEmpty()?"Prüfe die Aufgabenstellung noch einmal.":h.get(Math.min(lv-1,h.size()-1)));return o;}
+ @Transactional(readOnly=true) public JsonNode door(Long id,String code,HttpSession session){RunState st=state(session);int next=st.opened.size();if(next>=st.roomIds.size()||!Objects.equals(st.roomIds.get(next),id))throw new IllegalArgumentException("Raum gehört nicht zum aktuellen Abschnitt dieses Runs.");EscapeRoom r=rooms.findById(id).orElseThrow(()->new IllegalArgumentException("Raum nicht gefunden."));boolean complete=r.getPuzzles().stream().allMatch(p->st.resolved.contains(p.getId()));boolean open=complete&&eq(r.getDoorCode(),code,false);if(open)st.opened.add(id);ObjectNode o=mapper.createObjectNode();o.put("open",open);o.put("complete",complete);if(open)o.put("successText",r.getSuccessText());else o.put("message",complete?"Code abgelehnt. Setze die Fragmente von links nach rechts ohne Leerzeichen zusammen.":"Löse zuerst alle Rätsel dieses Raums.");return o;}
+ @Transactional public EscapeResult finish(String user,EscapeFinishRequest req,HttpSession session){RunState st=state(session);EscapeScenario s=scenarios.findBySlug(req.getSlug()).orElseThrow(()->new IllegalArgumentException("Szenario nicht gefunden."));if(!Objects.equals(st.scenarioId,s.getId())||!Objects.equals(st.slug,req.getSlug()))throw new IllegalArgumentException("Szenario gehört nicht zu diesem Run.");if(req.getDurationSeconds()<1||req.getDurationSeconds()>s.getTimeLimitSeconds()*4)throw new IllegalArgumentException("Unplausible Spieldauer.");if(req.getItems()==null||req.getItems().size()>MAX_ITEMS)throw new IllegalArgumentException("Ungültige Rätselliste.");Map<Long,EscapePuzzle>byId=new HashMap<>();Map<Long,EscapeRoom>selectedRooms=new HashMap<>();for(EscapeRoom r:s.getRooms())if(st.roomIds.contains(r.getId())){selectedRooms.put(r.getId(),r);for(EscapePuzzle p:r.getPuzzles())byId.put(p.getId(),p);}Set<Long>seen=new HashSet<>();int base=0,solved=0;for(EscapeFinishRequest.Item i:req.getItems()){if(i.getPuzzleId()==null||!st.puzzleIds.contains(i.getPuzzleId())||!seen.add(i.getPuzzleId()))throw new IllegalArgumentException("Fremde oder doppelte Rätsel-ID.");EscapePuzzle p=byId.get(i.getPuzzleId());if(p!=null&&matches(p,i.getSubmission())&&!st.revealed.contains(p.getId())){solved++;int a=Math.max(1,st.attempts.getOrDefault(p.getId(),1));double af=a==1?1:a==2?.6:.3;int hl=st.hints.getOrDefault(p.getId(),0);double hf=hl==0?1:hl==1?.8:.6;base+=(int)Math.round(p.getPoints()*af*hf);}}
+ int opened=st.opened.size();base+=opened*50;int max=selectedRooms.values().stream().mapToInt(r->r.getPuzzles().stream().mapToInt(EscapePuzzle::getPoints).sum()+50).sum();boolean escaped=req.isEscaped()&&opened==st.roomIds.size();int bonus=escaped?Math.max(0,(int)Math.round(500.0*(s.getTimeLimitSeconds()-req.getDurationSeconds())/s.getTimeLimitSeconds())):0;int total=base+bonus;int stars=stars(base,max);ScoreResult saved=scores.recordScore(user,GAME,s.getSlug(),total,solved,req.getDurationSeconds());httpClear(session);return new EscapeResult(total,base,max,bonus,solved,opened,escaped,stars,saved.getHighscore(),saved.isNewHighscore(),saved.getPlays());}
+ private void httpClear(HttpSession s){s.removeAttribute("codeescape.run");}
+ private boolean matches(EscapePuzzle p,JsonNode sub){JsonNode j=parse(p.getPayload());if(j==null||sub==null)return false;return switch(p.getType()){case"code"->strings(j,"solutions").stream().anyMatch(x->eq(x,sub.path("answer").asText(""),j.path("caseSensitive").asBoolean(false)));case"choice"->eq(j.path("correct").asText(),sub.path("answer").asText(),false);case"order"->listEq(strings(j,"solution"),strings(sub,"items"));case"match"->pairEq(j,sub);default->false;};}
+ private boolean pairEq(JsonNode j,JsonNode s){Map<String,String>w=new HashMap<>();for(JsonNode p:array(j,"pairs"))if(p.size()>1)w.put(norm(p.get(0).asText()),norm(p.get(1).asText()));for(JsonNode p:array(s,"pairs"))if(p.size()>1&&!Objects.equals(w.get(norm(p.get(0).asText())),norm(p.get(1).asText())))return false;return arraySize(s,"pairs")==w.size();}private int arraySize(JsonNode n,String f){JsonNode a=n==null?null:n.get(f);return a!=null&&a.isArray()?a.size():0;}private boolean listEq(List<String>a,List<String>b){if(a.size()!=b.size())return false;for(int i=0;i<a.size();i++)if(!eq(a.get(i),b.get(i),false))return false;return true;}private static boolean eq(String a,String b,boolean cs){return cs?norm(a).equals(norm(b)):norm(a).equalsIgnoreCase(norm(b));}private static String norm(String s){return s==null?"":s.trim().replaceAll("\\s+"," ");}private int stars(int s,int m){if(s<=0||m<=0)return 0;double r=(double)s/m;return r>=.8?3:r>=.5?2:1;}private JsonNode parse(String j){try{return mapper.readTree(j);}catch(Exception e){return null;}}private Iterable<JsonNode> array(JsonNode n,String f){JsonNode a=n==null?null:n.get(f);return a!=null&&a.isArray()?a:mapper.createArrayNode();}private List<String> strings(JsonNode n,String f){List<String>o=new ArrayList<>();for(JsonNode x:array(n,f))o.add(x.asText());return o;}private ArrayNode shuffle(List<String>x){List<String>c=new ArrayList<>(x);Collections.shuffle(c);ArrayNode a=mapper.createArrayNode();c.forEach(a::add);return a;}private void copy(JsonNode s,ObjectNode t,String f){if(s.hasNonNull(f))t.put(f,s.get(f).asText());}
+ // Admin
+ @Transactional(readOnly=true) public List<EscapeScenario> all(){return scenarios.findAllByOrderBySortOrderAscIdAsc();}@Transactional(readOnly=true) public EscapeScenario scenario(Long id){EscapeScenario s=scenarios.findById(id).orElseThrow();s.getRooms().size();return s;}@Transactional(readOnly=true) public EscapeRoom room(Long id){EscapeRoom r=rooms.findById(id).orElseThrow();r.getPuzzles().size();return r;}
+ @Transactional public Long addScenario(String title,String difficulty,String scope,String description,int limit){String slug=title.toLowerCase().replaceAll("[^a-z0-9]+","-").replaceAll("(^-|-$)","");if(slug.isBlank())slug="scenario";String b=slug;int i=2;while(scenarios.existsBySlug(slug))slug=b+"-"+i++;EscapeScenario s=new EscapeScenario(slug,title.trim(),difficulty,SCOPES.contains(scope)?scope:"AP1",description,Math.max(300,Math.min(3600,limit)),(int)scenarios.count()+1);return scenarios.save(s).getId();}
+ @Transactional public void addRoom(Long sid,String title,String intro,String prompt,String code,String success){EscapeScenario s=scenarios.findById(sid).orElseThrow();s.addRoom(new EscapeRoom(title,intro,prompt,code,success,s.getRooms().size()));}
+ @Transactional public void addPuzzle(Long rid,String type,String prompt,int points,String fragment,String payload){if(!TYPES.contains(type)||parse(payload)==null)throw new IllegalArgumentException("Ungültiger Rätseltyp oder Payload.");EscapeRoom r=rooms.findById(rid).orElseThrow();r.addPuzzle(new EscapePuzzle(type,prompt,Math.max(10,Math.min(1000,points)),fragment,r.getPuzzles().size(),payload));}
+ @Transactional public void deleteScenario(Long id){scenarios.deleteById(id);}@Transactional public void deleteRoom(Long id){rooms.deleteById(id);}@Transactional public void deletePuzzle(Long id){puzzles.deleteById(id);}@Transactional public void toggle(Long id){scenarios.findById(id).ifPresent(s->s.setActive(!s.isActive()));}
+}

src/main/java/com/example/mindflux/service/GameScoreService.java

@@ -5,6 +5,8 @@ import com.example.mindflux.dto.ScoreResult;
 import com.example.mindflux.dto.ScoreSubmission;
 import com.example.mindflux.model.GameScore;
 import com.example.mindflux.repository.GameScoreRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 
 import java.time.LocalDateTime;
@@ -16,10 +18,14 @@ import java.time.LocalDateTime;
 @Service
 public class GameScoreService {
 
-    private final GameScoreRepository repository;
+    private static final Logger log = LoggerFactory.getLogger(GameScoreService.class);
 
-    public GameScoreService(GameScoreRepository repository) {
+    private final GameScoreRepository repository;
+    private final AchievementService achievementService;
+
+    public GameScoreService(GameScoreRepository repository, AchievementService achievementService) {
         this.repository = repository;
+        this.achievementService = achievementService;
     }
 
     /**
@@ -66,9 +72,33 @@ public class GameScoreService {
         int highscore = previousBest == null ? score : Math.max(previousBest.getScore(), score);
         long plays = repository.countByUsernameAndGame(username, game);
 
+        // Achievement-Prüfung darf das Speichern des Scores nie gefährden.
+        try {
+            achievementService.checkAndAward(username, game, score, newHighscore, plays);
+        } catch (Exception e) {
+            log.error("Achievement-Prüfung fehlgeschlagen für {} / {}", username, game, e);
+        }
+
         return new ScoreResult(score, highscore, newHighscore, plays);
     }
 
+    /** Summe aller Scores eines Spielers über alle Spiele (XP-Basis). */
+    public long totalScore(String username) {
+        return repository.sumScoreByUsername(username);
+    }
+
+    /** Summe der moves-Werte (je nach Spiel gelöste Aufgaben/richtige Antworten). */
+    public long totalMoves(String username) {
+        return repository.sumMovesByUsername(username);
+    }
+
+    /** Alle Spieltage absteigend sortiert (für die Tages-Streak). */
+    public java.util.List<java.time.LocalDate> playDaysDesc(String username) {
+        return repository.findDistinctPlayDaysDesc(username).stream()
+                .map(java.sql.Date::toLocalDate)
+                .toList();
+    }
+
     /** Aktuelle Statistik (Highscore, Anzahl Spiele, zuletzt gespielt) für ein Spiel. */
     public GameStats getStats(String username, String game) {
         int highscore = repository.findTopByUsernameAndGameOrderByScoreDesc(username, game)

src/main/java/com/example/mindflux/service/LoginAttemptService.java

@@ -0,0 +1,55 @@
+package com.example.mindflux.service;
+
+import org.springframework.stereotype.Service;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Einfacher In-Memory-Schutz gegen Brute-Force auf den Login: Nach zu vielen
+ * Fehlversuchen wird der Benutzername für ein Zeitfenster gesperrt. Erfolgreicher
+ * Login setzt den Zähler zurück. Bewusst ohne externe Abhängigkeiten gehalten.
+ */
+@Service
+public class LoginAttemptService {
+
+    static final int MAX_ATTEMPTS = 5;
+    static final Duration WINDOW = Duration.ofMinutes(15);
+
+    private record Attempt(int count, Instant firstFailure) {}
+
+    private final Map<String, Attempt> attempts = new ConcurrentHashMap<>();
+
+    public void loginFailed(String username) {
+        String key = normalize(username);
+        attempts.compute(key, (k, existing) -> {
+            Instant now = Instant.now();
+            if (existing == null || existing.firstFailure().plus(WINDOW).isBefore(now)) {
+                return new Attempt(1, now);
+            }
+            return new Attempt(existing.count() + 1, existing.firstFailure());
+        });
+    }
+
+    public void loginSucceeded(String username) {
+        attempts.remove(normalize(username));
+    }
+
+    public boolean isBlocked(String username) {
+        Attempt attempt = attempts.get(normalize(username));
+        if (attempt == null) {
+            return false;
+        }
+        if (attempt.firstFailure().plus(WINDOW).isBefore(Instant.now())) {
+            attempts.remove(normalize(username));
+            return false;
+        }
+        return attempt.count() >= MAX_ATTEMPTS;
+    }
+
+    private String normalize(String username) {
+        return username == null ? "" : username.trim().toLowerCase();
+    }
+}

src/main/java/com/example/mindflux/service/ProgressService.java

@@ -6,6 +6,7 @@ import com.example.mindflux.dto.ProgressData;
 
 import org.springframework.stereotype.Service;
 
+import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -19,11 +20,12 @@ public class ProgressService {
     static {
         GAMES.put("mindmatch", "MindMatch");
         GAMES.put("techtacular", "TechTacular");
-        GAMES.put("syntax-saga", "Syntax Saga");
-        GAMES.put("escape-room", "Code Escape Room");
-        GAMES.put("service-clash", "Service Clash");
-        GAMES.put("bug-hunter", "Bug Hunter");
-        GAMES.put("netzwerker", "Netzwerker");
+        GAMES.put("devlab", "DevLab");
+        GAMES.put("syntax-saga", "SyntaxSaga");
+        GAMES.put("codeescape", "SystemEscape");
+        GAMES.put("serviceclash", "ServiceClash");
+        GAMES.put("bughunter", "BugHunter");
+        GAMES.put("networker", "NetWorker");
     }
 
     private final GameScoreService gameScoreService;
@@ -32,17 +34,53 @@ public class ProgressService {
         this.gameScoreService = gameScoreService;
     }
 
+    /** XP pro Level: Level n ist erreicht ab (n-1) * 1000 Gesamt-XP. */
+    static final int XP_PER_LEVEL = 1000;
+
+    /** Echter Gesamtfortschritt aus game_scores: XP = Summe aller Scores, Level linear. */
     public ProgressData getOverallProgress(String username) {
-        // Dummy-Daten – später aus DB berechnen
+        long totalXp = gameScoreService.totalScore(username);
+        int level = (int) (totalXp / XP_PER_LEVEL) + 1;
+        long nextLevelAt = (long) level * XP_PER_LEVEL;
+        int withinLevel = (int) (totalXp - (long) (level - 1) * XP_PER_LEVEL);
+
         ProgressData data = new ProgressData();
-        data.setCorrectAnswers(432);
-        data.setCurrentXp(2400);
-        data.setXpForNextLevel(3000);
-        data.setUserLevel(5);
-        data.setProgressPercent(78);
+        // Näherung: moves = je nach Spiel gelöste Aufgaben bzw. richtige Antworten
+        // (bei MindMatch sind es Zug-Versuche – bewusst in Kauf genommen).
+        data.setCorrectAnswers((int) Math.min(gameScoreService.totalMoves(username), Integer.MAX_VALUE));
+        data.setCurrentXp((int) Math.min(totalXp, Integer.MAX_VALUE));
+        data.setXpForNextLevel((int) Math.min(nextLevelAt, Integer.MAX_VALUE));
+        data.setUserLevel(level);
+        data.setProgressPercent(Math.round(withinLevel * 100f / XP_PER_LEVEL));
+        data.setStreakDays(computeStreak(gameScoreService.playDaysDesc(username), LocalDate.now()));
         return data;
     }
 
+    /**
+     * Tages-Streak: Anzahl zusammenhängender Spieltage bis heute. Ein Tag Karenz –
+     * wer heute noch nicht gespielt hat, behält die Serie von gestern.
+     */
+    static int computeStreak(List<LocalDate> playDaysDesc, LocalDate today) {
+        if (playDaysDesc.isEmpty()) {
+            return 0;
+        }
+        LocalDate anchor = playDaysDesc.get(0);
+        if (anchor.isBefore(today.minusDays(1))) {
+            return 0;
+        }
+        int streak = 0;
+        LocalDate expected = anchor;
+        for (LocalDate day : playDaysDesc) {
+            if (day.equals(expected)) {
+                streak++;
+                expected = expected.minusDays(1);
+            } else {
+                break;
+            }
+        }
+        return streak;
+    }
+
     /** Echter Spiel-Fortschritt pro Spiel aus der Datenbank (game_scores). */
     public List<GameProgress> getGameProgress(String username) {
         List<GameProgress> result = new ArrayList<>();

src/main/java/com/example/mindflux/service/RegistrationResult.java

@@ -0,0 +1,11 @@
+package com.example.mindflux.service;
+
+/** Ergebnis einer Selbstregistrierung – wird vom RegisterController auf Redirect-Flags gemappt. */
+public enum RegistrationResult {
+    SUCCESS,
+    USERNAME_INVALID,
+    USERNAME_TAKEN,
+    EMAIL_INVALID,
+    PASSWORD_MISMATCH,
+    PASSWORD_TOO_SHORT
+}

src/main/java/com/example/mindflux/service/TechtacularService.java

@@ -43,8 +43,10 @@ public class TechtacularService {
     public TechtacularBoardView buildBoard(Set<Long> exclude) {
         Set<Long> excluded = (exclude == null) ? Set.of() : exclude;
 
-        List<TechtacularCategory> usable = categoryRepository.findAllByActiveTrueOrderBySortOrderAscIdAsc()
-                .stream().filter(c -> !c.getQuestions().isEmpty()).collect(Collectors.toList());
+        // 2-Query-Muster statt N+1: Kategorien+Fragen in einem Fetch-Join, danach alle
+        // Antwort-Collections in einer zweiten Query im selben Persistence Context laden.
+        List<TechtacularCategory> usable = new ArrayList<>(categoryRepository.findActiveWithQuestions());
+        questionRepository.findActiveWithAnswers();
         Collections.shuffle(usable, random);
         List<TechtacularCategory> chosen = usable.stream().limit(BOARD_CATEGORIES).toList();
 
@@ -128,12 +130,14 @@ public class TechtacularService {
 
     // ---------- Admin ----------
 
-    /** Leichte Übersicht: Kategorien mit Fragenanzahl (lädt nicht alle Fragen). */
+    /** Leichte Übersicht: Kategorien mit Fragenanzahl (eine GROUP-BY-Query für alle Counts). */
     @Transactional(readOnly = true)
     public List<AdminCategoryRow> categoryRows() {
+        Map<Long, Long> counts = questionRepository.countGroupedByCategory().stream()
+                .collect(Collectors.toMap(row -> (Long) row[0], row -> (Long) row[1]));
         return categoryRepository.findAllByOrderBySortOrderAscIdAsc().stream()
                 .map(c -> new AdminCategoryRow(c.getId(), c.getSlug(), c.getTitle(), c.isActive(),
-                        questionRepository.countByCategoryId(c.getId())))
+                        counts.getOrDefault(c.getId(), 0L)))
                 .toList();
     }
 

src/main/java/com/example/mindflux/service/UserService.java

@@ -2,8 +2,34 @@ package com.example.mindflux.service;
 
 import com.example.mindflux.model.User;
 
+import java.util.List;
+import java.util.Optional;
+
 public interface UserService {
+
     User findByUsername(String username);
+
+    User findByUsernameIgnoreCase(String username);
+
+    List<User> findAll();
+
+    Optional<User> findById(Long id);
+
     void save(User user);
-    void deleteByUsername(String username); // <-- Nur die Methodensignatur, ohne {}
+
+    /** Selbstregistrierung mit allen Regeln (Passwortlänge, E-Mail-Format, Eindeutigkeit). */
+    RegistrationResult register(String username, String email, String password, String confirmPassword);
+
+    /** Anlage durch Admin/REST – wirft IllegalArgumentException bei Regelverstößen. */
+    User createUser(String username, String email, String rawPassword, String role);
+
+    /** Normalisiert die Rolle (Default USER) und wirft bei unbekannten Rollen. */
+    String validateRole(String role);
+
+    /** Wirft, wenn der Benutzername (case-insensitiv) bereits einem anderen Nutzer gehört. */
+    void assertUsernameAvailable(String username, Long exceptId);
+
+    void deleteByUsername(String username);
+
+    void deleteById(Long id);
 }

src/main/java/com/example/mindflux/service/UserServiceImpl.java

@@ -4,25 +4,61 @@ import com.example.mindflux.model.User;
 import com.example.mindflux.repository.AchievementRepository;
 import com.example.mindflux.repository.GameScoreRepository;
 import com.example.mindflux.repository.UserRepository;
-import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/**
+ * Zentrale Stelle für alle Benutzer-Operationen: Registrierung, Admin-/REST-Anlage,
+ * Validierung, Passwort-Encoding und Löschen. Alle Anlage-Pfade laufen hier durch,
+ * damit die Regeln (BCrypt, Rollen, Eindeutigkeit) nicht auseinanderdriften.
+ */
 @Service
 public class UserServiceImpl implements UserService {
 
-    @Autowired
-    private UserRepository userRepository;
+    private static final int MIN_PASSWORD_LENGTH = 8;
+    private static final Set<String> KNOWN_ROLES = Set.of("USER", "ADMIN");
+    private static final Pattern EMAIL = Pattern.compile("^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$");
 
-    @Autowired
-    private GameScoreRepository gameScoreRepository;
+    private final UserRepository userRepository;
+    private final GameScoreRepository gameScoreRepository;
+    private final AchievementRepository achievementRepository;
+    private final BCryptPasswordEncoder passwordEncoder;
 
-    @Autowired
-    private AchievementRepository achievementRepository;
+    public UserServiceImpl(UserRepository userRepository,
+                           GameScoreRepository gameScoreRepository,
+                           AchievementRepository achievementRepository,
+                           BCryptPasswordEncoder passwordEncoder) {
+        this.userRepository = userRepository;
+        this.gameScoreRepository = gameScoreRepository;
+        this.achievementRepository = achievementRepository;
+        this.passwordEncoder = passwordEncoder;
+    }
 
     @Override
     public User findByUsername(String username) {
-        return userRepository.findByUsername(username).orElse(null); // <-- Optional aufgelöst
+        return userRepository.findByUsername(username).orElse(null);
+    }
+
+    @Override
+    public User findByUsernameIgnoreCase(String username) {
+        return userRepository.findByUsernameIgnoreCase(username).orElse(null);
+    }
+
+    @Override
+    public List<User> findAll() {
+        return userRepository.findAll();
+    }
+
+    @Override
+    public Optional<User> findById(Long id) {
+        return userRepository.findById(id);
     }
 
     @Override
@@ -30,14 +66,85 @@ public class UserServiceImpl implements UserService {
         userRepository.save(user);
     }
 
+    @Override
+    public RegistrationResult register(String username, String email, String password, String confirmPassword) {
+        String name = username == null ? "" : username.trim();
+        if (name.isBlank() || name.length() > 100) {
+            return RegistrationResult.USERNAME_INVALID;
+        }
+        if (password == null || password.length() < MIN_PASSWORD_LENGTH) {
+            return RegistrationResult.PASSWORD_TOO_SHORT;
+        }
+        if (!password.equals(confirmPassword)) {
+            return RegistrationResult.PASSWORD_MISMATCH;
+        }
+        if (email == null || !EMAIL.matcher(email.trim()).matches()) {
+            return RegistrationResult.EMAIL_INVALID;
+        }
+        if (userRepository.findByUsernameIgnoreCase(name).isPresent()) {
+            return RegistrationResult.USERNAME_TAKEN;
+        }
+        User user = new User(name, passwordEncoder.encode(password), email.trim(), "USER");
+        try {
+            userRepository.save(user);
+        } catch (DataIntegrityViolationException e) {
+            // Race bei parallelem Insert – der case-insensitive Unique-Index (V9) greift.
+            return RegistrationResult.USERNAME_TAKEN;
+        }
+        return RegistrationResult.SUCCESS;
+    }
+
+    @Override
+    public User createUser(String username, String email, String rawPassword, String role) {
+        String name = username == null ? "" : username.trim();
+        if (name.isBlank() || name.length() > 100) {
+            throw new IllegalArgumentException("Ungültiger Benutzername.");
+        }
+        if (rawPassword == null || rawPassword.length() < MIN_PASSWORD_LENGTH) {
+            throw new IllegalArgumentException(
+                    "Das Passwort muss mindestens " + MIN_PASSWORD_LENGTH + " Zeichen lang sein.");
+        }
+        String checkedRole = validateRole(role);
+        assertUsernameAvailable(name, null);
+        User user = new User(name, passwordEncoder.encode(rawPassword),
+                email == null ? null : email.trim(), checkedRole);
+        try {
+            return userRepository.save(user);
+        } catch (DataIntegrityViolationException e) {
+            throw new IllegalArgumentException("Benutzername bereits vergeben.");
+        }
+    }
+
+    @Override
+    public String validateRole(String role) {
+        String normalized = (role == null || role.isBlank()) ? "USER" : role.trim().toUpperCase();
+        if (!KNOWN_ROLES.contains(normalized)) {
+            throw new IllegalArgumentException("Unbekannte Rolle: " + role);
+        }
+        return normalized;
+    }
+
+    @Override
+    public void assertUsernameAvailable(String username, Long exceptId) {
+        userRepository.findByUsernameIgnoreCase(username).ifPresent(existing -> {
+            if (exceptId == null || !existing.getId().equals(exceptId)) {
+                throw new IllegalArgumentException("Benutzername bereits vergeben.");
+            }
+        });
+    }
+
     @Override
     @Transactional
     public void deleteByUsername(String username) {
-        // Zugehörige Daten mitlöschen (kein FK/Cascade -> manuell), damit keine
-        // verwaisten Datensätze zurückbleiben und ein neuer gleichnamiger Account
-        // keine Alt-Daten erbt.
+        // Defensive Mitlöschung – seit V10 sichern zusätzlich FK-Kaskaden in der DB ab.
         gameScoreRepository.deleteByUsername(username);
         achievementRepository.deleteByUsername(username);
         userRepository.deleteByUsername(username);
     }
+
+    @Override
+    @Transactional
+    public void deleteById(Long id) {
+        userRepository.findById(id).ifPresent(user -> deleteByUsername(user.getUsername()));
+    }
 }

src/main/resources/codeescape/content.json

@@ -0,0 +1,37 @@
+{"scenarios":[
+{"slug":"verlassener-serverraum","title":"Der verlassene Serverraum","difficulty":"leicht","examScope":"AP1","description":"Zahlensysteme, Ports und Netzwerkgrundlagen öffnen den Weg nach draußen.","timeLimitSeconds":900,"rooms":[
+{"title":"Rack 01","intro":"Notlicht flackert über einem verriegelten Rack. Das Terminal verlangt drei Fragmente.","doorPrompt":"Alle Fragmente in Fundreihenfolge eingeben.","doorCode":"4122SYN","successText":"Das Rack entriegelt. Hinter der Rückwand führt ein Wartungsgang weiter.","puzzles":[
+{"type":"code","prompt":"Binärterminal","points":100,"fragment":"41","payload":{"narrative":"Auf dem Display pulsiert 0b101001.","instruction":"Wandle die Binärzahl in Dezimal um.","placeholder":"Dezimalwert","solutions":["41"],"hints":["Gewichte von rechts: 1, 2, 4, 8, 16, 32.","32 + 8 + 1"],"explanation":"101001₂ entspricht 32+8+1 = 41."}},
+{"type":"choice","prompt":"Offener Wartungsport","points":100,"fragment":"22","payload":{"instruction":"Welcher Standardport gehört zu SSH?","options":["21","22","23","25"],"correct":"22","hints":["SSH ersetzt unsichere Fernwartung per Telnet.","Der Port liegt direkt nach FTP."],"explanation":"SSH nutzt standardmäßig TCP-Port 22."}},
+{"type":"order","prompt":"TCP-Verbindung","points":120,"fragment":"SYN","payload":{"instruction":"Bringe den TCP-Drei-Wege-Handshake in Reihenfolge.","items":["SYN","SYN-ACK","ACK"],"solution":["SYN","SYN-ACK","ACK"],"hints":["Der Client beginnt mit einer Synchronisationsanfrage.","Die Mitte bestätigt und synchronisiert zugleich."],"explanation":"SYN → SYN-ACK → ACK."}}]},
+{"title":"Patchfeld","intro":"Lose Leitungen hängen über dem Boden. Ein altes Patchpanel blockiert die Schleuse.","doorPrompt":"Setze alle Fragmente in Fundreihenfolge zusammen.","doorCode":"6253UP","successText":"Die Link-LEDs springen an und die Schleuse gleitet auf.","puzzles":[
+{"type":"code","prompt":"Subnetz-Kapazität","points":120,"fragment":"62","payload":{"instruction":"Wie viele nutzbare IPv4-Hosts bietet ein /26-Netz klassisch?","solutions":["62"],"hints":["Ein /26 lässt 6 Hostbits.","2⁶ Adressen minus Netz und Broadcast."],"explanation":"64 Gesamtadressen minus 2 = 62 Hosts."}},
+{"type":"match","prompt":"Dienste verbinden","points":120,"fragment":"53","payload":{"instruction":"Ordne Dienst und Standardport zu.","pairs":[["DNS","53"],["HTTP","80"],["HTTPS","443"]],"hints":["Web unverschlüsselt liegt auf 80.","DNS nutzt 53, TLS-Web 443."],"explanation":"DNS 53, HTTP 80, HTTPS 443."}},
+{"type":"choice","prompt":"Kabeldiagnose","points":100,"fragment":"UP","payload":{"instruction":"Welche Anzeige bestätigt eine physische Ethernet-Verbindung?","options":["Link LED","DNS Cache","Default Route","TTL"],"correct":"Link LED","hints":["Gesucht ist Schicht 1.","Sie sitzt meist direkt an der Buchse."],"explanation":"Die Link-LED zeigt den physischen Link."}}]},
+{"title":"Kontrollraum","intro":"Die Hauptkonsole wartet auf die letzte Startsequenz.","doorPrompt":"Nutze die Fragmente der beiden Kontrollrätsel.","doorCode":"DHCP67","successText":"Die Außentür öffnet sich. Frische Nachtluft strömt herein.","puzzles":[
+{"type":"order","prompt":"DHCP-Ablauf","points":140,"fragment":"DHCP","payload":{"instruction":"Sortiere den DORA-Ablauf.","items":["Discover","Offer","Request","Acknowledge"],"solution":["Discover","Offer","Request","Acknowledge"],"hints":["Der Client sucht zuerst.","Discover, Offer, Request, Acknowledge."],"explanation":"DORA beschreibt die DHCP-Adressvergabe."}},
+{"type":"code","prompt":"DHCP-Serverport","points":100,"fragment":"67","payload":{"instruction":"Welchen UDP-Port nutzt der DHCP-Server?","solutions":["67"],"hints":["Client und Server verwenden zwei benachbarte Ports.","Der Server nutzt den kleineren: 67."],"explanation":"DHCP-Server: UDP 67, Client: UDP 68."}}]}]},
+{"slug":"lockdown-rechenzentrum","title":"Lockdown im Rechenzentrum","difficulty":"mittel","examScope":"AP2_FISI","description":"RAID, USV, Backup und Virtualisierung unter Zeitdruck.","timeLimitSeconds":1100,"rooms":[
+{"title":"Stromschleuse","intro":"Die USV hält nur noch wenige Minuten. Das Energiemanagement ist verriegelt.","doorPrompt":"Gib alle drei Fragmente in Fundreihenfolge ein.","doorCode":"3TBUSVR5","successText":"Die Last wechselt auf den sicheren Pfad.","puzzles":[
+{"type":"code","prompt":"RAID-5-Kapazität","points":150,"fragment":"3TB","payload":{"instruction":"Vier 1-TB-Platten im RAID 5: nutzbare Kapazität?","solutions":["3 TB","3TB","3"],"hints":["Eine Plattenkapazität geht für Parität verloren.","(4−1) × 1 TB"],"explanation":"RAID 5 nutzt n−1 Plattenkapazitäten."}},
+{"type":"choice","prompt":"USV-Typ","points":140,"fragment":"USV","payload":{"instruction":"Welche USV entkoppelt Verbraucher dauerhaft über den Wechselrichter?","options":["Offline","Line-interactive","Online-Doppelwandler","Steckdosenleiste"],"correct":"Online-Doppelwandler","hints":["Die Last wird permanent neu erzeugt.","VFI/Online-Doppelwandler."],"explanation":"Online-USV: Netz → Gleichrichter → Zwischenkreis → Wechselrichter."}},
+{"type":"match","prompt":"RAID-Eigenschaften","points":140,"fragment":"R5","payload":{"instruction":"Ordne Level und Kerneigenschaft.","pairs":[["RAID 0","Striping"],["RAID 1","Spiegelung"],["RAID 5","verteilte Parität"]],"hints":["RAID 1 dupliziert Daten.","RAID 5 verteilt Paritätsinformationen."],"explanation":"Die Zuordnung beschreibt die Grundverfahren."}}]},
+{"title":"Backup-Tresor","intro":"Ein Ransomware-Alarm sperrt das Backup-System.","doorPrompt":"Verbinde Backupfolge und Schutzprinzip.","doorCode":"VOLL321","successText":"Das unveränderliche Backup wird freigegeben.","puzzles":[
+{"type":"order","prompt":"GFS-Wiederherstellung","points":160,"fragment":"VOLL","payload":{"instruction":"Sortiere eine Wiederherstellung mit inkrementellen Backups.","items":["Vollsicherung","Inkrement 1","Inkrement 2","Inkrement 3"],"solution":["Vollsicherung","Inkrement 1","Inkrement 2","Inkrement 3"],"hints":["Basis ist immer das letzte Vollbackup.","Danach jedes Inkrement chronologisch."],"explanation":"Inkrementelle Ketten benötigen Vollbackup plus alle Folgeinkremente."}},
+{"type":"code","prompt":"3-2-1-Regel","points":140,"fragment":"321","payload":{"instruction":"Welche drei Ziffern beschreiben Kopien, Medientypen und externen Standort?","solutions":["321","3-2-1"],"hints":["Drei Kopien auf zwei Medien.","Eine Kopie außer Haus."],"explanation":"3 Kopien, 2 Medientypen, 1 extern."}}]},
+{"title":"Hypervisor-Kern","intro":"Die Managementkonsole meldet Ressourcenüberbuchung.","doorPrompt":"Kombiniere alle Fragmente in Fundreihenfolge.","doorCode":"TYPE1NOSNAPISO","successText":"Der Cluster übernimmt und der Lockdown endet.","puzzles":[
+{"type":"choice","prompt":"Bare-Metal-Hypervisor","points":150,"fragment":"TYPE1","payload":{"instruction":"Welcher Hypervisor läuft direkt auf der Hardware?","options":["Typ 1","Typ 2","Container Runtime","JVM"],"correct":"Typ 1","hints":["Kein Hostbetriebssystem dazwischen.","Auch Bare-Metal genannt."],"explanation":"Typ-1-Hypervisor laufen direkt auf der Hardware."}},
+{"type":"code","prompt":"Snapshot-Falle","points":150,"fragment":"NOSNAP","payload":{"instruction":"Ist ein VM-Snapshot ein vollwertiges Backup? Antworte ja oder nein.","solutions":["nein","no"],"hints":["Snapshot und Basisdatenträger bleiben gekoppelt.","Ein Defekt des Datastores betrifft beides."],"explanation":"Snapshots ersetzen kein unabhängiges Backup."}},
+{"type":"match","prompt":"Virtualisierungsgrenzen","points":150,"fragment":"ISO","payload":{"instruction":"Ordne Technik und Isolation.","pairs":[["VM","eigener Kernel"],["Container","geteilter Host-Kernel"],["VLAN","logische Netzsegmentierung"]],"hints":["Container teilen den Kernel.","VLAN segmentiert das Netz, nicht Prozesse."],"explanation":"VM, Container und VLAN isolieren auf verschiedenen Ebenen."}}]}]},
+{"slug":"gehacktes-buero","title":"Das gehackte Büro","difficulty":"schwer","examScope":"CROSS","description":"Zertifikate, Kryptografie, SQL und Incident Response auf AP2-Niveau.","timeLimitSeconds":1200,"rooms":[
+{"title":"Forensik-Labor","intro":"Ein kompromittierter Client hält die Beweise verschlüsselt.","doorPrompt":"Setze alle Fragmente in Fundreihenfolge zusammen.","doorCode":"SHA256443CIA","successText":"Das Beweisarchiv wird lesbar.","puzzles":[
+{"type":"choice","prompt":"Hashverfahren","points":180,"fragment":"SHA256","payload":{"instruction":"Welches Verfahren ist für Integritätsprüfungen heute geeignet?","options":["MD5","SHA-1","SHA-256","ROT13"],"correct":"SHA-256","hints":["MD5 und SHA-1 gelten als kollisionsgeschwächt.","Die gesuchte SHA-2-Variante hat 256 Bit."],"explanation":"SHA-256 ist eine verbreitete kryptografische Hashfunktion."}},
+{"type":"code","prompt":"TLS-Port","points":140,"fragment":"443","payload":{"instruction":"Standardport für HTTPS?","solutions":["443"],"hints":["HTTP nutzt 80.","HTTPS nutzt 443."],"explanation":"HTTPS verwendet TCP 443."}},
+{"type":"match","prompt":"Schutzziele","points":170,"fragment":"CIA","payload":{"instruction":"Ordne CIA-Schutzziel und deutsche Bedeutung.","pairs":[["Confidentiality","Vertraulichkeit"],["Integrity","Integrität"],["Availability","Verfügbarkeit"]],"hints":["CIA ist nicht der Nachrichtendienst in diesem Kontext.","C=Confidentiality, I=Integrity, A=Availability."],"explanation":"Die CIA-Triade bildet zentrale Informationssicherheitsziele."}}]},
+{"title":"Datenbank-Bunker","intro":"Die Angreifer haben Spuren in einer unsicheren Suchmaske hinterlassen.","doorPrompt":"Verbinde SQL-Schutz und Transaktionsfragment.","doorCode":"PREPAREDACID","successText":"Der Datenbankzugang ist wieder unter Kontrolle.","puzzles":[
+{"type":"choice","prompt":"SQL-Injection stoppen","points":190,"fragment":"PREPARED","payload":{"instruction":"Welche Maßnahme trennt SQL-Code zuverlässig von Eingabedaten?","options":["Prepared Statements","HTML-Escaping","Base64","Mehr RAM"],"correct":"Prepared Statements","hints":["Parameter werden gebunden statt konkateniert.","Prepared Statements."],"explanation":"Parametrisierte Statements verhindern das Einschleusen von SQL-Syntax."}},
+{"type":"order","prompt":"Sichere Transaktion","points":180,"fragment":"ACID","payload":{"instruction":"Ordne den vereinfachten Ablauf.","items":["BEGIN","Änderungen ausführen","Validieren","COMMIT"],"solution":["BEGIN","Änderungen ausführen","Validieren","COMMIT"],"hints":["Transaktion öffnen, arbeiten, prüfen, bestätigen.","COMMIT steht am Ende."],"explanation":"Erst nach erfolgreicher Validierung wird committed."}}]},
+{"title":"Incident-Leitstand","intro":"Die letzte Tür verlangt eine saubere Reaktion statt hektischer Einzelaktionen.","doorPrompt":"Setze alle Fragmente in Fundreihenfolge zusammen.","doorCode":"ISOLATECALEAST","successText":"Die Systeme sind eingedämmt. Der Ausgang ist frei.","puzzles":[
+{"type":"order","prompt":"Incident Response","points":200,"fragment":"ISOLATE","payload":{"instruction":"Sortiere die ersten Reaktionsschritte.","items":["Erkennen","Eindämmen","Beweise sichern","Bereinigen","Wiederherstellen"],"solution":["Erkennen","Eindämmen","Beweise sichern","Bereinigen","Wiederherstellen"],"hints":["Vor Bereinigung muss der Vorfall eingedämmt und dokumentiert sein.","Erkennen → Eindämmen → Beweise → Bereinigen → Wiederherstellen."],"explanation":"Die Reihenfolge erhält Beweise und begrenzt Schaden."}},
+{"type":"choice","prompt":"Zertifikatsvertrauen","points":180,"fragment":"CA","payload":{"instruction":"Wer bestätigt die Bindung zwischen Identität und öffentlichem Schlüssel?","options":["Certificate Authority","DHCP-Server","Hypervisor","Switch"],"correct":"Certificate Authority","hints":["Sie signiert Zertifikate.","Certificate Authority (CA)."],"explanation":"Eine CA validiert und signiert Zertifikate."}},
+{"type":"code","prompt":"Prinzip der Rechte","points":160,"fragment":"LEAST","payload":{"instruction":"Ergänze: Principle of ___ Privilege.","solutions":["least"],"caseSensitive":false,"hints":["Nur minimal notwendige Rechte.","Das englische Wort bedeutet ‚am wenigsten‘."],"explanation":"Least Privilege reduziert Angriffsfläche."}}]}]}]}

src/main/resources/db/migration/V10__data_integrity.sql

@@ -0,0 +1,30 @@
+-- Datenintegrität: E-Mail eindeutig (case-insensitiv) und referenzielle Integrität
+-- für Scores/Achievements. Verwaiste Altdaten werden vorher bereinigt.
+
+-- 1) E-Mail-Dubletten auflösen: Die älteste Zeile behält die Adresse, spätere verlieren sie.
+UPDATE users u
+SET email = NULL
+WHERE u.email IS NOT NULL
+  AND EXISTS (
+    SELECT 1 FROM users o
+    WHERE o.email IS NOT NULL
+      AND lower(o.email) = lower(u.email)
+      AND o.id < u.id
+  );
+
+CREATE UNIQUE INDEX uq_users_email_lower ON users (lower(email)) WHERE email IS NOT NULL;
+
+-- 2) Verwaiste Spielstände/Achievements entfernen (stammen aus Zeiten ohne FK).
+DELETE FROM game_scores  WHERE username NOT IN (SELECT username FROM users);
+DELETE FROM achievements WHERE username IS NOT NULL AND username NOT IN (SELECT username FROM users);
+
+-- 3) Referenzielle Integrität: Löschen räumt Daten mit ab, Umbenennen zieht sie mit um.
+ALTER TABLE game_scores
+    ADD CONSTRAINT fk_game_scores_user
+    FOREIGN KEY (username) REFERENCES users (username)
+    ON DELETE CASCADE ON UPDATE CASCADE;
+
+ALTER TABLE achievements
+    ADD CONSTRAINT fk_achievements_user
+    FOREIGN KEY (username) REFERENCES users (username)
+    ON DELETE CASCADE ON UPDATE CASCADE;

src/main/resources/db/migration/V11_1__repair_codeescape_door_codes.sql

@@ -0,0 +1,9 @@
+UPDATE escape_rooms SET door_code = '4122SYN', door_prompt = 'Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.' WHERE title = 'Rack 01';
+UPDATE escape_rooms SET door_code = '6253UP', door_prompt = 'Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.' WHERE title = 'Patchfeld';
+UPDATE escape_rooms SET door_code = 'DHCP67', door_prompt = 'Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.' WHERE title = 'Kontrollraum';
+UPDATE escape_rooms SET door_code = '3TBUSVR5', door_prompt = 'Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.' WHERE title = 'Stromschleuse';
+UPDATE escape_rooms SET door_code = 'VOLL321', door_prompt = 'Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.' WHERE title = 'Backup-Tresor';
+UPDATE escape_rooms SET door_code = 'TYPE1NOSNAPISO', door_prompt = 'Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.' WHERE title = 'Hypervisor-Kern';
+UPDATE escape_rooms SET door_code = 'SHA256443CIA', door_prompt = 'Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.' WHERE title = 'Forensik-Labor';
+UPDATE escape_rooms SET door_code = 'PREPAREDACID', door_prompt = 'Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.' WHERE title = 'Datenbank-Bunker';
+UPDATE escape_rooms SET door_code = 'ISOLATECALEAST', door_prompt = 'Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.' WHERE title = 'Incident-Leitstand';

src/main/resources/db/migration/V11__codeescape.sql

@@ -0,0 +1,27 @@
+CREATE TABLE escape_scenarios (
+    id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    slug VARCHAR(150) NOT NULL UNIQUE,
+    title VARCHAR(200) NOT NULL,
+    difficulty VARCHAR(30) NOT NULL DEFAULT 'leicht',
+    exam_scope VARCHAR(20) NOT NULL DEFAULT 'AP1',
+    description VARCHAR(1200),
+    time_limit_seconds INT NOT NULL DEFAULT 900,
+    sort_order INT NOT NULL DEFAULT 0,
+    active BOOLEAN NOT NULL DEFAULT TRUE,
+    CONSTRAINT chk_escape_exam_scope CHECK (exam_scope IN ('AP1','AP2_FIAE','AP2_FISI','CROSS'))
+);
+CREATE TABLE escape_rooms (
+    id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    scenario_id BIGINT NOT NULL REFERENCES escape_scenarios(id) ON DELETE CASCADE,
+    title VARCHAR(200) NOT NULL, intro VARCHAR(2000), door_prompt VARCHAR(500),
+    door_code VARCHAR(50) NOT NULL, success_text VARCHAR(1000), sort_order INT NOT NULL DEFAULT 0
+);
+CREATE TABLE escape_puzzles (
+    id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    room_id BIGINT NOT NULL REFERENCES escape_rooms(id) ON DELETE CASCADE,
+    puzzle_type VARCHAR(30) NOT NULL, prompt VARCHAR(500) NOT NULL,
+    points INT NOT NULL DEFAULT 100, code_fragment VARCHAR(20) NOT NULL,
+    sort_order INT NOT NULL DEFAULT 0, payload VARCHAR(8000) NOT NULL
+);
+CREATE INDEX idx_escape_rooms_scenario ON escape_rooms(scenario_id);
+CREATE INDEX idx_escape_puzzles_room ON escape_puzzles(room_id);

src/main/resources/db/migration/V9__users_unique_lower_username.sql

@@ -0,0 +1,6 @@
+-- Benutzernamen case-insensitiv eindeutig machen: Die App prüft bei Login und
+-- Registrierung ignoreCase, die DB kannte bisher nur ein case-sensitives UNIQUE.
+-- Damit ist auch das Check-then-Insert-Race der Registrierung abgesichert.
+-- Voraussetzung: Es existieren keine Bestandsnamen, die sich nur in der
+-- Groß-/Kleinschreibung unterscheiden (sonst vorher manuell bereinigen).
+CREATE UNIQUE INDEX uq_users_username_lower ON users (lower(username));

src/main/resources/static/css/accessibility-placement.css

@@ -0,0 +1,7 @@
+body{padding-left:0!important;padding-bottom:0!important}
+.mf-a11y-trigger{position:static!important;width:38px;height:38px;z-index:auto;flex:0 0 38px;box-shadow:0 0 14px var(--glow-w);border-radius:10px}
+.mf-a11y-trigger svg{width:18px;height:18px}
+.mf-a11y-panel{inset:76px 16px auto auto!important;width:min(450px,calc(100vw - 32px));max-height:calc(100dvh - 92px)}
+.mf-a11y-utility{position:sticky;top:0;z-index:1700;min-height:60px;display:flex;align-items:center;justify-content:flex-end;padding:.5rem 1rem;background:var(--panel);border-bottom:1px solid var(--border)}
+.mf-theme-float{display:flex;align-items:center;gap:.55rem}
+@media(max-width:700px){.mf-a11y-panel{inset:70px 6px auto 6px!important;width:auto;max-height:calc(100dvh - 82px)}}

src/main/resources/static/css/accessibility.css

@@ -0,0 +1,10 @@
+html[data-mf-font="115"]{font-size:115%!important}html[data-mf-font="130"]{font-size:130%!important}html[data-mf-font="150"]{font-size:150%!important}
+html[data-mf-readable="true"] body,html[data-mf-readable="true"] button,html[data-mf-readable="true"] input,html[data-mf-readable="true"] select,html[data-mf-readable="true"] textarea{font-family:Verdana,Arial,sans-serif!important;letter-spacing:.025em;word-spacing:.1em;line-height:1.65}
+html[data-mf-contrast="true"]{--bg:#000;--panel:#050505;--surface:#090909;--surface-2:#111;--text:#fff;--heading:#fff;--muted:#e7e7e7;--border:#fff;--border-accent:#ffd21a;--accent:#ffd21a;--accent-2:#fff}
+html[data-mf-color="safe"]{--success:#2f9bff;--danger:#ff8a3d;--secondary:#c58cff;--esc-accent:#ffd166}
+html[data-mf-mono="true"] body{filter:grayscale(1)}html[data-mf-links="true"] a{text-decoration:underline!important;text-underline-offset:.18em;text-decoration-thickness:.12em}
+html[data-mf-motion="false"] *,html[data-mf-motion="false"] *::before,html[data-mf-motion="false"] *::after{animation-duration:.001ms!important;animation-iteration-count:1!important;scroll-behavior:auto!important;transition-duration:.001ms!important}
+html[data-mf-cursor="true"],html[data-mf-cursor="true"] *{cursor:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='32' height='32'%3E%3Cpath d='M2 1v25l7-7 5 11 5-2-5-10h10z' fill='white' stroke='black' stroke-width='2'/%3E%3C/svg%3E") 2 1,auto!important}
+body{padding-left:72px}.mf-a11y-dock{position:fixed;inset:0 auto 0 0;z-index:1799;width:72px;display:flex;align-items:flex-end;justify-content:center;padding:0 0 18px;background:color-mix(in srgb,var(--panel) 94%,transparent);border-right:1px solid var(--border);box-shadow:5px 0 18px rgba(0,0,0,.16)}
+.mf-a11y-trigger{position:fixed;left:8px;bottom:18px;z-index:1800;width:56px;height:56px;flex:0 0 auto;border:1px solid var(--border-accent);border-radius:50%;display:grid;place-items:center;background:linear-gradient(135deg,var(--accent),var(--accent-2));color:var(--accent-ink);box-shadow:0 0 22px var(--glow-s),0 7px 24px rgba(0,0,0,.38);cursor:pointer}.mf-a11y-trigger svg{width:31px;height:31px}.mf-a11y-trigger:focus-visible,.mf-a11y-panel button:focus-visible{outline:3px solid var(--accent);outline-offset:3px}
+.mf-a11y-panel{position:fixed;left:82px;bottom:18px;z-index:1801;width:min(450px,calc(100vw - 100px));max-height:calc(100dvh - 36px);overflow:auto;border:1px solid var(--border);border-radius:10px;background:var(--panel);color:var(--text);box-shadow:0 12px 45px rgba(0,0,0,.55)}.mf-a11y-panel[hidden]{display:none}.mf-a11y-head{position:sticky;top:0;display:flex;align-items:center;gap:1rem;padding:.65rem;background:#07121f;color:#fff;z-index:1}.mf-a11y-head h2{font:800 1.05rem Arial,sans-serif;margin:0 auto}.mf-a11y-close{width:44px;height:44px;border:0;border-radius:6px;background:#fff;color:#07121f;font-size:1.8rem;cursor:pointer}.mf-a11y-grid{display:grid;grid-template-columns:1fr 1fr;gap:4px;padding:10px;background:var(--surface)}.mf-a11y-option{min-height:88px;border:1px solid var(--border);border-radius:6px;background:var(--surface-2);color:var(--text);padding:.65rem;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:.35rem;font:inherit;cursor:pointer}.mf-a11y-option strong{font-size:1.35rem}.mf-a11y-option[aria-pressed="true"]{border-color:var(--accent);background:color-mix(in srgb,var(--accent) 18%,var(--surface));box-shadow:inset 0 0 0 2px var(--accent)}.mf-a11y-option small{color:var(--muted)}@media(max-width:700px){body{padding-left:0;padding-bottom:68px}.mf-a11y-dock{inset:auto 0 0 0;width:auto;height:68px;padding:0 10px;justify-content:flex-start;align-items:center;border-right:0;border-top:1px solid var(--border);box-shadow:0 -5px 18px rgba(0,0,0,.18)}.mf-a11y-trigger{width:52px;height:52px}.mf-a11y-panel{left:6px;bottom:74px;width:calc(100vw - 12px);max-height:calc(100dvh - 86px)}.mf-a11y-grid{grid-template-columns:1fr 1fr}.mf-a11y-option{min-height:78px;font-size:.82rem}}

src/main/resources/static/css/codeescape-global.css

@@ -0,0 +1 @@
+.esc-global-tools{justify-self:end;display:flex;align-items:center;gap:.65rem}.mf-a11y-host{display:flex}.esc-back,.esc-timer{font-family:"Inter","Segoe UI",system-ui,sans-serif}.esc-back{font-weight:600}

src/main/resources/static/css/codeescape-guide.css

@@ -0,0 +1 @@
+.esc-how{display:grid;grid-template-columns:repeat(3,1fr);gap:.65rem;margin:0 0 1rem}.esc-how>div{display:flex;align-items:center;gap:.65rem;padding:.7rem;background:var(--surface);border:1px solid var(--border);border-radius:9px;color:var(--muted)}.esc-how b{display:grid;place-items:center;min-width:1.7rem;height:1.7rem;border:1px solid var(--border);border-radius:50%;color:var(--muted)}.esc-how strong,.esc-how small{display:block}.esc-how strong{color:var(--heading);font-size:.78rem}.esc-how small{margin-top:.15rem;font-size:.65rem}.esc-how .done,.esc-how .active{border-color:var(--esc-accent)}.esc-how .done b{background:var(--success);border-color:var(--success);color:#06120a}.esc-how .active{box-shadow:0 0 18px var(--esc-glow)}.esc-puzzle:not(.done) .status{color:var(--esc-accent)}.esc-puzzle:not(.done):hover{border-color:var(--esc-accent);transform:translateY(-2px)}.esc-fragment{display:flex;align-items:center;gap:.45rem}.esc-fragment small{display:grid;place-items:center;width:1.25rem;height:1.25rem;border-radius:50%;background:var(--esc-accent);color:#160d00;font-size:.6rem}.esc-inventory.complete{border-style:solid;border-color:var(--success)}.esc-ready{margin:.7rem 0 0;color:var(--success);font-size:.75rem}.esc-door{flex-wrap:wrap}.esc-door.ready{border-color:var(--esc-accent);box-shadow:0 0 22px color-mix(in srgb,var(--esc-accent) 14%,transparent)}.esc-door-title{flex-basis:100%;display:flex;justify-content:space-between;align-items:center}.esc-door-title strong{color:var(--heading);font-size:.8rem}.esc-door-feedback{flex-basis:100%;min-height:1.2rem;font-size:.75rem}.esc-door-feedback.ok{color:var(--success)}.esc-door-feedback.bad{color:var(--danger)}.esc-door-feedback.wait{color:var(--esc-accent)}.esc-input.bad{border-color:var(--danger);box-shadow:0 0 0 2px color-mix(in srgb,var(--danger) 28%,transparent)}.esc-btn:disabled{opacity:.45;cursor:not-allowed;box-shadow:none}@media(max-width:800px){.esc-how{grid-template-columns:1fr}.esc-door-title{align-items:flex-start}}

src/main/resources/static/css/devlabgame.css

@@ -3,8 +3,9 @@
 
 @keyframes dlgIn { 0% { opacity: 0; transform: translateY(14px); } 100% { opacity: 1; transform: translateY(0); } }
 
+html { font-size: clamp(16px, calc(12px + 0.34vw), 21px); }
 body.dlg-body { min-height: 100vh; display: flex; flex-direction: column; color: var(--text); }
-.dlg-shell { flex: 1; width: 100%; max-width: 1100px; margin: 0 auto; display: flex; flex-direction: column; padding: 0.7rem 0.9rem 1.4rem; gap: 0.7rem; }
+.dlg-shell { flex: 1; width: min(96vw, 2200px); min-height: 100vh; margin: 0 auto; display: flex; flex-direction: column; padding: clamp(.7rem, 1.2vw, 1.4rem); gap: clamp(.7rem, 1vw, 1.15rem); }
 
 .dlg-header { display: flex; align-items: center; justify-content: space-between; gap: 1rem; padding: 0.5rem 1.1rem; background: var(--surface); border: 1px solid var(--border); border-radius: 12px; box-shadow: var(--g-soft); }
 .dlg-head-title { text-align: center; }
@@ -18,8 +19,8 @@ body.dlg-body { min-height: 100vh; display: flex; flex-direction: column; color:
 .dlg-stat { display: inline-flex; align-items: baseline; gap: 0.4rem; padding: 0.35rem 0.7rem; background: var(--surface-2); border: 1px solid var(--border); border-radius: 10px; font-size: 0.7rem; text-transform: uppercase; letter-spacing: 0.05em; color: var(--muted); white-space: nowrap; }
 .dlg-stat b { font-size: 1.05rem; color: var(--accent); }
 
-.dlg-stage { flex: 1; display: grid; grid-template-columns: 1fr 300px; gap: 0.8rem; align-items: start; }
-.dlg-card { background: var(--surface); border: 1px solid var(--border-accent); border-radius: 16px; padding: 1.3rem 1.5rem 1.4rem; box-shadow: 0 0 24px var(--glow-w); animation: dlgIn 0.32s ease-out; min-width: 0; }
+.dlg-stage { flex: 1; display: grid; grid-template-columns: minmax(0, 3fr) minmax(280px, 1fr); gap: clamp(.8rem, 1.2vw, 1.4rem); align-items: stretch; }
+.dlg-card { background: var(--surface); border: 1px solid var(--border-accent); border-radius: 16px; padding: clamp(1.3rem, 1.7vw, 2.2rem); box-shadow: 0 0 24px var(--glow-w); animation: dlgIn 0.32s ease-out; min-width: 0; }
 .dlg-card-head { display: flex; align-items: center; justify-content: space-between; margin-bottom: 0.5rem; }
 .dlg-points { color: var(--accent); font-weight: 800; }
 .dlg-card h2 { color: var(--heading); font-size: 1.3rem; font-weight: 800; margin-bottom: 0.4rem; }
@@ -111,7 +112,7 @@ body.dlg-body { min-height: 100vh; display: flex; flex-direction: column; color:
 .dlg-result-high[hidden] { display: none; }
 .dlg-result-actions { display: flex; flex-wrap: wrap; gap: 0.7rem; justify-content: center; margin-top: 1rem; }
 
-@media (max-width: 820px) { .dlg-stage { grid-template-columns: 1fr; } }
+@media (max-width: 820px) { html { font-size: 16px; } .dlg-shell { width: 100%; } .dlg-stage { grid-template-columns: 1fr; } }
 @media (max-width: 560px) {
   .dlg-head-title h1 { font-size: 1.05rem; }
   .dlg-stat { font-size: 0.62rem; padding: 0.3rem 0.5rem; }

src/main/resources/static/css/fluxtimer.css

@@ -0,0 +1,50 @@
+/* FluxTimer – Zeitschaltkreis-Optik, rein clientseitig. */
+.ft-trigger { position:relative; color:var(--fluxtimer-secondary); }
+.ft-trigger-icon { width:22px!important; height:22px!important; fill:none; stroke:currentColor; stroke-width:1.35; }
+.ft-trigger-bolt { fill:color-mix(in srgb,currentColor 24%,transparent); stroke-width:1.5; stroke-linejoin:round; }
+.ft-trigger-dot { position:absolute; right:4px; top:4px; width:6px; height:6px; border-radius:50%; background:var(--muted); border:1px solid var(--surface); opacity:.5; }
+.ft-trigger.ft-active { color:var(--fluxtimer-primary); border-color:color-mix(in srgb,var(--fluxtimer-primary) 65%,var(--border)); box-shadow:0 0 14px color-mix(in srgb,var(--fluxtimer-primary) 35%,transparent); }
+.ft-trigger.ft-active .ft-trigger-dot { background:var(--fluxtimer-primary); box-shadow:0 0 8px var(--fluxtimer-primary); opacity:1; }
+.ft-popover { position:fixed; z-index:1600; width:min(340px,calc(100vw - 24px)); padding:1rem; border:1px solid color-mix(in srgb,var(--fluxtimer-secondary) 55%,var(--border)); border-radius:16px; background:var(--panel); box-shadow:0 18px 55px rgba(0,0,0,.38),0 0 24px color-mix(in srgb,var(--fluxtimer-secondary) 22%,transparent); display:none; }
+.ft-popover.open { display:block; animation:ft-in .18s ease-out; }
+.ft-popover-head,.ft-popover-actions,.ft-settings-head,.ft-settings-actions,.ft-options { display:flex; align-items:center; gap:.7rem; }
+.ft-popover-head { justify-content:space-between; margin-bottom:.75rem; }
+.ft-popover-head b { color:var(--heading); letter-spacing:.08em; }
+.ft-close { border:0; background:none; color:var(--muted); cursor:pointer; font-size:1.25rem; }
+.ft-circuit { display:grid; gap:.55rem; padding:.8rem; border-radius:12px; background:var(--fluxtimer-display); border:1px solid color-mix(in srgb,var(--fluxtimer-primary) 45%,var(--border)); box-shadow:inset 0 0 22px rgba(0,0,0,.28); }
+.ft-row { display:grid; grid-template-columns:1fr auto; align-items:center; gap:.7rem; }
+.ft-row span { font-size:.65rem; letter-spacing:.12em; color:var(--muted); }
+.ft-row strong,.ft-preview strong { color:var(--fluxtimer-segment); font-family:"Courier New",monospace; font-variant-numeric:tabular-nums; letter-spacing:.08em; text-shadow:0 0 9px color-mix(in srgb,var(--fluxtimer-segment) 58%,transparent); }
+.ft-row.primary strong { font-size:1.3rem; }
+.ft-popover-status { color:var(--muted); font-size:.8rem; margin:.7rem 0; }
+.ft-popover-actions { justify-content:space-between; flex-wrap:wrap; }
+.ft-mini-toggle { border:1px solid var(--border-accent); background:var(--surface-2); color:var(--text); border-radius:9px; padding:.45rem .7rem; cursor:pointer; font-weight:700; }
+.ft-settings-head { justify-content:space-between; align-items:flex-start; margin-bottom:1rem; }
+.ft-settings-head p { color:var(--muted); font-size:.88rem; margin-top:.25rem; }
+.ft-settings-grid { display:grid; grid-template-columns:1fr 220px; gap:1rem; align-items:stretch; }
+.ft-preview { display:flex; flex-direction:column; justify-content:center; align-items:center; padding:.8rem; border-radius:12px; background:var(--fluxtimer-display); border:1px solid color-mix(in srgb,var(--fluxtimer-primary) 42%,var(--border)); }
+.ft-preview span { color:var(--muted); font-size:.65rem; letter-spacing:.13em; }
+.ft-preview strong { font-size:1.55rem; margin-top:.25rem; }
+.ft-switch { display:inline-flex; align-items:center; gap:.5rem; cursor:pointer; color:var(--text); }
+.ft-switch input { position:absolute; opacity:0; }
+.ft-switch span { width:44px; height:24px; border-radius:99px; background:var(--surface-2); border:1px solid var(--border); position:relative; transition:.2s; }
+.ft-switch span::after { content:""; position:absolute; width:18px; height:18px; left:2px; top:2px; border-radius:50%; background:var(--muted); transition:.2s; }
+.ft-switch input:checked + span { background:color-mix(in srgb,var(--fluxtimer-secondary) 34%,var(--surface)); border-color:var(--fluxtimer-secondary); }
+.ft-switch input:checked + span::after { transform:translateX(20px); background:var(--fluxtimer-secondary); box-shadow:0 0 8px var(--fluxtimer-secondary); }
+.ft-reminders { display:flex; flex-wrap:wrap; gap:.2rem 1rem; border:0; margin:.3rem 0 .8rem; }
+.ft-reminders legend { width:100%; margin-bottom:.25rem; }
+.ft-options { flex-wrap:wrap; margin:.25rem 0 .8rem; }
+.ft-settings-actions { justify-content:space-between; flex-wrap:wrap; }
+.ft-overlay { position:fixed; inset:0; z-index:1900; display:none; place-items:center; padding:1rem; background:rgba(5,3,2,.76); backdrop-filter:blur(7px); }
+.ft-overlay.open { display:grid; }
+.ft-overlay::before { content:""; position:absolute; inset:0; pointer-events:none; background:linear-gradient(115deg,transparent 35%,rgba(255,255,255,.7) 49%,transparent 55%); transform:translateX(-120%); }
+.ft-overlay.open::before { animation:ft-flash .7s ease-out; }
+.ft-modal { position:relative; width:min(560px,100%); text-align:center; padding:1.5rem; border-radius:20px; background:var(--panel); border:1px solid var(--fluxtimer-secondary); box-shadow:0 0 50px color-mix(in srgb,var(--fluxtimer-secondary) 35%,transparent); }
+.ft-modal .ft-kicker { color:var(--fluxtimer-secondary); text-transform:uppercase; letter-spacing:.18em; font-size:.72rem; font-weight:800; }
+.ft-modal h2 { color:var(--heading); font-size:1.7rem; margin:.7rem 0 .4rem; }
+.ft-modal p { color:var(--muted); line-height:1.55; }
+.ft-modal-actions { display:flex; justify-content:center; flex-wrap:wrap; gap:.7rem; margin-top:1.2rem; }
+@keyframes ft-in { from{opacity:0;transform:translateY(-6px)} to{opacity:1;transform:none} }
+@keyframes ft-flash { to{transform:translateX(120%)} }
+@media (max-width:620px){ .ft-settings-grid{grid-template-columns:1fr}.ft-settings-head{align-items:stretch;flex-direction:column}.ft-popover{left:12px!important;right:12px!important;top:64px!important;width:auto} }
+@media (prefers-reduced-motion:reduce){ .ft-popover.open,.ft-overlay.open::before{animation:none} }

src/main/resources/static/css/techtacular.css

@@ -136,7 +136,8 @@ body.tt-body {
 }
 
 .tt-cat-title {
-  flex: 0 0 auto;
+  flex: 0 0 3.5rem;
+  min-height: 3.5rem;
   display: flex;
   align-items: center;
   justify-content: center;

src/main/resources/static/css/theme.css

@@ -14,6 +14,12 @@
   --secondary:#2d9cce; --secondary-2:#5cc4e8;
   --text:#ece3d2; --muted:#8c8170; --heading:#ffffff;
   --success:#2d9cce; --danger:#ff4d6d;
+  --esc-accent:#f0a81a; --esc-glow:rgba(240,168,26,.48);
+  --bh-accent:#d94b64; --bh-glow:rgba(217,75,100,.42);
+  --sc-accent:#38b9d6; --sc-glow:rgba(56,185,214,.40);
+  --nw-accent:#4f8ff7; --nw-glow:rgba(79,143,247,.42);
+  --fluxtimer-primary:#ff5a5f; --fluxtimer-secondary:#f0a81a;
+  --fluxtimer-display:#170704; --fluxtimer-segment:#ff765f;
   --glow-s:rgba(240,168,26,.55); --glow-w:rgba(240,168,26,.16);
   --g-soft:0 0 18px var(--glow-w);
 }
@@ -25,6 +31,12 @@
   --secondary:#1f86b8; --secondary-2:#2d9cce;
   --text:#33271c; --muted:#8a7d6c; --heading:#241a12;
   --success:#1f86b8; --danger:#be123c;
+  --esc-accent:#c96a12; --esc-glow:rgba(201,106,18,.30);
+  --bh-accent:#b42342; --bh-glow:rgba(180,35,66,.26);
+  --sc-accent:#147f9e; --sc-glow:rgba(20,127,158,.26);
+  --nw-accent:#2868c7; --nw-glow:rgba(40,104,199,.26);
+  --fluxtimer-primary:#b42342; --fluxtimer-secondary:#c96a12;
+  --fluxtimer-display:#fff5ec; --fluxtimer-segment:#a93131;
   --glow-s:rgba(214,81,22,.40); --glow-w:rgba(214,81,22,.12);
   --g-soft:0 6px 18px var(--glow-w);
 }
@@ -84,8 +96,6 @@ a { color:var(--secondary); }
 .mf-hello h1 { color:var(--heading); font-size:1.85rem; font-weight:800; letter-spacing:-.01em; }
 .mf-hello h1 .nm { color:var(--accent); text-shadow:0 0 16px var(--glow-s); }
 .mf-hello p { color:var(--muted); margin-top:.35rem; font-size:.95rem; }
-.mf-pulse { flex:1; min-width:0; display:flex; justify-content:center; align-items:center; }
-.mf-pulse svg { width:200px; max-width:100%; filter:drop-shadow(0 0 7px var(--glow-s)); }
 .mf-tools { display:flex; align-items:center; gap:.6rem; margin-left:auto; }
 .mf-iconbtn { width:38px; height:38px; border-radius:10px; border:1px solid var(--border); background:var(--surface); color:var(--muted); display:inline-flex; align-items:center; justify-content:center; cursor:pointer; text-decoration:none; transition:all .18s; }
 .mf-iconbtn:hover { color:var(--accent); border-color:var(--border-accent); box-shadow:0 0 14px var(--glow-w); }
@@ -113,6 +123,8 @@ a { color:var(--secondary); }
 .mf-play { margin-top:.9rem; align-self:flex-start; display:inline-flex; align-items:center; gap:.45rem; font-size:.74rem; font-weight:800; letter-spacing:.08em; color:var(--accent); border:1px solid var(--border-accent); border-radius:8px; padding:.5rem .85rem; text-decoration:none; transition:all .18s; }
 .mf-card:hover .mf-play { background:var(--accent); color:var(--accent-ink); box-shadow:0 0 16px var(--glow-s); }
 .mf-play svg { width:14px; height:14px; }
+.mf-card-codeescape { --accent:var(--esc-accent); --glow-s:var(--esc-glow); --glow-w:color-mix(in srgb,var(--esc-accent) 16%,transparent); background:repeating-linear-gradient(0deg,rgba(255,255,255,.015) 0 1px,transparent 1px 4px),var(--surface); }
+.mf-card-codeescape::after { content:"ACCESS"; position:absolute; right:12px; top:9px; color:var(--esc-accent); font:700 .52rem/1 "Courier New",monospace; letter-spacing:.12em; opacity:.6; }
 
 /* ===== Panels / Widgets ===== */
 .mf-panel { background:var(--surface); border:1px solid var(--border); border-radius:14px; padding:1.1rem; box-shadow:var(--g-soft); }
@@ -186,7 +198,7 @@ body.mf-nav-open .mf-nav-backdrop { opacity:1; pointer-events:auto; }
   .mf-main { padding:1.1rem 1rem 1.4rem; }
   .mf-rightbar { padding:0 1rem 1.4rem; }
   .mf-grid { grid-template-columns:repeat(2,1fr); }
-  .mf-pulse, .mf-search { display:none; }
+  .mf-search { display:none; }
   .mf-hello h1 { font-size:1.4rem; }
   .mf-tools { margin-left:auto; }
 
@@ -203,3 +215,9 @@ body.mf-nav-open .mf-nav-backdrop { opacity:1; pointer-events:auto; }
 }
 
 @media (max-width:560px){ .mf-grid{grid-template-columns:1fr;} }
+
+/* ===== Profilbereich: Tab-Navigation (Fragment fragments/layout :: profileTabs) ===== */
+.mf-tab-nav { display:flex; flex-wrap:wrap; gap:.4rem; margin-bottom:1.4rem; }
+.mf-tab { padding:.55rem .95rem; border-radius:10px; border:1px solid var(--border); color:var(--muted); text-decoration:none; font-size:.85rem; font-weight:700; transition:all .18s ease; }
+.mf-tab:hover { color:var(--text); background:var(--surface-2); }
+.mf-tab.active { color:var(--accent-ink); background:linear-gradient(100deg,var(--accent),var(--accent-2)); box-shadow:0 0 18px var(--glow-s); border-color:transparent; }

src/main/resources/static/finalflux/ap2-fiae/entwurfsmuster.html

@@ -0,0 +1,115 @@
+<!DOCTYPE html>
+<html lang="de" data-theme="dark">
+<head>
+  <meta charset="UTF-8">
+  <title>Entwurfsmuster - FinalFlux AP2</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link rel="stylesheet" href="/css/style.css">
+  <link rel="stylesheet" href="/css/theme.css">
+  <link rel="stylesheet" href="/css/finalflux.css">
+  <script src="/js/theme.js"></script>
+</head>
+<body class="finalflux-page">
+<div class="mf-theme-float"><button class="mf-theme"></button></div>
+<main>
+  <a href="/finalflux" class="back-link">Zurück zu FinalFlux</a>
+  <h1>Entwurfsmuster (Design Patterns)</h1>
+
+  <section>
+    <h2>Lernfokus</h2>
+    <p>AP2 Anwendungsentwicklung: die prüfungsrelevanten Entwurfsmuster erkennen, erklären und dem richtigen Problem zuordnen.</p>
+    <ul class="key-list">
+      <li>Zweck von Entwurfsmustern erklären.</li>
+      <li>Singleton, Factory und Observer unterscheiden.</li>
+      <li>MVC-Schichten und ihre Aufgaben zuordnen.</li>
+    </ul>
+  </section>
+
+  <section>
+    <h2>Was sind Entwurfsmuster?</h2>
+    <p>Entwurfsmuster sind bewährte, wiederverwendbare Lösungsschablonen für häufige Probleme im Software-Design. Sie sind kein fertiger Code, sondern beschreiben eine Struktur aus Klassen und deren Zusammenspiel. In der AP2 wird typischerweise verlangt, ein Muster zu benennen, seinen Zweck zu erklären oder es in einem UML-Diagramm wiederzuerkennen.</p>
+    <p class="merksatz"><strong>Merksatz:</strong> Ein Entwurfsmuster ist eine Schablone für ein Entwurfsproblem – nicht der Code selbst.</p>
+  </section>
+
+  <section>
+    <h2>Singleton</h2>
+    <p>Stellt sicher, dass von einer Klasse <strong>genau eine Instanz</strong> existiert, und bietet einen globalen Zugriffspunkt darauf. Typische Einsätze: Konfiguration, Logger, Verbindungs-Pools.</p>
+    <ul class="key-list">
+      <li><strong>Privater Konstruktor:</strong> verhindert Instanziierung von außen.</li>
+      <li><strong>Statische Zugriffsmethode</strong> (z. B. <code>getInstance()</code>) liefert immer dieselbe Instanz.</li>
+      <li><strong>Kritik:</strong> globaler Zustand erschwert Tests – in der Prüfung als Nachteil nennen können.</li>
+    </ul>
+  </section>
+
+  <section>
+    <h2>Factory (Fabrikmethode)</h2>
+    <p>Kapselt die Objekterzeugung: Der aufrufende Code kennt nur das Interface, die Fabrik entscheidet, welche konkrete Klasse instanziiert wird. So lassen sich neue Varianten ergänzen, ohne den Client-Code zu ändern (Offen-Geschlossen-Prinzip).</p>
+    <ul class="key-list">
+      <li><strong>Problem:</strong> <code>new KonkreteKlasse()</code> überall verstreut macht Änderungen teuer.</li>
+      <li><strong>Lösung:</strong> zentrale Erzeugungsmethode, die das passende Objekt liefert.</li>
+    </ul>
+  </section>
+
+  <section>
+    <h2>Observer (Beobachter)</h2>
+    <p>Ein Subjekt hält eine Liste von Beobachtern und benachrichtigt sie automatisch bei Zustandsänderungen (1:n-Abhängigkeit). Grundlage vieler GUI- und Event-Systeme.</p>
+    <ul class="key-list">
+      <li><strong>Subjekt:</strong> <code>anmelden()</code>, <code>abmelden()</code>, <code>benachrichtigen()</code>.</li>
+      <li><strong>Beobachter:</strong> gemeinsames Interface mit <code>aktualisiere()</code>.</li>
+      <li><strong>Vorteil:</strong> lose Kopplung – das Subjekt kennt nur das Interface.</li>
+    </ul>
+    <p class="merksatz"><strong>Merksatz:</strong> Observer = abonnieren und benachrichtigt werden, statt ständig nachzufragen (Polling).</p>
+  </section>
+
+  <section>
+    <h2>MVC (Model-View-Controller)</h2>
+    <p>Architektur-Muster, das eine Anwendung in drei Verantwortlichkeiten trennt. In der AP2 häufig als Zuordnungsaufgabe gefragt.</p>
+    <ul class="key-list">
+      <li><strong>Model:</strong> Daten und Geschäftslogik – unabhängig von der Darstellung.</li>
+      <li><strong>View:</strong> Präsentation der Daten für den Benutzer.</li>
+      <li><strong>Controller:</strong> nimmt Eingaben entgegen, ruft das Model auf, wählt die View.</li>
+    </ul>
+    <p>Vorteile: getrennte Zuständigkeiten, parallele Entwicklung, bessere Testbarkeit, austauschbare Oberflächen.</p>
+  </section>
+
+  <section>
+    <h2>Prüfungsmodus</h2>
+    <p>Dieser FluxCheck führt dich durch die wichtigsten AP2-Aspekte dieses Themas. Du kannst Antworten prüfen, Fragen überspringen und bekommst am Ende eine Auswertung nach Kategorie.</p>
+  </section>
+
+  <section class="finalflux-test" data-finalflux-test aria-live="polite">
+    <div class="test-meta">
+      <span data-question-counter>Frage 1</span>
+      <span data-score-counter>0 richtig</span>
+    </div>
+    <div class="category-block">
+      <p class="eyebrow">Kategorie</p>
+      <h2 data-category-title>Entwurfsmuster</h2>
+      <p data-category-hint>AP2-Training</p>
+    </div>
+    <div class="question-card">
+      <h3 data-question-text></h3>
+      <div data-answer-options class="answer-options"></div>
+      <div data-answer-feedback class="fluxcheck-result"></div>
+    </div>
+    <div class="test-actions">
+      <button type="button" data-check-answer>Antwort prüfen</button>
+      <button type="button" data-skip-question class="secondary">Überspringen</button>
+      <button type="button" data-next-question class="secondary" disabled>Weiter</button>
+    </div>
+  </section>
+
+  <section data-test-result class="finalflux-panel" hidden>
+    <h2>Auswertung</h2>
+    <p data-result-summary></p>
+    <ul data-category-summary class="key-list"></ul>
+    <div class="finalflux-actions">
+      <button type="button" data-restart-test>Test neu starten</button>
+      <a href="/finalflux">Zurück zur Übersicht</a>
+    </div>
+  </section>
+</main>
+
+<script src="/js/finalflux-test.js" data-questions-src="/finalflux/questions/ap2_fiae_entwurfsmuster.json" defer></script>
+</body>
+</html>

src/main/resources/static/finalflux/ap2-fisi/hochverfuegbarkeit.html

@@ -0,0 +1,101 @@
+<!DOCTYPE html>
+<html lang="de" data-theme="dark">
+<head>
+  <meta charset="UTF-8">
+  <title>Hochverfügbarkeit - FinalFlux AP2</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link rel="stylesheet" href="/css/style.css">
+  <link rel="stylesheet" href="/css/theme.css">
+  <link rel="stylesheet" href="/css/finalflux.css">
+  <script src="/js/theme.js"></script>
+</head>
+<body class="finalflux-page">
+<div class="mf-theme-float"><button class="mf-theme"></button></div>
+<main>
+  <a href="/finalflux" class="back-link">Zurück zu FinalFlux</a>
+  <h1>Hochverfügbarkeit (HA)</h1>
+
+  <section>
+    <h2>Lernfokus</h2>
+    <p>AP2 Systemintegration: Verfügbarkeit berechnen, Redundanzkonzepte unterscheiden und RTO/RPO sicher einordnen.</p>
+    <ul class="key-list">
+      <li>Verfügbarkeit in Prozent und Ausfallzeit umrechnen.</li>
+      <li>Redundanzkonzepte (RAID, Cluster, USV, Netzteil) einordnen.</li>
+      <li>RTO und RPO unterscheiden.</li>
+    </ul>
+  </section>
+
+  <section>
+    <h2>Was bedeutet Hochverfügbarkeit?</h2>
+    <p>Hochverfügbarkeit beschreibt die Fähigkeit eines Systems, trotz Ausfällen einzelner Komponenten weiterzulaufen. Die Verfügbarkeit wird in Prozent der Betriebszeit angegeben – die bekannten „Neunen": 99 % bedeuten rund 3,65 Tage Ausfall pro Jahr, 99,9 % rund 8,76 Stunden, 99,99 % rund 53 Minuten.</p>
+    <ul class="key-list">
+      <li><strong>Formel:</strong> Verfügbarkeit = (Gesamtzeit − Ausfallzeit) / Gesamtzeit × 100 %.</li>
+      <li><strong>SPOF (Single Point of Failure):</strong> jede Komponente, deren Ausfall das Gesamtsystem stoppt – Ziel ist, SPOFs durch Redundanz zu eliminieren.</li>
+      <li><strong>MTBF/MTTR:</strong> mittlere Zeit zwischen Ausfällen bzw. mittlere Reparaturzeit.</li>
+    </ul>
+    <p class="merksatz"><strong>Merksatz:</strong> Jede zusätzliche „Neun" kostet überproportional mehr – Verfügbarkeit ist immer eine Kosten-Nutzen-Abwägung.</p>
+  </section>
+
+  <section>
+    <h2>Redundanzkonzepte</h2>
+    <p>Redundanz bedeutet, kritische Komponenten mehrfach auszulegen, damit der Ausfall einer Komponente abgefangen wird.</p>
+    <ul class="key-list">
+      <li><strong>RAID:</strong> schützt gegen Ausfall einzelner Festplatten – <em>ersetzt aber kein Backup</em> (gelöschte Daten sind auf allen Platten gelöscht).</li>
+      <li><strong>Cluster (Failover):</strong> zweiter Server übernimmt automatisch, wenn der aktive ausfällt (aktiv/passiv) oder Last wird verteilt (aktiv/aktiv).</li>
+      <li><strong>USV:</strong> überbrückt Stromausfälle und ermöglicht geordnetes Herunterfahren.</li>
+      <li><strong>Redundante Netzteile/Netzwerkpfade:</strong> doppelte Stromversorgung, zwei Switches/Uplinks gegen SPOFs im Netz.</li>
+      <li><strong>Georedundanz:</strong> zweiter Standort gegen Standortausfall (Brand, Hochwasser).</li>
+    </ul>
+  </section>
+
+  <section>
+    <h2>RTO und RPO</h2>
+    <p>Zwei Kennzahlen aus der Notfallplanung, die in der AP2 gern verwechselt werden:</p>
+    <ul class="key-list">
+      <li><strong>RTO (Recovery Time Objective):</strong> Wie lange darf die Wiederherstellung maximal dauern? → maximale Ausfall<em>zeit</em>.</li>
+      <li><strong>RPO (Recovery Point Objective):</strong> Wie viele Daten dürfen maximal verloren gehen? → maximaler Daten<em>verlust</em>, bestimmt die Backup-Frequenz.</li>
+    </ul>
+    <p class="merksatz"><strong>Merksatz:</strong> RTO = Zeit bis alles wieder läuft, RPO = Zeitraum an Daten, der fehlen darf.</p>
+  </section>
+
+  <section>
+    <h2>Prüfungsmodus</h2>
+    <p>Dieser FluxCheck führt dich durch die wichtigsten AP2-Aspekte dieses Themas. Du kannst Antworten prüfen, Fragen überspringen und bekommst am Ende eine Auswertung nach Kategorie.</p>
+  </section>
+
+  <section class="finalflux-test" data-finalflux-test aria-live="polite">
+    <div class="test-meta">
+      <span data-question-counter>Frage 1</span>
+      <span data-score-counter>0 richtig</span>
+    </div>
+    <div class="category-block">
+      <p class="eyebrow">Kategorie</p>
+      <h2 data-category-title>Hochverfügbarkeit</h2>
+      <p data-category-hint>AP2-Training</p>
+    </div>
+    <div class="question-card">
+      <h3 data-question-text></h3>
+      <div data-answer-options class="answer-options"></div>
+      <div data-answer-feedback class="fluxcheck-result"></div>
+    </div>
+    <div class="test-actions">
+      <button type="button" data-check-answer>Antwort prüfen</button>
+      <button type="button" data-skip-question class="secondary">Überspringen</button>
+      <button type="button" data-next-question class="secondary" disabled>Weiter</button>
+    </div>
+  </section>
+
+  <section data-test-result class="finalflux-panel" hidden>
+    <h2>Auswertung</h2>
+    <p data-result-summary></p>
+    <ul data-category-summary class="key-list"></ul>
+    <div class="finalflux-actions">
+      <button type="button" data-restart-test>Test neu starten</button>
+      <a href="/finalflux">Zurück zur Übersicht</a>
+    </div>
+  </section>
+</main>
+
+<script src="/js/finalflux-test.js" data-questions-src="/finalflux/questions/ap2_fisi_hochverfuegbarkeit.json" defer></script>
+</body>
+</html>

src/main/resources/static/finalflux/questions/ap2_fiae_entwurfsmuster.json

@@ -0,0 +1,77 @@
+{
+  "title": "Entwurfsmuster",
+  "questions": [
+    {
+      "category": "Grundlagen",
+      "hint": "Zweck von Entwurfsmustern.",
+      "text": "Was ist ein Entwurfsmuster?",
+      "answers": [
+        "Eine bewährte, wiederverwendbare Lösungsschablone für ein häufiges Entwurfsproblem.",
+        "Eine fertige Code-Bibliothek, die direkt eingebunden wird.",
+        "Ein Werkzeug zur automatischen Codegenerierung aus UML-Diagrammen."
+      ],
+      "correct": 0,
+      "explanation": "Ein Entwurfsmuster beschreibt eine Struktur und ihr Zusammenspiel – es ist kein fertiger Code, sondern eine Schablone."
+    },
+    {
+      "category": "Singleton",
+      "hint": "Genau eine Instanz.",
+      "text": "Welches Merkmal gehört zwingend zum Singleton-Muster?",
+      "answers": [
+        "Ein öffentlicher Konstruktor, damit jede Klasse Instanzen erzeugen kann.",
+        "Ein privater Konstruktor und eine statische Zugriffsmethode auf die einzige Instanz.",
+        "Eine Liste von Beobachtern, die bei Änderungen benachrichtigt werden."
+      ],
+      "correct": 1,
+      "explanation": "Der private Konstruktor verhindert Fremd-Instanziierung; getInstance() liefert immer dieselbe Instanz."
+    },
+    {
+      "category": "Factory",
+      "hint": "Objekterzeugung kapseln.",
+      "text": "Welches Problem löst die Fabrikmethode (Factory)?",
+      "answers": [
+        "Sie sorgt dafür, dass Objekte automatisch gelöscht werden.",
+        "Sie verschlüsselt die Kommunikation zwischen Objekten.",
+        "Sie kapselt die Objekterzeugung, sodass der Client nur das Interface kennt."
+      ],
+      "correct": 2,
+      "explanation": "Die Fabrik entscheidet, welche konkrete Klasse instanziiert wird – neue Varianten erfordern keine Änderung im Client-Code."
+    },
+    {
+      "category": "Observer",
+      "hint": "1:n-Abhängigkeit.",
+      "text": "Wann ist das Observer-Muster die richtige Wahl?",
+      "answers": [
+        "Wenn mehrere Objekte automatisch über Zustandsänderungen eines Objekts informiert werden sollen.",
+        "Wenn von einer Klasse nur eine einzige Instanz existieren darf.",
+        "Wenn die Erzeugung von Objekten zentralisiert werden soll."
+      ],
+      "correct": 0,
+      "explanation": "Das Subjekt benachrichtigt alle angemeldeten Beobachter – lose gekoppelt über ein gemeinsames Interface."
+    },
+    {
+      "category": "MVC",
+      "hint": "Drei Verantwortlichkeiten.",
+      "text": "Welche Aufgabe hat der Controller im MVC-Muster?",
+      "answers": [
+        "Er speichert die Daten und enthält die Geschäftslogik.",
+        "Er nimmt Benutzereingaben entgegen, ruft das Model auf und wählt die View.",
+        "Er stellt die Daten grafisch für den Benutzer dar."
+      ],
+      "correct": 1,
+      "explanation": "Model = Daten/Logik, View = Darstellung, Controller = Vermittler zwischen Eingabe, Model und View."
+    },
+    {
+      "category": "MVC",
+      "hint": "Vorteile der Trennung.",
+      "text": "Welcher Vorteil ergibt sich direkt aus der MVC-Trennung?",
+      "answers": [
+        "Die Anwendung benötigt keine Datenbank mehr.",
+        "Der Quellcode wird automatisch schneller ausgeführt.",
+        "Oberfläche und Logik sind getrennt test- und austauschbar."
+      ],
+      "correct": 2,
+      "explanation": "Durch die Trennung der Schichten lassen sich Views austauschen und Model-Logik isoliert testen."
+    }
+  ]
+}

src/main/resources/static/finalflux/questions/ap2_fisi_hochverfuegbarkeit.json

@@ -0,0 +1,77 @@
+{
+  "title": "Hochverfügbarkeit",
+  "questions": [
+    {
+      "category": "Grundlagen",
+      "hint": "Die Neunen kennen.",
+      "text": "Ein System hat eine Verfügbarkeit von 99,9 % pro Jahr. Wie viel Ausfallzeit entspricht das ungefähr?",
+      "answers": [
+        "Rund 8,8 Stunden pro Jahr.",
+        "Rund 3,65 Tage pro Jahr.",
+        "Rund 53 Minuten pro Jahr."
+      ],
+      "correct": 0,
+      "explanation": "0,1 % von 8760 Stunden sind rund 8,76 Stunden. 3,65 Tage gehören zu 99 %, 53 Minuten zu 99,99 %."
+    },
+    {
+      "category": "Grundlagen",
+      "hint": "Kritische Einzelkomponenten.",
+      "text": "Was ist ein Single Point of Failure (SPOF)?",
+      "answers": [
+        "Eine Komponente, die doppelt ausgelegt ist und darum nie ausfällt.",
+        "Eine Komponente, deren Ausfall das gesamte System zum Stillstand bringt.",
+        "Der zentrale Monitoring-Server eines Rechenzentrums."
+      ],
+      "correct": 1,
+      "explanation": "Ein SPOF ist jede nicht redundante Komponente, an der das Gesamtsystem hängt – Ziel ist, SPOFs durch Redundanz zu eliminieren."
+    },
+    {
+      "category": "Redundanz",
+      "hint": "RAID richtig einordnen.",
+      "text": "Warum ersetzt ein RAID kein Backup?",
+      "answers": [
+        "Weil RAID nur bei SSDs funktioniert, Backups aber auf Festplatten liegen.",
+        "Weil RAID die Daten komprimiert und dadurch Datenverlust entsteht.",
+        "Weil versehentlich gelöschte oder verschlüsselte Daten sofort auf allen Platten betroffen sind."
+      ],
+      "correct": 2,
+      "explanation": "RAID schützt gegen Hardware-Ausfall einzelner Platten. Logische Fehler (Löschen, Ransomware) treffen alle Kopien gleichzeitig – dagegen hilft nur ein Backup."
+    },
+    {
+      "category": "Redundanz",
+      "hint": "Cluster-Betriebsarten.",
+      "text": "Was kennzeichnet einen Aktiv/Passiv-Failover-Cluster?",
+      "answers": [
+        "Ein Standby-Server übernimmt automatisch, wenn der aktive Server ausfällt.",
+        "Beide Server bearbeiten dauerhaft gemeinsam die Last.",
+        "Die Server sichern sich gegenseitig täglich per Backup."
+      ],
+      "correct": 0,
+      "explanation": "Beim Aktiv/Passiv-Cluster steht der zweite Knoten bereit und übernimmt beim Ausfall (Failover). Aktiv/Aktiv verteilt dagegen die Last auf beide."
+    },
+    {
+      "category": "RTO & RPO",
+      "hint": "Zeit vs. Datenverlust.",
+      "text": "Welche Aussage zu RTO und RPO ist korrekt?",
+      "answers": [
+        "RTO begrenzt den maximalen Datenverlust, RPO die Wiederherstellungszeit.",
+        "RTO begrenzt die maximale Wiederherstellungszeit, RPO den maximalen Datenverlust.",
+        "RTO und RPO bezeichnen dasselbe und sind austauschbar."
+      ],
+      "correct": 1,
+      "explanation": "RTO = wie lange darf die Wiederherstellung dauern; RPO = wie alt darf der letzte Datenstand sein (bestimmt die Backup-Frequenz)."
+    },
+    {
+      "category": "RTO & RPO",
+      "hint": "Backup-Frequenz ableiten.",
+      "text": "Ein Unternehmen definiert einen RPO von 1 Stunde. Was folgt daraus?",
+      "answers": [
+        "Das System muss nach einem Ausfall innerhalb 1 Stunde wieder laufen.",
+        "Die USV muss das System mindestens 1 Stunde überbrücken.",
+        "Die Daten müssen mindestens stündlich gesichert bzw. repliziert werden."
+      ],
+      "correct": 2,
+      "explanation": "Der RPO begrenzt den maximal tolerierten Datenverlust – bei 1 Stunde RPO darf der letzte Sicherungsstand höchstens 1 Stunde alt sein."
+    }
+  ]
+}

src/main/resources/static/js/accessibility.js

@@ -0,0 +1,11 @@
+(function(){'use strict';var KEY='mf-accessibility',levels=[100,115,130,150],defaults={font:100,readable:false,contrast:false,color:false,mono:false,links:false,motion:true,cursor:false};
+function load(){try{return Object.assign({},defaults,JSON.parse(localStorage.getItem(KEY)||'{}'));}catch(e){return Object.assign({},defaults);}}var state=load();
+function apply(){var h=document.documentElement;h.setAttribute('data-mf-font',String(state.font));h.setAttribute('data-mf-readable',state.readable);h.setAttribute('data-mf-contrast',state.contrast);h.setAttribute('data-mf-color',state.color?'safe':'standard');h.setAttribute('data-mf-mono',state.mono);h.setAttribute('data-mf-links',state.links);h.setAttribute('data-mf-motion',state.motion);h.setAttribute('data-mf-cursor',state.cursor);try{localStorage.setItem(KEY,JSON.stringify(state));}catch(e){}}
+apply();
+function button(id,icon,label,detail){return '<button type="button" class="mf-a11y-option" data-a11y="'+id+'"><strong aria-hidden="true">'+icon+'</strong><span>'+label+'</span>'+(detail?'<small>'+detail+'</small>':'')+'</button>';}
+function init(){if(document.querySelector('.mf-a11y-trigger'))return;var trigger=document.createElement('button');trigger.type='button';trigger.className='mf-a11y-trigger';trigger.setAttribute('aria-label','Barrierefreiheit öffnen');trigger.setAttribute('aria-expanded','false');trigger.setAttribute('aria-controls','mf-a11y-panel');trigger.innerHTML='<svg viewBox="0 0 32 32" fill="none" stroke="currentColor" stroke-width="2.5" aria-hidden="true"><circle cx="18" cy="5" r="3" fill="currentColor"/><path d="M13 11l5-2 5 4m-7-2-2 7-6 1m8-4 6 2 3 7M13 18a7 7 0 1 0 6 7"/></svg>';
+var panel=document.createElement('section');panel.id='mf-a11y-panel';panel.className='mf-a11y-panel';panel.hidden=true;panel.setAttribute('role','dialog');panel.setAttribute('aria-modal','false');panel.setAttribute('aria-labelledby','mf-a11y-title');panel.innerHTML='<div class="mf-a11y-head"><button type="button" class="mf-a11y-close" aria-label="Barrierefreiheit schließen">×</button><h2 id="mf-a11y-title">Barrierefreiheit</h2></div><div class="mf-a11y-grid">'+button('font','T⁺','Text vergrößern','100 %')+button('contrast','◐','Hochkontrast')+button('color','◉','Farbenblind-Modus')+button('mono','◒','Monochrom')+button('readable','Aa','Lesemodus (Dyslexie)','Verdana + Abstände')+button('links','🔗','Links unterstreichen')+button('motion','Ⅱ','Animationen stoppen')+button('cursor','➤','Großer Cursor')+button('reset','↺','Alles zurücksetzen')+'</div>';
+document.body.appendChild(trigger);document.body.appendChild(panel);var close=panel.querySelector('.mf-a11y-close');function paint(){panel.querySelectorAll('[data-a11y]').forEach(function(b){var id=b.dataset.a11y,on=id==='font'?state.font>100:id==='motion'?!state.motion:id==='reset'?false:!!state[id];b.setAttribute('aria-pressed',on);if(id==='font')b.querySelector('small').textContent=state.font+' %';});}
+var host=document.querySelector('.mf-a11y-host,.mf-tools,.tt-header-tools,.mm-header-tools,.ss-header-tools,.dlg-header-tools,.mf-theme-float');if(host){host.insertBefore(trigger,host.firstChild);}else{var utility=document.createElement('div');utility.className='mf-a11y-utility';utility.setAttribute('aria-label','Globale Werkzeuge');utility.appendChild(trigger);document.body.insertBefore(utility,document.body.firstChild);}
+function hide(){panel.hidden=true;trigger.setAttribute('aria-expanded','false');trigger.focus();}function show(){panel.hidden=false;trigger.setAttribute('aria-expanded','true');paint();close.focus();}trigger.addEventListener('click',function(){panel.hidden?show():hide();});close.addEventListener('click',hide);window.addEventListener('keydown',function(e){if(e.key==='Escape'&&!panel.hidden)hide();});panel.addEventListener('click',function(e){var b=e.target.closest('[data-a11y]');if(!b)return;var id=b.dataset.a11y;if(id==='reset')state=Object.assign({},defaults);else if(id==='font')state.font=levels[(levels.indexOf(state.font)+1)%levels.length];else if(id==='motion')state.motion=!state.motion;else state[id]=!state[id];apply();paint();});paint();}
+if(document.readyState==='loading')document.addEventListener('DOMContentLoaded',init);else init();})();

src/main/resources/static/js/codeescape.js

@@ -0,0 +1,18 @@
+(function(){'use strict';const view=document.getElementById('escView'),timerEl=document.getElementById('escTimer');let catalog=[],session=null,roomIndex=0,start=0,tickId=null,answers=new Map(),fragments=new Map(),selected=null;
+const api=(url,opt)=>fetch('/api/codeescape'+url,{headers:{'Content-Type':'application/json'},...opt}).then(async r=>{const j=await r.json();if(!r.ok)throw new Error(j.message||'Serverfehler');return j});
+function esc(s){return String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));}function post(url,data){return api(url,{method:'POST',body:JSON.stringify(data)});}function seconds(){return Math.max(1,Math.round((Date.now()-start)/1000));}
+function startTimer(){clearInterval(tickId);start=Date.now();tickId=setInterval(()=>{let left=session.timeLimitSeconds-seconds();timerEl.textContent=(left<0?'+':'')+fmt(Math.abs(left));timerEl.classList.toggle('alarm',left<=0);},1000);}function fmt(s){return String(Math.floor(s/60)).padStart(2,'0')+':'+String(s%60).padStart(2,'0');}
+function loadCatalog(){api('/scenarios').then(d=>{catalog=d.scenarios;renderLobby();}).catch(error);}
+function renderLobby(){timerEl.textContent='--:--';view.innerHTML='<div class="esc-hero"><span class="esc-eyebrow">FACILITY ARCHIVE // VARIABLE RUNS</span><h1>Wähle deinen Fluchtweg</h1><p>Jeder Run stellt vier Räume neu aus einem größeren Pool zusammen. Löse IT-Rätsel, sichere Fragmente und entkomme – der nächste Durchlauf wird anders.</p></div><div class="esc-grid">'+catalog.map(s=>`<article class="esc-card"><span class="esc-eyebrow">${esc(s.examScope)} · ${esc(s.difficulty)}</span><h2>${esc(s.title)}</h2><p>${esc(s.description)}</p><div class="esc-meta"><span class="esc-chip">${s.roomCount} Räume pro Run</span><span class="esc-chip">${s.poolSize} im Pool</span><span class="esc-chip">${Math.round(s.timeLimitSeconds/60)} Minuten</span></div><button class="esc-btn" data-start="${esc(s.slug)}">NEUEN RUN GENERIEREN</button></article>`).join('')+'</div>';view.querySelectorAll('[data-start]').forEach(b=>b.onclick=()=>begin(b.dataset.start));}
+function begin(slug){api('/session/'+encodeURIComponent(slug)).then(d=>{session=d;roomIndex=0;answers.clear();fragments.clear();startTimer();renderRoom();}).catch(error);}
+function renderRoom(){const r=session.rooms[roomIndex],complete=r.puzzles.every(p=>answers.has(p.puzzleId));view.innerHTML=`<div class="esc-room-head"><div><span class="esc-eyebrow">RAUM ${roomIndex+1} / ${session.rooms.length} · ${esc(session.examScope)}</span><h1>${esc(r.title)}</h1><p>${esc(r.intro)}</p></div><div class="esc-progress">${'● '.repeat(roomIndex+1)}${'○ '.repeat(session.rooms.length-roomIndex-1)}</div></div><div class="esc-how"><div class="${complete?'done':''}"><b>1</b><span><strong>Rätsel lösen</strong><small>Die Rätsel sind frei wählbar.</small></span></div><div class="${complete?'done':''}"><b>2</b><span><strong>Fragmente sammeln</strong><small>Ihre Reihenfolge ist links → rechts.</small></span></div><div class="${complete?'active':''}"><b>3</b><span><strong>Türcode bilden</strong><small>Ohne Leerzeichen zusammensetzen.</small></span></div></div><div class="esc-puzzles">${r.puzzles.map((p,i)=>`<button class="esc-puzzle ${answers.has(p.puzzleId)?'done':''}" data-puzzle="${p.puzzleId}"><span class="esc-eyebrow">RÄTSEL ${i+1} · ${esc(p.type)}</span><h3>${esc(p.prompt)}</h3><div class="status">${answers.has(p.puzzleId)?'✓ FRAGMENT GESICHERT':'ANKLICKEN UND LÖSEN →'}</div></button>`).join('')}</div><div class="esc-inventory ${complete?'complete':''}"><span class="esc-eyebrow">2 · FRAGMENTE VON LINKS NACH RECHTS</span><div class="esc-fragments">${r.puzzles.map((p,i)=>`<span class="esc-fragment"><small>${i+1}</small>${fragments.has(p.puzzleId)?esc(fragments.get(p.puzzleId)):'•••'}</span>`).join('')}</div>${complete?'<p class="esc-ready">✓ Alle Fragmente gesichert. Bilde jetzt unten den Türcode.</p>':''}</div><div class="esc-door ${complete?'ready':''}"><div class="esc-door-title"><span class="esc-eyebrow">3 · TÜRTERMINAL</span><strong>${complete?'Schleuse bereit':'Noch nicht verfügbar'}</strong></div><label>${complete?esc(r.doorPrompt):'Löse zuerst alle Rätsel, um das Terminal freizuschalten.'}<input class="esc-input" id="doorCode" autocomplete="off" spellcheck="false" ${complete?'':'disabled'}></label>${complete?'<button class="esc-btn" id="assembleBtn">FRAGMENTE EINSETZEN</button>':''}<button class="esc-btn primary" id="doorBtn" ${complete?'':'disabled'}>CODE PRÜFEN &amp; ÖFFNEN</button><button class="esc-btn danger" id="quitBtn">AUFGEBEN</button><div class="esc-door-feedback" id="doorFeedback" role="status" aria-live="polite"></div></div>`;view.querySelectorAll('[data-puzzle]').forEach(b=>b.onclick=()=>openPuzzle(r.puzzles.find(p=>p.puzzleId==b.dataset.puzzle)));if(complete){document.getElementById('assembleBtn').onclick=()=>{document.getElementById('doorCode').value=r.puzzles.map(p=>fragments.get(p.puzzleId)).join('');document.getElementById('doorCode').focus();doorMessage('Fragmente eingesetzt. Prüfe den Code und öffne die Schleuse.','ok');};document.getElementById('doorCode').onkeydown=e=>{if(e.key==='Enter')openDoor(r);};}document.getElementById('doorBtn').onclick=()=>openDoor(r);document.getElementById('quitBtn').onclick=()=>finish(false);}
+function control(p){if(p.type==='code')return `<input class="esc-input" id="answer" placeholder="${esc(p.placeholder||'Antwort')}">`;if(p.type==='choice')return `<div class="esc-options">${p.options.map(x=>`<button class="esc-option" data-value="${esc(x)}">${esc(x)}</button>`).join('')}</div>`;if(p.type==='order')return `<div class="esc-options">${p.items.map((x,i)=>`<label>${i+1}.<select class="esc-select order">${p.items.map(y=>`<option>${esc(y)}</option>`).join('')}</select></label>`).join('')}</div>`;if(p.type==='match')return `<div class="esc-pairs">${p.left.map(x=>`<label>${esc(x)}<select class="esc-select pair" data-left="${esc(x)}">${p.right.map(y=>`<option>${esc(y)}</option>`).join('')}</select></label>`).join('')}</div>`;return'';}
+function openPuzzle(p){selected=null;document.body.insertAdjacentHTML('beforeend',`<div class="esc-modal"><div class="esc-dialog"><span class="esc-eyebrow">SECURE TERMINAL · ${esc(p.type)}</span><h2>${esc(p.prompt)}</h2><p>${esc(p.narrative||p.instruction||'Löse das Zugriffsrätsel.')}</p>${p.narrative&&p.instruction?`<p>${esc(p.instruction)}</p>`:''}${control(p)}<div class="esc-feedback" id="feedback"></div><div class="esc-actions"><button class="esc-btn primary" id="checkBtn">PRÜFEN</button><button class="esc-btn" id="hintBtn">HINWEIS</button><button class="esc-btn danger" id="revealBtn">AUFLÖSEN</button><button class="esc-btn" id="closeBtn">SCHLIESSEN</button></div></div></div>`);const modal=document.querySelector('.esc-modal');modal.querySelectorAll('.esc-option').forEach(b=>b.onclick=()=>{modal.querySelectorAll('.esc-option').forEach(x=>x.classList.remove('selected'));b.classList.add('selected');selected=b.dataset.value;});document.getElementById('closeBtn').onclick=()=>modal.remove();let hintLevel=0;document.getElementById('hintBtn').onclick=()=>post('/hint',{puzzleId:p.puzzleId,level:Math.min(2,++hintLevel)}).then(x=>feedback(x.text,'ok'));document.getElementById('checkBtn').onclick=()=>checkPuzzle(p,false,modal);document.getElementById('revealBtn').onclick=()=>checkPuzzle(p,true,modal);}
+function submission(p,modal){if(p.type==='code')return{answer:modal.querySelector('#answer').value};if(p.type==='choice')return{answer:selected||''};if(p.type==='order')return{items:[...modal.querySelectorAll('.order')].map(x=>x.value)};if(p.type==='match')return{pairs:[...modal.querySelectorAll('.pair')].map(x=>[x.dataset.left,x.value])};return{};}
+function checkPuzzle(p,reveal,modal){const sub=submission(p,modal);post('/check',{puzzleId:p.puzzleId,reveal,submission:sub}).then(x=>{if(x.resolved){answers.set(p.puzzleId,{puzzleId:p.puzzleId,submission:sub});fragments.set(p.puzzleId,x.fragment);feedback(reveal?'Auflösung freigegeben. Fragment gesichert.':'Zugriff bestätigt. Fragment gesichert.','ok');setTimeout(()=>{modal.remove();renderRoom();},700);}else feedback('Zugriff verweigert. Prüfe deine Eingabe.','bad');}).catch(e=>feedback(e.message,'bad'));}
+function feedback(t,c){const f=document.getElementById('feedback');if(f){f.textContent=t;f.className='esc-feedback '+c;}}
+function doorMessage(text,type){const box=document.getElementById('doorFeedback');if(box){box.textContent=text;box.className='esc-door-feedback '+type;}}
+function openDoor(r){const input=document.getElementById('doorCode'),button=document.getElementById('doorBtn'),code=input.value.trim();input.classList.remove('bad');if(!code){input.classList.add('bad');doorMessage('Setze zuerst die Fragmente zu einem Code zusammen.','bad');input.focus();return;}button.disabled=true;button.textContent='CODE WIRD GEPRÜFT …';doorMessage('Türterminal prüft den Code …','wait');post('/door',{roomId:r.roomId,code}).then(x=>{if(!x.open){input.classList.add('bad');doorMessage(x.message||'Code abgelehnt. Prüfe die Reihenfolge der Fragmente.','bad');button.disabled=false;button.textContent='CODE PRÜFEN & ÖFFNEN';input.focus();return;}doorMessage('✓ '+(x.successText||'Schleuse geöffnet.'),'ok');setTimeout(()=>{if(roomIndex<session.rooms.length-1){roomIndex++;renderRoom();}else finish(true);},1100);}).catch(e=>{doorMessage(e.message||'Das Türterminal ist nicht erreichbar.','bad');button.disabled=false;button.textContent='ERNEUT VERSUCHEN';});}
+function finish(escaped){clearInterval(tickId);post('/finish',{slug:session.slug,durationSeconds:seconds(),escaped,items:[...answers.values()],doors:[]}).then(renderResult).catch(error);}
+function renderResult(r){timerEl.textContent='ESCAPED';view.innerHTML=`<section class="esc-result"><span class="esc-eyebrow">FACILITY RUN ABGESCHLOSSEN</span><h1>${r.escaped?'AUSGANG ERREICHT':'RUN BEENDET'}</h1><div class="score">${r.score}</div><p>${'★'.repeat(r.stars)}${'☆'.repeat(3-r.stars)}</p><div class="esc-stats"><div><b>${r.baseScore}</b>Basis</div><div><b>+${r.timeBonus}</b>Zeitbonus</div><div><b>${r.solvedPuzzles}</b>Rätsel</div><div><b>${r.roomsOpened}</b>Räume</div><div><b>${r.highscore}</b>Highscore</div><div><b>${r.plays}</b>Runs</div></div><button class="esc-btn primary" id="again">NEUER RUN</button></section>`;document.getElementById('again').onclick=loadCatalog;}
+function error(e){view.innerHTML=`<div class="esc-result"><h1>SYSTEMFEHLER</h1><p>${esc(e.message||e)}</p><button class="esc-btn" onclick="location.reload()">NEU LADEN</button></div>`;}loadCatalog();})();

src/main/resources/static/js/fluxtimer.js

@@ -0,0 +1,129 @@
+/* FluxTimer – lokaler Pausen-Timer ohne Server- oder Drittdienst. */
+(function () {
+  'use strict';
+  if (window.MindfluxTimer) return;
+
+  var KEY = 'fluxtimer';
+  var MIN_INTERVAL = 5;
+  var MAX_INTERVAL = 240;
+  var DEFAULTS = { enabled:false, intervalMinutes:45, reminders:['aufstehen','trinken','augenpause'], customText:'', sound:false, notify:false, nextFireAt:null, lastFiredAt:null, reminderIndex:0 };
+  var LABELS = {
+    aufstehen:'88 mph erreicht – kurz aufstehen, McFly!',
+    trinken:'Großer Scott! Zeit, etwas zu trinken.',
+    essen:'Dein Fluxkompensator braucht einen Snack.',
+    augenpause:'Blick in die Zukunft: Gönn deinen Augen eine Pause.'
+  };
+  var state = load();
+  var ringing = false;
+  var intervalId;
+
+  function number(value, fallback) { var n = Number(value); return Number.isFinite(n) ? n : fallback; }
+  function clamp(value, min, max) { return Math.min(max, Math.max(min, value)); }
+  function normalize(raw) {
+    raw = raw && typeof raw === 'object' ? raw : {};
+    var reminders = Array.isArray(raw.reminders) ? raw.reminders.filter(function (x) { return Object.prototype.hasOwnProperty.call(LABELS, x); }) : DEFAULTS.reminders.slice();
+    return {
+      enabled: raw.enabled === true,
+      intervalMinutes: clamp(Math.round(number(raw.intervalMinutes, 45)), MIN_INTERVAL, MAX_INTERVAL),
+      reminders: reminders,
+      customText: typeof raw.customText === 'string' ? raw.customText.trim().slice(0,120) : '',
+      sound: raw.sound === true,
+      notify: raw.notify === true,
+      nextFireAt: Number.isFinite(Number(raw.nextFireAt)) ? Number(raw.nextFireAt) : null,
+      lastFiredAt: Number.isFinite(Number(raw.lastFiredAt)) ? Number(raw.lastFiredAt) : null,
+      reminderIndex: Math.max(0, Math.round(number(raw.reminderIndex, 0)))
+    };
+  }
+  function load() { try { return normalize(JSON.parse(localStorage.getItem(KEY) || '{}')); } catch (e) { return normalize({}); } }
+  function save() { try { localStorage.setItem(KEY, JSON.stringify(state)); } catch (e) {} syncUi(); }
+  function schedule(from) { state.nextFireAt = (from || Date.now()) + state.intervalMinutes * 60000; ringing = false; save(); }
+  function setEnabled(enabled) { state.enabled = !!enabled; if (state.enabled) schedule(Date.now()); else { state.nextFireAt = null; ringing = false; closeOverlay(); save(); } }
+  function remainingMs(now) { return state.enabled && state.nextFireAt ? Math.max(0, state.nextFireAt - (now || Date.now())) : 0; }
+  function pad(n) { return String(n).padStart(2,'0'); }
+  function formatDuration(ms) { var seconds=Math.max(0,Math.ceil(ms/1000)); return pad(Math.floor(seconds/3600))+':'+pad(Math.floor((seconds%3600)/60))+':'+pad(seconds%60); }
+  function formatClock(ts) { if (!ts) return '--:--:--'; return new Date(ts).toLocaleTimeString('de-DE',{hour:'2-digit',minute:'2-digit',second:'2-digit'}); }
+  function reminderText() {
+    var pool = state.reminders.slice(); if (state.customText) pool.push('custom');
+    if (!pool.length) return 'Zeit für eine kurze Pause.';
+    var key = pool[state.reminderIndex % pool.length];
+    state.reminderIndex = (state.reminderIndex + 1) % pool.length;
+    return key === 'custom' ? state.customText : LABELS[key];
+  }
+  function ensureUi() {
+    if (!document.querySelector('.ft-popover')) {
+      var pop=document.createElement('section'); pop.className='ft-popover'; pop.setAttribute('aria-label','FluxTimer');
+      pop.innerHTML='<div class="ft-popover-head"><b>FLUXTIMER</b><button class="ft-close" type="button" data-ft-close aria-label="Schließen">×</button></div><div class="ft-circuit"><div class="ft-row primary"><span>NÄCHSTE PAUSE</span><strong data-ft-countdown>--:--:--</strong></div><div class="ft-row"><span>JETZT</span><strong data-ft-now>--:--:--</strong></div><div class="ft-row"><span>LETZTE PAUSE</span><strong data-ft-last>--:--:--</strong></div></div><p class="ft-popover-status" data-ft-status></p><div class="ft-popover-actions"><button class="ft-mini-toggle" type="button" data-ft-quick-toggle></button><a class="mf-btn outline" href="/profile/settings">Einstellungen</a></div>';
+      document.body.appendChild(pop);
+    }
+    if (!document.querySelector('.ft-overlay')) {
+      var overlay=document.createElement('div'); overlay.className='ft-overlay'; overlay.setAttribute('role','dialog'); overlay.setAttribute('aria-modal','true'); overlay.setAttribute('aria-labelledby','ft-title');
+      overlay.innerHTML='<div class="ft-modal"><span class="ft-kicker">ZEITSCHALTKREISE AKTIV</span><h2 id="ft-title">Zeit für eine Pause</h2><p data-ft-message></p><div class="ft-modal-actions"><button class="mf-btn outline" type="button" data-ft-snooze>+5 Minuten</button><button class="mf-btn" type="button" data-ft-done>Pause erledigt</button></div></div>';
+      document.body.appendChild(overlay);
+    }
+  }
+  function positionPopover() {
+    var trigger=document.querySelector('[data-fluxtimer-toggle]'), pop=document.querySelector('.ft-popover'); if (!trigger || !pop) return;
+    var r=trigger.getBoundingClientRect(); pop.style.top=(r.bottom+8)+'px'; pop.style.left=Math.max(12,Math.min(window.innerWidth-pop.offsetWidth-12,r.right-pop.offsetWidth))+'px';
+  }
+  function togglePopover() { var pop=document.querySelector('.ft-popover'); if (!pop) return; pop.classList.toggle('open'); var open=pop.classList.contains('open'); var trigger=document.querySelector('[data-fluxtimer-toggle]'); if(trigger) trigger.setAttribute('aria-expanded',String(open)); if(open){positionPopover();syncUi();} }
+  function closePopover() { var pop=document.querySelector('.ft-popover'); if(pop) pop.classList.remove('open'); var trigger=document.querySelector('[data-fluxtimer-toggle]'); if(trigger) trigger.setAttribute('aria-expanded','false'); }
+  function closeOverlay() { var overlay=document.querySelector('.ft-overlay'); if(overlay) overlay.classList.remove('open'); }
+  function playSound() { if (!state.sound) return; try { var C=window.AudioContext||window.webkitAudioContext; if(!C)return; var ctx=new C(),o=ctx.createOscillator(),g=ctx.createGain(); o.frequency.value=523.25; g.gain.setValueAtTime(.05,ctx.currentTime); g.gain.exponentialRampToValueAtTime(.001,ctx.currentTime+.35); o.connect(g);g.connect(ctx.destination);o.start();o.stop(ctx.currentTime+.35); } catch(e){} }
+  function notify(text) { if (!state.notify || !('Notification' in window) || Notification.permission!=='granted') return; try { new Notification('Mindflux FluxTimer',{body:text,tag:'mindflux-fluxtimer'}); } catch(e){} }
+  function fire(testOnly) { ensureUi(); if(ringing&&!testOnly)return; ringing=true; var text=reminderText(); state.lastFiredAt=Date.now(); save(); var msg=document.querySelector('[data-ft-message]'); if(msg)msg.textContent=text; document.querySelector('.ft-overlay').classList.add('open'); playSound(); notify(text); }
+  function done() { closeOverlay(); schedule(Date.now()); }
+  function snooze() { closeOverlay(); state.nextFireAt=Date.now()+5*60000; ringing=false; save(); }
+  function tick() { var now=Date.now(); if(state.enabled&&state.nextFireAt&&now>=state.nextFireAt)fire(false); syncUi(now); }
+  function syncUi(now) {
+    now=now||Date.now(); var countdown=state.enabled?formatDuration(remainingMs(now)):'PAUSIERT';
+    document.querySelectorAll('[data-ft-countdown]').forEach(function(el){el.textContent=countdown;});
+    document.querySelectorAll('[data-ft-now]').forEach(function(el){el.textContent=formatClock(now);});
+    document.querySelectorAll('[data-ft-last]').forEach(function(el){el.textContent=formatClock(state.lastFiredAt);});
+    document.querySelectorAll('[data-ft-status]').forEach(function(el){el.textContent=state.enabled?'Aktiv · '+state.intervalMinutes+' Minuten':'Der Timer ist deaktiviert.';});
+    document.querySelectorAll('[data-ft-quick-toggle]').forEach(function(el){el.textContent=state.enabled?'Timer pausieren':'Timer aktivieren';});
+    document.querySelectorAll('[data-fluxtimer-toggle]').forEach(function(el){el.classList.toggle('ft-active',state.enabled);});
+    var fields=document.querySelector('[data-fluxtimer-settings]'); if(fields){
+      var enabled=fields.querySelector('[data-ft-field="enabled"]'); if(enabled&&document.activeElement!==enabled)enabled.checked=state.enabled;
+      var interval=fields.querySelector('[data-ft-field="intervalMinutes"]'); if(interval&&document.activeElement!==interval)interval.value=state.intervalMinutes;
+      var custom=fields.querySelector('[data-ft-field="customText"]'); if(custom&&document.activeElement!==custom)custom.value=state.customText;
+      ['sound','notify'].forEach(function(k){var el=fields.querySelector('[data-ft-field="'+k+'"]');if(el&&document.activeElement!==el)el.checked=state[k];});
+      fields.querySelectorAll('[data-ft-reminder]').forEach(function(el){if(document.activeElement!==el)el.checked=state.reminders.indexOf(el.value)>=0;});
+    }
+  }
+  function readSettings(container) {
+    var interval=container.querySelector('[data-ft-field="intervalMinutes"]'), previousInterval=state.intervalMinutes; state.intervalMinutes=clamp(Math.round(number(interval.value,45)),MIN_INTERVAL,MAX_INTERVAL); interval.value=state.intervalMinutes;
+    state.customText=container.querySelector('[data-ft-field="customText"]').value.trim().slice(0,120);
+    state.sound=container.querySelector('[data-ft-field="sound"]').checked;
+    state.notify=container.querySelector('[data-ft-field="notify"]').checked;
+    state.reminders=Array.prototype.map.call(container.querySelectorAll('[data-ft-reminder]:checked'),function(el){return el.value;});
+    if(state.enabled&&previousInterval!==state.intervalMinutes)schedule(Date.now());else save();
+    var status=container.querySelector('[data-ft-save-status]');if(status){status.textContent='Auf diesem Gerät gespeichert.';setTimeout(function(){status.textContent='Wird nur auf diesem Gerät gespeichert.';},1800);}
+  }
+  function init() {
+    if(location.pathname==='/'||location.pathname==='/login'||location.pathname==='/register')return;
+    ensureUi();
+    if(state.enabled&&!state.nextFireAt)schedule(Date.now());
+    document.addEventListener('click',function(e){
+      if(e.target.closest('[data-fluxtimer-toggle]')){togglePopover();return;}
+      if(e.target.closest('[data-ft-close]')){closePopover();return;}
+      if(e.target.closest('[data-ft-quick-toggle]')){setEnabled(!state.enabled);return;}
+      if(e.target.closest('[data-ft-done]')){done();return;}
+      if(e.target.closest('[data-ft-snooze]')){snooze();return;}
+      if(e.target.closest('[data-ft-test]')){fire(true);return;}
+      var pop=e.target.closest('.ft-popover'); if(!pop&&!e.target.closest('[data-fluxtimer-toggle]'))closePopover();
+    });
+    var settings=document.querySelector('[data-fluxtimer-settings]'); if(settings){
+      settings.addEventListener('change',function(e){
+        if(e.target.matches('[data-ft-field="enabled"]')){setEnabled(e.target.checked);return;}
+        if(e.target.matches('[data-ft-field="notify"]')&&e.target.checked&&'Notification' in window&&Notification.permission==='default') Notification.requestPermission().then(function(p){if(p!=='granted'){e.target.checked=false;state.notify=false;save();}});
+        readSettings(settings);
+      });
+      settings.addEventListener('input',function(e){if(e.target.matches('[data-ft-field="customText"],[data-ft-field="intervalMinutes"]'))readSettings(settings);});
+    }
+    window.addEventListener('storage',function(e){if(e.key===KEY){state=load();syncUi();}});
+    window.addEventListener('resize',positionPopover);
+    intervalId=window.setInterval(tick,1000); tick();
+  }
+  window.MindfluxTimer={getState:function(){return JSON.parse(JSON.stringify(state));},setEnabled:setEnabled,remainingMs:remainingMs,formatDuration:formatDuration,test:function(){fire(true);},reset:function(){state=normalize({});save();}};
+  if(document.readyState==='loading')document.addEventListener('DOMContentLoaded',init);else init();
+})();

src/main/resources/static/js/theme.js

@@ -8,6 +8,42 @@
 
   apply(read()); // früh -> kein Aufblitzen
 
+  // Globale, rein clientseitige Komfortfunktionen. FluxTimer bleibt auf öffentlichen
+  // Seiten inaktiv, läuft bei aktivierter Einstellung aber über Seitennavigationen weiter.
+  if (!document.querySelector('link[data-fluxtimer]')) {
+    var timerCss = document.createElement('link');
+    timerCss.rel = 'stylesheet';
+    timerCss.href = '/css/fluxtimer.css?v=3';
+    timerCss.setAttribute('data-fluxtimer', '');
+    document.head.appendChild(timerCss);
+  }
+  if (!document.querySelector('script[data-fluxtimer]')) {
+    var timerScript = document.createElement('script');
+    timerScript.src = '/js/fluxtimer.js?v=1';
+    timerScript.defer = true;
+    timerScript.setAttribute('data-fluxtimer', '');
+    document.head.appendChild(timerScript);
+  }
+  if (!document.querySelector('link[data-accessibility]')) {
+    var accessibilityCss = document.createElement('link');
+    accessibilityCss.rel = 'stylesheet';
+    accessibilityCss.href = '/css/accessibility.css?v=3';
+    accessibilityCss.setAttribute('data-accessibility', '');
+    document.head.appendChild(accessibilityCss);
+    var accessibilityPlacementCss = document.createElement('link');
+    accessibilityPlacementCss.rel = 'stylesheet';
+    accessibilityPlacementCss.href = '/css/accessibility-placement.css?v=2';
+    accessibilityPlacementCss.setAttribute('data-accessibility', '');
+    document.head.appendChild(accessibilityPlacementCss);
+  }
+  if (!document.querySelector('script[data-accessibility]')) {
+    var accessibilityScript = document.createElement('script');
+    accessibilityScript.src = '/js/accessibility.js?v=4';
+    accessibilityScript.defer = true;
+    accessibilityScript.setAttribute('data-accessibility', '');
+    document.head.appendChild(accessibilityScript);
+  }
+
   var SUN  = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="4"/><path d="M12 2v2M12 20v2M4.9 4.9l1.4 1.4M17.7 17.7l1.4 1.4M2 12h2M20 12h2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4"/></svg>';
   var MOON = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 12.8A9 9 0 1 1 11.2 3a7 7 0 0 0 9.8 9.8z"/></svg>';
 
@@ -21,7 +57,18 @@
     try { localStorage.setItem(KEY, next); } catch (e) {}
     paint();
   }
-  window.MindfluxTheme = { toggle: toggle, apply: apply };
+  function set(mode) {
+    var next = mode === 'light' ? 'light' : 'dark';
+    apply(next);
+    try { localStorage.setItem(KEY, next); } catch (e) {}
+    paint();
+  }
+  window.MindfluxTheme = {
+    toggle: toggle,
+    apply: apply,
+    set: set,
+    current: function () { return document.documentElement.getAttribute('data-theme'); }
+  };
 
   // Mobile-Nav: Off-Canvas-Drawer für Seiten mit App-Sidebar (.mf-shell)
   function initMobileNav() {

src/main/resources/templates/achievements.html

@@ -30,12 +30,14 @@
 <div class="mf-container">
 
     <div class="mf-page-head">
-        <a href="/profile" class="mf-back">⟵ Zurück zum Profil</a>
+        <a th:href="@{/dashboard}" class="mf-back">⟵ Zurück zum Dashboard</a>
     </div>
-    <span class="mf-eyebrow">Deine Trophäen</span>
-    <h1 style="color:var(--heading); font-size:1.9rem; font-weight:800; margin:.3rem 0 .25rem;">🏆 Deine Trophäen</h1>
+    <span class="mf-eyebrow">Deine Erfolge</span>
+    <h1 style="color:var(--heading); font-size:1.9rem; font-weight:800; margin:.3rem 0 .25rem;">🏆 Deine Erfolge</h1>
     <p style="color:var(--muted); margin-bottom:1.4rem;">Sammle sie alle und werde zur Legende!</p>
 
+    <nav th:replace="~{fragments/layout :: profileTabs('erfolge')}"></nav>
+
     <div class="mf-panel">
         <div class="mf-ach-grid">
             <div class="achievement-card"

src/main/resources/templates/admin/codeescape-room.html

@@ -0,0 +1 @@
+<!doctype html><html lang="de" data-theme="dark" xmlns:th="http://www.thymeleaf.org"><head><meta charset="utf-8"><title>CodeEscape Raum</title><link rel="stylesheet" href="/css/theme.css"><script src="/js/theme.js"></script></head><body><main class="mf-container"><a class="mf-back" th:href="@{/admin/codeescape/{id}(id=${room.scenario.id})}">← Szenario</a><h1 th:text="${room.title}" style="margin:1rem 0;color:var(--heading)"></h1><form class="mf-panel" method="post" th:action="@{/admin/codeescape/rooms/{id}/puzzles(id=${room.id})}"><h2>Rätsel hinzufügen</h2><div class="mf-field"><label class="mf-label">Typ</label><select class="mf-select" name="type"><option>code</option><option>choice</option><option>order</option><option>match</option></select></div><div class="mf-field"><label class="mf-label">Titel</label><input class="mf-input" name="prompt" required></div><div class="mf-field"><label class="mf-label">Punkte</label><input class="mf-input" type="number" name="points" value="100"></div><div class="mf-field"><label class="mf-label">Fragment</label><input class="mf-input" name="codeFragment" required></div><div class="mf-field"><label class="mf-label">Payload JSON</label><textarea class="mf-input" rows="10" name="payload" required>{"instruction":"...","solutions":["..."]}</textarea></div><button class="mf-btn">Rätsel anlegen</button></form><table class="mf-table" style="margin-top:1rem"><tr><th>Typ</th><th>Titel</th><th>Fragment</th><th></th></tr><tr th:each="p:${room.puzzles}"><td th:text="${p.type}"></td><td th:text="${p.prompt}"></td><td th:text="${p.codeFragment}"></td><td><form method="post" th:action="@{/admin/codeescape/puzzles/{id}/delete(id=${p.id})}"><input type="hidden" name="roomId" th:value="${room.id}"><button class="mf-btn danger">Löschen</button></form></td></tr></table></main></body></html>

src/main/resources/templates/admin/codeescape-scenario.html

@@ -0,0 +1 @@
+<!doctype html><html lang="de" data-theme="dark" xmlns:th="http://www.thymeleaf.org"><head><meta charset="utf-8"><title>CodeEscape Szenario</title><link rel="stylesheet" href="/css/theme.css"><script src="/js/theme.js"></script></head><body><main class="mf-container"><a class="mf-back" href="/admin/codeescape">← Szenarien</a><h1 th:text="${scenario.title}" style="margin:1rem 0;color:var(--heading)"></h1><form class="mf-panel" method="post" th:action="@{/admin/codeescape/{id}/rooms(id=${scenario.id})}"><h2>Raum hinzufügen</h2><div class="mf-field"><label class="mf-label">Titel</label><input class="mf-input" name="title" required></div><div class="mf-field"><label class="mf-label">Intro</label><textarea class="mf-input" name="intro"></textarea></div><div class="mf-field"><label class="mf-label">Tür-Hinweis</label><input class="mf-input" name="doorPrompt"></div><div class="mf-field"><label class="mf-label">Türcode</label><input class="mf-input" name="doorCode" required></div><div class="mf-field"><label class="mf-label">Erfolgstext</label><input class="mf-input" name="successText"></div><button class="mf-btn">Raum anlegen</button></form><div class="mf-grid" style="margin-top:1rem"><article class="mf-panel" th:each="r:${scenario.rooms}"><h2><a th:href="@{/admin/codeescape/rooms/{id}(id=${r.id})}" th:text="${r.title}"></a></h2><p th:text="${r.intro}"></p><form method="post" th:action="@{/admin/codeescape/rooms/{id}/delete(id=${r.id})}"><button class="mf-btn danger">Raum löschen</button></form></article></div></main></body></html>

src/main/resources/templates/admin/codeescape.html

@@ -0,0 +1 @@
+<!doctype html><html lang="de" data-theme="dark" xmlns:th="http://www.thymeleaf.org"><head><meta charset="utf-8"><title>Admin · CodeEscape</title><link rel="stylesheet" href="/css/theme.css"><script src="/js/theme.js"></script></head><body><main class="mf-container"><a class="mf-back" href="/admin">← Admin</a><h1 style="margin:1rem 0;color:var(--heading)">CodeEscape · Szenarien</h1><form class="mf-panel" method="post" action="/admin/codeescape/add"><div class="mf-field"><label class="mf-label">Titel</label><input class="mf-input" name="title" required></div><div class="mf-field"><label class="mf-label">Schwierigkeit</label><select class="mf-select" name="difficulty"><option>leicht</option><option>mittel</option><option>schwer</option></select></div><div class="mf-field"><label class="mf-label">Prüfungsbereich</label><select class="mf-select" name="examScope"><option>AP1</option><option>AP2_FIAE</option><option>AP2_FISI</option><option>CROSS</option></select></div><div class="mf-field"><label class="mf-label">Beschreibung</label><textarea class="mf-input" name="description"></textarea></div><div class="mf-field"><label class="mf-label">Zeitlimit Sekunden</label><input class="mf-input" type="number" name="timeLimitSeconds" value="900"></div><button class="mf-btn">Szenario anlegen</button></form><table class="mf-table" style="margin-top:1rem"><tr><th>Titel</th><th>Scope</th><th>Status</th><th>Aktion</th></tr><tr th:each="s:${scenarios}"><td><a th:href="@{/admin/codeescape/{id}(id=${s.id})}" th:text="${s.title}"></a></td><td th:text="${s.examScope}"></td><td th:text="${s.active?'aktiv':'inaktiv'}"></td><td><form style="display:inline" method="post" th:action="@{/admin/codeescape/{id}/toggle(id=${s.id})}"><button class="mf-btn outline">Toggle</button></form> <form style="display:inline" method="post" th:action="@{/admin/codeescape/{id}/delete(id=${s.id})}"><button class="mf-btn danger">Löschen</button></form></td></tr></table></main></body></html>

src/main/resources/templates/admin/dashboard.html

@@ -48,6 +48,7 @@
         <a th:href="@{/admin/techtacular}" class="admin-card">🎯 TechTacular-Fragen verwalten</a>
         <a th:href="@{/admin/syntaxsaga}" class="admin-card">📜 Syntax-Saga-Missionen verwalten</a>
         <a th:href="@{/admin/devlab}" class="admin-card">⚗️ Dev-Lab-Aufgaben verwalten</a>
+        <a th:href="@{/admin/codeescape}" class="admin-card">🚪 SystemEscape-Szenarien verwalten</a>
       </div>
       <p style="margin-top:1.1rem; color:var(--muted);">
         Hier entsteht noch Großes... ✨ Bleib dran!

src/main/resources/templates/admin/users/form.html

@@ -34,8 +34,9 @@
             </div>
 
             <div class="mf-field">
-                <label class="mf-label">Passwort</label>
-                <input class="mf-input" type="password" name="password" th:required="${user.id == null}" autocomplete="new-password"/>
+                <label class="mf-label" th:text="${user.id == null} ? 'Passwort' : 'Neues Passwort (leer lassen = unverändert)'">Passwort</label>
+                <input class="mf-input" type="password" name="password" th:required="${user.id == null}" autocomplete="new-password"
+                       th:placeholder="${user.id == null} ? 'Passwort' : 'leer lassen = unverändert'"/>
             </div>
 
             <div class="mf-field">

src/main/resources/templates/admin/users/list.html

@@ -43,9 +43,17 @@
                         <td th:text="${user.id}">1</td>
                         <td th:text="${user.username}">Max</td>
                         <td th:text="${user.email}">max@mindflux.de</td>
-                        <td style="display:flex; gap:.5rem; flex-wrap:wrap;">
+                        <td style="display:flex; gap:.5rem; flex-wrap:wrap; align-items:center;">
                             <a th:href="@{'/admin/users/edit/' + ${user.id}}" class="mf-btn outline">Bearbeiten</a>
-                            <form th:action="@{'/admin/users/delete/' + ${user.id}}" method="post" style="display:inline;">
+                            <form th:action="@{'/admin/users/' + ${user.id} + '/reset-password'}" method="post"
+                                  style="display:flex; gap:.35rem; align-items:center;"
+                                  onsubmit="return confirm('Passwort für diesen Nutzer wirklich neu setzen?');">
+                                <input class="mf-input" type="text" name="newPassword" placeholder="Neues Passwort"
+                                       required minlength="4" style="width:150px; padding:.45rem .6rem;">
+                                <button type="submit" class="mf-btn">PW zurücksetzen</button>
+                            </form>
+                            <form th:action="@{'/admin/users/delete/' + ${user.id}}" method="post" style="display:inline;"
+                                  onsubmit="return confirm('Benutzer wirklich löschen?');">
                                 <button type="submit" class="mf-btn danger">Löschen</button>
                             </form>
                         </td>

src/main/resources/templates/codeescape.html

@@ -0,0 +1 @@
+<!doctype html><html lang="de" data-theme="dark" xmlns:th="http://www.thymeleaf.org"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>SystemEscape · Mindflux</title><link rel="stylesheet" href="/css/theme.css"><link rel="stylesheet" href="/css/codeescape.css?v=2"><link rel="stylesheet" href="/css/codeescape-guide.css?v=3"><link rel="stylesheet" href="/css/codeescape-global.css?v=1"><script src="/js/theme.js"></script></head><body><main class="esc-app"><header class="esc-top"><a href="/dashboard" class="esc-back">← Dashboard</a><div class="esc-brand"><b>SYSTEMESCAPE</b><span>FACILITY ACCESS PROTOCOL</span></div><div class="esc-global-tools"><span class="mf-a11y-host"></span><div class="esc-timer" id="escTimer">--:--</div></div></header><section id="escView" class="esc-view"><div class="esc-loading">FACILITY WIRD INITIALISIERT …</div></section></main><script src="/js/codeescape.js?v=2"></script></body></html>

src/main/resources/templates/dashboard.html

@@ -35,83 +35,30 @@
 <body>
 <div class="mf-shell">
 
-  <!-- ===== Sidebar ===== -->
-  <aside class="mf-sidebar">
-    <a th:href="@{/dashboard}" class="mf-logo">
-      <span class="mark"></span>
-      <span class="txt"><b>MINDFLUX</b><span>KNOWLEDGE. CODE. WIN.</span></span>
-    </a>
-
-    <nav class="mf-nav">
-      <a th:href="@{/dashboard}" class="active">
-        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="3" width="7" height="7" rx="1.5"/><rect x="14" y="3" width="7" height="7" rx="1.5"/><rect x="3" y="14" width="7" height="7" rx="1.5"/><rect x="14" y="14" width="7" height="7" rx="1.5"/></svg>
-        Dashboard
-      </a>
-      <a th:href="@{/admin}" sec:authorize="hasRole('ADMIN')">
-        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 2l8 4v6c0 5-3.5 8-8 10-4.5-2-8-5-8-10V6z"/><path d="M9 12l2 2 4-4"/></svg>
-        Admin-Dashboard
-      </a>
-      <a th:href="@{/profile/knowledge}">
-        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="9"/><path d="M3 12h18M12 3c3 3 3 15 0 18M12 3c-3 3-3 15 0 18"/></svg>
-        Knowledge Core
-      </a>
-      <a th:href="@{/progress}">
-        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M4 20V10M10 20V4M16 20v-8M22 20H2"/></svg>
-        Statistiken
-      </a>
-      <a th:href="@{/profile/achievements}">
-        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="9" r="6"/><path d="M9 14l-2 8 5-3 5 3-2-8"/></svg>
-        Achievements
-      </a>
-      <a th:href="@{/profile/settings}">
-        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="3.2"/><path d="M19 12a7 7 0 0 0-.1-1l2-1.6-2-3.4-2.4 1a7 7 0 0 0-1.7-1L14.5 2h-4l-.3 2.5a7 7 0 0 0-1.7 1l-2.4-1-2 3.4 2 1.6a7 7 0 0 0 0 2l-2 1.6 2 3.4 2.4-1a7 7 0 0 0 1.7 1l.3 2.5h4l.3-2.5a7 7 0 0 0 1.7-1l2.4 1 2-3.4-2-1.6c.1-.3.1-.7.1-1z"/></svg>
-        Einstellungen
-      </a>
-    </nav>
-
-    <a th:href="@{/profile}" class="mf-profile" style="text-decoration:none">
-      <div class="row">
-        <span class="mf-avatar" th:text="${#authentication.name != null ? #authentication.name.substring(0,1).toUpperCase() : 'U'}">A</span>
-        <div>
-          <b sec:authentication="name">Alice Darkest</b>
-          <span class="role" sec:authorize="hasRole('ADMIN')">Administrator</span>
-          <span class="role" sec:authorize="!hasRole('ADMIN')">Mitglied</span>
-        </div>
-        <svg style="margin-left:auto;color:var(--muted);width:18px;height:18px" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M6 9l6 6 6-6"/></svg>
-      </div>
-    </a>
-
-    <div class="mf-meta">
-      <div class="lvl">LEVEL <b>12</b></div>
-      <div class="xp">3250 / 5000 XP</div>
-      <div class="mf-bar"><i style="width:65%"></i></div>
-    </div>
-    <div class="mf-streak">
-      <span class="fire">🔥</span><span><b>STREAK</b><small>7 Tage in Folge</small></span>
-    </div>
-
-    <div class="mf-brain">
-      <svg viewBox="0 0 120 110" fill="none" stroke="var(--accent)" stroke-width="1.4">
-        <path d="M60 12c-14-8-34-2-36 14-10 4-12 18-4 26-4 10 2 22 14 24 4 8 18 10 26 4 8 6 22 4 26-4 12-2 18-14 14-24 8-8 6-22-4-26-2-16-22-22-36-14z"/>
-        <path d="M60 16v82M40 30c8 4 8 14 0 18M80 30c-8 4-8 14 0 18M34 60c10 0 14 8 14 16M86 60c-10 0-14 8-14 16M48 44h24M44 76h32"/>
-      </svg>
-    </div>
-  </aside>
+  <!-- ===== Sidebar (gemeinsames Fragment) ===== -->
+  <aside th:replace="~{fragments/layout :: sidebar('dashboard')}"></aside>
 
   <!-- ===== Topbar ===== -->
   <header class="mf-topbar">
     <div class="mf-hello">
-      <h1>Willkommen zurück, <span class="nm" sec:authentication="name">Alice</span>! 👋</h1>
+      <h1>Willkommen zurück, <span class="nm" sec:authentication="name">Alice</span>!</h1>
       <p>Wähle ein Spielmodus, um dein Wissen auf die Probe zu stellen.</p>
     </div>
-    <div class="mf-pulse">
-      <svg viewBox="0 0 200 50" fill="none" stroke="var(--accent)" stroke-width="2"><path d="M2 26h40l8-18 10 34 9-26 7 14h26l6-12 9 22 7-24h59"/></svg>
-    </div>
     <div class="mf-tools">
-      <button class="mf-iconbtn" aria-label="Benachrichtigungen"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M18 8a6 6 0 0 0-12 0c0 7-3 9-3 9h18s-3-2-3-9"/><path d="M13.7 21a2 2 0 0 1-3.4 0"/></svg></button>
+      <button class="mf-iconbtn ft-trigger" type="button" data-fluxtimer-toggle aria-label="FluxTimer öffnen" aria-expanded="false">
+        <svg class="ft-trigger-icon" viewBox="0 0 24 24" aria-hidden="true">
+          <circle cx="10.5" cy="12" r="7.5"/>
+          <path d="M10.5 7.5V12l3 2M10.5 2v2M3 12H1.5M4.3 5.8 2.8 4.3"/>
+          <path class="ft-trigger-bolt" d="M17 8.5h4l-2.5 4H22l-6.2 8 1.7-5H14z"/>
+        </svg>
+        <span class="ft-trigger-dot" aria-hidden="true"></span>
+      </button>
+      <button class="mf-iconbtn" type="button" aria-label="Benachrichtigungen"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M18 8a6 6 0 0 0-12 0c0 7-3 9-3 9h18s-3-2-3-9"/><path d="M13.7 21a2 2 0 0 1-3.4 0"/></svg></button>
       <div class="mf-search"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="7"/><path d="M21 21l-4-4"/></svg><input placeholder="Suche..."></div>
       <button class="mf-theme"></button>
-      <a class="mf-iconbtn" href="/logout" aria-label="Logout" style="color:var(--danger)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9"/></svg></a>
+      <form th:action="@{/logout}" method="post" style="display:inline">
+        <button type="submit" class="mf-iconbtn" aria-label="Abmelden" title="Abmelden" style="color:var(--danger)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true"><path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9"/></svg></button>
+      </form>
     </div>
   </header>
 
@@ -186,16 +133,16 @@
   const GAMES = [
     ['MindMatch','brain','Trainiere dein Gedächtnis mit IT-Begriffen in einem klassischen Memory-Spiel.','/mindmatch'],
     ['TechTacular','code','Das IT-Quizduell im Jeopardy-Stil – teste dein Wissen in verschiedenen Kategorien.','/techtacular'],
-    ['Dev Lab','lab','Das Entwicklerlabor bündelt Java, SQL, CSS, PHP, HTML, Git, REST und Regex.','/devlab'],
-    ['Syntax Saga','terminal','Interaktive IT-Geschichten mit Lückentexten – wie ein Textadventure zum Mitdenken.','/syntaxsaga'],
-    ['Code Escape Room','lock','Entkomme mit IT-Rätseln aus digitalen Räumen – sei schnell und clever.','/comingsoon'],
-    ['Service Clash','sword','Der chaotische Admin-Alltag als Spiel – meistere Anfragen & halte Systeme am Laufen!','/comingsoon'],
-    ['Bug Hunter','bug','Finde Fehler im Code, denke wie ein Debugger und löse knifflige Bugs.','/comingsoon'],
-    ['Netzwerker – Das Router-Rätselspiel','network','Verbinde Netzwerke, konfiguriere IPs und löse Routing-Herausforderungen.','/comingsoon'],
+    ['DevLab','lab','Das Entwicklerlabor bündelt Java, SQL, CSS, PHP, HTML, Git, REST und Regex.','/devlab'],
+    ['SyntaxSaga','terminal','Interaktive IT-Geschichten mit Lückentexten – wie ein Textadventure zum Mitdenken.','/syntaxsaga'],
+    ['SystemEscape','lock','Löse IT-Rätsel, sammle Zugriffsfragmente und entkomme dem System.','/codeescape'],
+    ['ServiceClash','sword','Der chaotische Admin-Alltag als Spiel – meistere Anfragen & halte Systeme am Laufen!','/comingsoon'],
+    ['BugHunter','bug','Finde Fehler im Code, denke wie ein Debugger und löse knifflige Bugs.','/comingsoon'],
+    ['NetWorker','network','Verbinde Netzwerke, konfiguriere IPs und löse Routing-Herausforderungen.','/comingsoon'],
     ['FinalFlux','trophy','Dein Power-Modul für die Prüfung – gezielt lernen, strukturiert trainieren, sicher bestehen.','/finalflux']
   ];
   document.getElementById('grid').innerHTML = GAMES.map(([t,ic,d,href])=>`
-    <a class="mf-card" href="${href}">
+    <a class="mf-card ${t === 'SystemEscape' ? 'mf-card-codeescape' : ''}" href="${href}">
       <span class="ico"><svg viewBox="0 0 64 64" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round">${GI[ic]}</svg></span>
       <h3>${t}</h3><p>${d}</p>
       <span class="mf-play">SPIEL STARTEN <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><path d="M5 12h14M13 6l6 6-6 6"/></svg></span>

src/main/resources/templates/devlab-game.html

@@ -6,7 +6,7 @@
   <title>Dev Lab Spiel – Mindflux</title>
   <link rel="stylesheet" href="/css/theme.css">
   <script src="/js/theme.js"></script>
-  <link rel="stylesheet" href="/css/devlabgame.css?v=3">
+  <link rel="stylesheet" href="/css/devlabgame.css?v=4">
 </head>
 <body class="dlg-body" th:attr="data-game=${gameSlug}">
   <div class="dlg-shell">
@@ -18,7 +18,9 @@
       </div>
       <div class="dlg-header-tools">
         <button type="button" class="mf-theme"></button>
-        <a href="/logout" class="dlg-logout">Logout</a>
+        <form th:action="@{/logout}" method="post" style="display:inline">
+          <button type="submit" class="mf-iconbtn" aria-label="Abmelden" title="Abmelden" style="color:var(--danger)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true"><path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9"/></svg></button>
+        </form>
       </div>
     </header>
 

src/main/resources/templates/devlab.html

@@ -41,12 +41,14 @@
     <header class="mf-topbar dl-topbar">
       <div class="mf-hello">
         <p class="mf-eyebrow">Entwicklerlabor</p>
-        <h1>Dev Lab</h1>
+        <h1>DevLab</h1>
         <p>Ein zentraler Hub für die Spiele aus Syntax, Debugging und visueller Praxis.</p>
       </div>
       <div class="mf-tools">
         <button type="button" class="mf-theme"></button>
-        <a class="mf-iconbtn" href="/logout" aria-label="Logout" style="color:var(--danger)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9"/></svg></a>
+        <form th:action="@{/logout}" method="post" style="display:inline">
+          <button type="submit" class="mf-iconbtn" aria-label="Abmelden" title="Abmelden" style="color:var(--danger)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true"><path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9"/></svg></button>
+        </form>
       </div>
     </header>
 

src/main/resources/templates/error.html

@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html lang="de" data-theme="dark" xmlns:th="http://www.thymeleaf.org">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Mindflux – Fehler</title>
+  <link rel="stylesheet" href="/css/theme.css">
+  <script src="/js/theme.js"></script>
+</head>
+<body>
+
+<div class="mf-theme-float"><button class="mf-theme"></button></div>
+
+<div class="mf-container" style="max-width:640px; margin:10vh auto 0;">
+  <div class="mf-panel" style="text-align:center; padding:2.5rem 2rem;">
+    <div style="font-size:2.6rem; margin-bottom:.6rem;">⚡</div>
+    <h1 style="color:var(--heading); font-size:1.6rem; font-weight:800; margin-bottom:.4rem;">
+      Ups – da ist etwas schiefgelaufen
+    </h1>
+    <p style="color:var(--muted); margin-bottom:1rem;">
+      <span th:if="${status != null}" th:text="'Fehlercode ' + ${status}">Fehlercode</span>
+      <span th:unless="${status != null}">Unerwarteter Fehler</span>
+    </p>
+    <p th:if="${friendlyMessage != null}" th:text="${friendlyMessage}"
+       style="color:var(--text); margin-bottom:1.4rem;"></p>
+    <a th:href="@{/dashboard}" class="mf-btn">Zum Dashboard</a>
+  </div>
+</div>
+
+</body>
+</html>

src/main/resources/templates/finalflux.html

@@ -16,9 +16,9 @@
       <button class="mf-theme"></button>
     </div>
     <h1>FinalFlux</h1>
-    <p>AP1 Informatik nach aktueller IHK-Ausbildungsordnung.</p>
+    <p>AP1 &amp; AP2 nach aktueller IHK-Ausbildungsordnung – die gesamte Fachinformatiker-Ausbildung.</p>
 
-    <nav class="finalflux-nav" aria-label="FinalFlux AP1 Navigation">
+    <nav class="finalflux-nav" aria-label="FinalFlux Navigation">
       <section>
         <h2>Grundlagen</h2>
         <a href="/finalflux/ap1/zahlensysteme.html">Zahlensysteme & Speicher</a>
@@ -58,6 +58,16 @@
         <a href="/finalflux/wirtschaft/harvard_konzept.html">Harvard-Konzept</a>
         <a href="/finalflux/wirtschaft/win_win_strategie.html">Win-Win-Strategie</a>
       </section>
+
+      <section>
+        <h2>AP2 Anwendungsentwicklung</h2>
+        <a href="/finalflux/ap2-fiae/entwurfsmuster.html">Entwurfsmuster</a>
+      </section>
+
+      <section>
+        <h2>AP2 Systemintegration</h2>
+        <a href="/finalflux/ap2-fisi/hochverfuegbarkeit.html">Hochverfügbarkeit</a>
+      </section>
     </nav>
   </aside>
 

src/main/resources/templates/fragments/layout.html

@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<!-- Gemeinsame Layout-Fragmente: App-Sidebar, Profil-Tab-Leiste, Footer.
+     Einbinden mit th:replace="~{fragments/layout :: sidebar('dashboard')}" usw. -->
+<html lang="de" xmlns:th="http://www.thymeleaf.org"
+      xmlns:sec="http://www.thymeleaf.org/extras/spring-security">
+<body>
+
+<!-- ===== App-Sidebar (Dashboard-Shell). 'active' markiert den aktuellen Eintrag.
+     Die XP/Streak-Widgets erscheinen nur, wenn die Seite 'overall' (ProgressData) liefert. ===== -->
+<aside class="mf-sidebar" th:fragment="sidebar(active)">
+  <a th:href="@{/dashboard}" class="mf-logo">
+    <span class="mark"></span>
+    <span class="txt"><b>MINDFLUX</b><span>KNOWLEDGE. CODE. WIN.</span></span>
+  </a>
+
+  <nav class="mf-nav">
+    <a th:href="@{/dashboard}" th:classappend="${active == 'dashboard'} ? 'active'">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="3" width="7" height="7" rx="1.5"/><rect x="14" y="3" width="7" height="7" rx="1.5"/><rect x="3" y="14" width="7" height="7" rx="1.5"/><rect x="14" y="14" width="7" height="7" rx="1.5"/></svg>
+      Dashboard
+    </a>
+    <a th:href="@{/admin}" sec:authorize="hasRole('ADMIN')" th:classappend="${active == 'admin'} ? 'active'">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 2l8 4v6c0 5-3.5 8-8 10-4.5-2-8-5-8-10V6z"/><path d="M9 12l2 2 4-4"/></svg>
+      Admin-Dashboard
+    </a>
+    <a th:href="@{/profile}" th:classappend="${active == 'profil'} ? 'active'">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 3.6-6.5 8-6.5S20 17 20 21"/></svg>
+      Profil
+    </a>
+    <a th:href="@{/profile/knowledge}" th:classappend="${active == 'knowledge'} ? 'active'">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="9"/><path d="M3 12h18M12 3c3 3 3 15 0 18M12 3c-3 3-3 15 0 18"/></svg>
+      Knowledge Core
+    </a>
+    <a th:href="@{/progress}" th:classappend="${active == 'statistiken'} ? 'active'">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M4 20V10M10 20V4M16 20v-8M22 20H2"/></svg>
+      Statistiken
+    </a>
+    <a th:href="@{/profile/achievements}" th:classappend="${active == 'erfolge'} ? 'active'">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="9" r="6"/><path d="M9 14l-2 8 5-3 5 3-2-8"/></svg>
+      Erfolge
+    </a>
+    <a th:href="@{/profile/settings}" th:classappend="${active == 'einstellungen'} ? 'active'">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="3.2"/><path d="M19 12a7 7 0 0 0-.1-1l2-1.6-2-3.4-2.4 1a7 7 0 0 0-1.7-1L14.5 2h-4l-.3 2.5a7 7 0 0 0-1.7 1l-2.4-1-2 3.4 2 1.6a7 7 0 0 0 0 2l-2 1.6 2 3.4 2.4-1a7 7 0 0 0 1.7 1l.3 2.5h4l.3-2.5a7 7 0 0 0 1.7-1l2.4 1 2-3.4-2-1.6c.1-.3.1-.7.1-1z"/></svg>
+      Einstellungen
+    </a>
+  </nav>
+
+  <!-- Profil-Shortcut (ohne Dropdown-Pfeil – es gibt kein Dropdown) -->
+  <a th:href="@{/profile}" class="mf-profile" style="text-decoration:none">
+    <div class="row">
+      <span class="mf-avatar" th:text="${#authentication.name != null ? #authentication.name.substring(0,1).toUpperCase() : 'U'}">A</span>
+      <div>
+        <b sec:authentication="name">Benutzer</b>
+        <span class="role" sec:authorize="hasRole('ADMIN')">Administrator</span>
+        <span class="role" sec:authorize="!hasRole('ADMIN')">Mitglied</span>
+      </div>
+    </div>
+  </a>
+
+  <div class="mf-meta" th:if="${overall != null}">
+    <div class="lvl">LEVEL <b th:text="${overall.userLevel}">1</b></div>
+    <div class="xp" th:text="${overall.currentXp} + ' / ' + ${overall.xpForNextLevel} + ' XP'">0 / 1000 XP</div>
+    <div class="mf-bar"><i th:style="'width:' + ${overall.progressPercent} + '%'"></i></div>
+  </div>
+  <div class="mf-streak" th:if="${overall != null}">
+    <span class="fire">🔥</span>
+    <span><b>STREAK</b><small th:text="${overall.streakDays} + (${overall.streakDays == 1} ? ' Tag' : ' Tage') + ' in Folge'">0 Tage in Folge</small></span>
+  </div>
+
+  <div class="mf-brain">
+    <svg viewBox="0 0 120 110" fill="none" stroke="var(--accent)" stroke-width="1.4">
+      <path d="M60 12c-14-8-34-2-36 14-10 4-12 18-4 26-4 10 2 22 14 24 4 8 18 10 26 4 8 6 22 4 26-4 12-2 18-14 14-24 8-8 6-22-4-26-2-16-22-22-36-14z"/>
+      <path d="M60 16v82M40 30c8 4 8 14 0 18M80 30c-8 4-8 14 0 18M34 60c10 0 14 8 14 16M86 60c-10 0-14 8-14 16M48 44h24M44 76h32"/>
+    </svg>
+  </div>
+</aside>
+
+<!-- ===== Profilbereich: Tab-Leiste, auf ALLEN Unterseiten identisch ===== -->
+<nav class="mf-tab-nav" th:fragment="profileTabs(active)">
+  <a th:href="@{/profile}" class="mf-tab" th:classappend="${active == 'profil'} ? ' active'">Profil</a>
+  <a th:href="@{/progress}" class="mf-tab" th:classappend="${active == 'statistiken'} ? ' active'">Statistiken</a>
+  <a th:href="@{/profile/achievements}" class="mf-tab" th:classappend="${active == 'erfolge'} ? ' active'">Erfolge</a>
+  <a th:href="@{/soziales}" class="mf-tab" th:classappend="${active == 'soziales'} ? ' active'">Soziales</a>
+  <a th:href="@{/profile/settings}" class="mf-tab" th:classappend="${active == 'einstellungen'} ? ' active'">Einstellungen</a>
+</nav>
+
+<!-- ===== Footer ===== -->
+<footer class="mf-footer" th:fragment="footer">
+  <a href="#">Support</a>
+  <a href="#">Feedback</a>
+  <a href="/nutzungsbedingungen">Nutzungsbedingungen</a>
+  <a href="/richtlinien">Richtlinien</a>
+  <a href="/datenschutz">Datenschutz</a>
+  <a href="/impressum">Impressum</a>
+</footer>
+
+</body>
+</html>

src/main/resources/templates/index.html

@@ -40,7 +40,7 @@
               <label class="mf-label" for="login-password">Passwort</label>
               <input id="login-password" class="mf-input" type="password" name="password" placeholder="Passwort" required>
             </div>
-            <button class="neon-btn" type="submit"><span class="lock">🔒</span> Login</button>
+            <button class="neon-btn" type="submit">Login</button>
           </form>
 
           <p class="mobile-switch">Noch keinen Account? <a data-goto="signup">Jetzt registrieren</a></p>
@@ -58,6 +58,9 @@
           </div>
 
           <div th:if="${param.registerError}" class="mf-alert err">Benutzername bereits vergeben.</div>
+          <div th:if="${param.passwordMismatch}" class="mf-alert err">Die Passwörter stimmen nicht überein. Bitte erneut eingeben.</div>
+          <div th:if="${param.passwordPolicy}" class="mf-alert err">Das Passwort muss mindestens 8 Zeichen lang sein.</div>
+          <div th:if="${param.emailInvalid}" class="mf-alert err">Bitte gib eine gültige E-Mail-Adresse an.</div>
 
           <form th:action="@{/register}" method="post">
             <div class="mf-field">
@@ -70,8 +73,13 @@
             </div>
             <div class="mf-field">
               <label class="mf-label" for="reg-password">Passwort</label>
-              <input id="reg-password" class="mf-input" type="password" name="password" placeholder="Passwort" required>
+              <input id="reg-password" class="mf-input" type="password" name="password" placeholder="Passwort (min. 8 Zeichen)" required minlength="8">
             </div>
+            <div class="mf-field">
+              <label class="mf-label" for="reg-password2">Passwort wiederholen</label>
+              <input id="reg-password2" class="mf-input" type="password" name="confirmPassword" placeholder="Passwort wiederholen" required>
+            </div>
+            <p id="reg-pw-msg" class="mf-alert err" style="display:none">Die Passwörter stimmen nicht überein.</p>
             <button class="neon-btn" type="submit"><span class="lock">🚀</span> Account erstellen</button>
           </form>
 
@@ -128,10 +136,30 @@
       el.addEventListener('click', function (e) { e.preventDefault(); c.classList.remove('active'); });
     });
 
-    // Bei Registrierungsfehler direkt das Signup-Panel öffnen
-    if (new URLSearchParams(window.location.search).has('registerError')) {
+    // Bei Registrierungs-/Passwortfehler direkt das Signup-Panel öffnen
+    var qp = new URLSearchParams(window.location.search);
+    if (qp.has('registerError') || qp.has('passwordMismatch')) {
       c.classList.add('active');
     }
+
+    // Client-seitiger Passwort-Abgleich (sofortiges Feedback; der Server prüft zusätzlich)
+    var pw = document.getElementById('reg-password');
+    var pw2 = document.getElementById('reg-password2');
+    var pwMsg = document.getElementById('reg-pw-msg');
+    var signupForm = pw2 ? pw2.closest('form') : null;
+    function pwCheck() {
+      var mismatch = pw2.value.length > 0 && pw.value !== pw2.value;
+      if (pwMsg) pwMsg.style.display = mismatch ? 'block' : 'none';
+      pw2.setCustomValidity(pw.value !== pw2.value ? 'Passwörter stimmen nicht überein' : '');
+      return !mismatch;
+    }
+    if (pw && pw2) {
+      pw.addEventListener('input', pwCheck);
+      pw2.addEventListener('input', pwCheck);
+      if (signupForm) signupForm.addEventListener('submit', function (e) {
+        if (pw.value !== pw2.value) { e.preventDefault(); pwCheck(); c.classList.add('active'); }
+      });
+    }
   })();
 </script>
 

src/main/resources/templates/legal/datenschutz.html

@@ -34,7 +34,7 @@
   </div>
 
   <h1>Datenschutzerklärung</h1>
-  <p class="stand">Stand: Juni 2026</p>
+  <p class="stand">Stand: Juli 2026</p>
 
   <div class="dev-note">
     Hinweis: Mindflux befindet sich in aktiver Entwicklung und ist derzeit nicht für die öffentliche
@@ -87,6 +87,18 @@
     im Rahmen von Tests zurückgesetzt werden.
   </p>
 
+  <h2>6a. Lokale Einstellungen, Barrierefreiheit und FluxTimer</h2>
+  <p>
+    Theme-Auswahl, Barrierefreiheitsoptionen und FluxTimer-Einstellungen werden ausschließlich im
+    lokalen Browserspeicher (<code>localStorage</code>) des verwendeten Geräts abgelegt. Dazu gehören
+    gewählte Textgröße, Kontrast-, Farb-, Schrift-, Bewegungs- und Cursorhilfen sowie Aktivierungsstatus,
+    Intervall, ausgewählte Erinnerungsarten, optionaler eigener Erinnerungstext sowie der nächste
+    und letzte Auslösezeitpunkt. Diese Angaben werden nicht an den Mindflux-Server übertragen und
+    können durch Löschen der Website-Daten im Browser entfernt werden. Browser-Benachrichtigungen
+    werden nur nach ausdrücklicher Freigabe lokal erzeugt; es gibt keinen Web-Push- oder externen
+    Benachrichtigungsdienst.
+  </p>
+
   <h2>7. Empfänger und Hosting</h2>
   <p>
     Die Daten werden auf einer vom Anbieter betriebenen Server-Infrastruktur verarbeitet und nicht zu

src/main/resources/templates/login.html

@@ -1,67 +0,0 @@
-<!DOCTYPE html>
-<html lang="de" xmlns:th="http://www.thymeleaf.org">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Login – Mindflux</title>
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-            max-width: 400px;
-            margin: 50px auto;
-            padding: 2rem;
-            border: 1px solid #ccc;
-            border-radius: 8px;
-        }
-        h2 {
-            text-align: center;
-        }
-        label {
-            display: block;
-            margin: 1rem 0 0.3rem;
-        }
-        input {
-            width: 100%;
-            padding: 0.5rem;
-        }
-        button {
-            margin-top: 1rem;
-            width: 100%;
-            padding: 0.7rem;
-            background-color: #4CAF50;
-            color: white;
-            border: none;
-            border-radius: 4px;
-            cursor: pointer;
-        }
-        .message {
-            margin-top: 1rem;
-            text-align: center;
-        }
-        .error {
-            color: red;
-        }
-    </style>
-</head>
-<body>
-    <h2>Login</h2>
-
-    <form th:action="@{/login}" method="post">
-        <label for="username">Benutzername</label>
-        <input type="text" id="username" name="username" required th:value="${param.username}"/>
-
-        <label for="password">Passwort</label>
-        <input type="password" id="password" name="password" required/>
-
-        <div class="message error" th:if="${param.error}">
-            Benutzername oder Passwort sind falsch.
-        </div>
-
-        <div class="message" th:if="${param.logout}">
-            Du hast dich erfolgreich abgemeldet.
-        </div>
-
-        <button type="submit">Einloggen</button>
-    </form>
-</body>
-</html>

src/main/resources/templates/mindmatch.html

@@ -18,7 +18,9 @@
       <h1 class="mm-title">MindMatch</h1>
       <div class="mm-header-tools">
         <button type="button" class="mf-theme"></button>
-        <a href="/logout" class="mm-logout">Logout</a>
+        <form th:action="@{/logout}" method="post" style="display:inline">
+          <button type="submit" class="mf-iconbtn" aria-label="Abmelden" title="Abmelden" style="color:var(--danger)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true"><path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9"/></svg></button>
+        </form>
       </div>
     </header>
 

src/main/resources/templates/profile.html

@@ -7,10 +7,6 @@
   <link rel="stylesheet" href="/css/theme.css">
   <script src="/js/theme.js"></script>
   <style>
-    .mf-tab-nav { display:flex; flex-wrap:wrap; gap:.4rem; margin-bottom:1.4rem; }
-    .mf-tab { padding:.55rem .95rem; border-radius:10px; border:1px solid var(--border); color:var(--muted); text-decoration:none; font-size:.85rem; font-weight:700; transition:all .18s ease; }
-    .mf-tab:hover { color:var(--text); background:var(--surface-2); }
-    .mf-tab.active { color:var(--accent-ink); background:linear-gradient(100deg,var(--accent),var(--accent-2)); box-shadow:0 0 18px var(--glow-s); border-color:transparent; }
     .mf-profile-pic { display:flex; justify-content:center; margin-bottom:1.3rem; }
     .mf-profile-pic img { width:140px; height:140px; border-radius:50%; object-fit:cover; border:2px solid var(--border-accent); box-shadow:0 0 22px var(--glow-w); }
     .mf-success { margin-bottom:1.2rem; transition:opacity 1.5s ease; }
@@ -32,13 +28,7 @@
   <h1 style="color:var(--heading); font-size:1.9rem; font-weight:800; margin:.3rem 0 .25rem;">👤 Mein Profil</h1>
   <p style="color:var(--muted); margin-bottom:1.4rem;">Alles rund um dich und deinen Fortschritt</p>
 
-  <nav class="mf-tab-nav">
-    <a th:href="@{/profile}" class="mf-tab active">Profil</a>
-    <a th:href="@{/progress}" class="mf-tab">Fortschritt</a>
-    <a th:href="@{/profile/achievements}" class="mf-tab">Erfolge</a>
-    <a th:href="@{/soziales}" class="mf-tab">Soziales</a>
-    <a th:href="@{/profile/settings}" class="mf-tab">Einstellungen</a>
-  </nav>
+  <nav th:replace="~{fragments/layout :: profileTabs('profil')}"></nav>
 
   <!-- Erfolgsmeldung -->
   <div th:if="${message}" class="mf-panel accent mf-success" id="successMessage">

src/main/resources/templates/progress.html

@@ -33,12 +33,14 @@
 <div class="mf-container">
 
     <div class="mf-page-head">
-        <a href="/profile" class="mf-back">⟵ Zurück zum Profil</a>
+        <a th:href="@{/dashboard}" class="mf-back">⟵ Zurück zum Dashboard</a>
     </div>
-    <span class="mf-eyebrow">Dein Fortschritt</span>
-    <h1 style="color:var(--heading); font-size:2.1rem; font-weight:800; margin:.3rem 0 .25rem;">Dein Fortschritt</h1>
+    <span class="mf-eyebrow">Deine Statistiken</span>
+    <h1 style="color:var(--heading); font-size:2.1rem; font-weight:800; margin:.3rem 0 .25rem;">Deine Statistiken</h1>
     <p style="color:var(--muted); margin-bottom:1.4rem;">Bleib am Ball – jeder Schritt zählt!</p>
 
+    <nav th:replace="~{fragments/layout :: profileTabs('statistiken')}"></nav>
+
     <!-- Gesamtfortschritt -->
     <section class="mf-panel accent" style="margin-bottom:1.2rem;">
         <div class="mf-progress-summary">