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,303 @@ 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
+(SQL, Java/Debugging, Git, HTML, CSS, Regex, PHP, REST). Im Gegensatz zur ersten,
+rein clientseitigen Skizze ist Dev Lab jetzt **server-autoritativ, DB-gestützt und im
+Admin pflegbar** – mit **echter Mechanik-Vielfalt** statt überall demselben Lückentext.
+
+### Hinzugefügt
+- **Spiel: Dev Lab (`/devlab`)** mit Hub (drei Trainingspfade: Syntax · Debugging · Praxis)
+  und **11 Disziplinen** (`query-builder`, `sql-detective`, `debug-hunt`, `git-mission`,
+  `html-architect`, `css-designer`, `css-cascade`, `flexbox-factory`, `regex-master`,
+  `php-request`, `api-explorer`), zusammen **189 Aufgaben** (16–21 je Spiel).
+- **Sechs unterschiedliche Spielmechaniken** – passend zum Thema gemischt:
+  **cloze** (Code-Lücke tippen), **choice** (Multiple-Choice-Chips), **order**
+  (Bausteine klick-basiert zusammensetzen/sortieren), **spot** (den fehlerhaften Token
+  anklicken), **match** (Paare zuordnen) und **regex** (Muster schreiben mit
+  **Live-Treffer-Vorschau** gegen Beispiel-Strings).
+- **Server-autoritativ & Anti-Cheat:** Aus dem JSON-Payload jeder Aufgabe baut der Server
+  eine bereinigte Sicht **ohne Lösung**; geprüft und gewertet wird ausschließlich serverseitig
+  (Text-/Reihenfolge-/Verhaltensvergleich). `correctIndex`/`bugIndex`/Lösungen/Pattern verlassen
+  nie das Backend. Score über die generische `game_scores`-Tabelle (Kennung `devlab`, `deck`=Spiel-Slug).
+- **Fehler-Mechanik** wie bei Syntax Saga: bis zu drei Versuche mit Hinweis, dann „Auflösung",
+  kein Game-Over; Punkte nach Versuch, Sterne 0–3.
+- **Admin-Verwaltung (`/admin/devlab`):** Spiele und Aufgaben (Typ + JSON-Payload) anlegen,
+  bearbeiten, löschen, aktiv/inaktiv schalten. Inhalte aus `devlab/content.json` (idempotenter Seeder).
+
+### Behoben / geändert (ggü. der ersten Dev-Lab-Skizze)
+- **Platzhalter-Leak entfernt:** Die Eingabefelder zeigten vorher die Lösung als Platzhalter –
+  jetzt sind es neutrale Kategorie-Labels („Keyword", „Operator", „Tag" …). Geprüft wird serverseitig.
+- **Echte Mechanik-Abwechslung** statt 11×Lückentext; **deutlich mehr Aufgaben** je Disziplin.
+
+### Technik
+- Neue Entities `DevLabGame`/`DevLabTask` (JSON-`payload`) + Flyway `V8__devlab.sql`;
+  `DevLabService` mit sechs Mechanik-Checkern; JSON-API `/api/devlab/**`
+  (`catalog`/`session`/`check`/`finish`, CSRF-ausgenommen, `devlab` in `KNOWN_GAMES`).
+  Frontend: polymorphe Engine `devlabgame.js`, DB-getriebener Hub `devlab.js`, `devlabgame.css` (Prefix `dlg-`).
+
+## [Unreleased] – 2026-06-30
+
+Neues Spiel **Syntax Saga**: interaktive IT-Geschichten, in denen man den fehlenden
+Code (Schlüsselwörter, Operatoren, ganze Zeilen) in eine kleine Story tippt. Server-autoritativ
+nach dem TechTacular-Muster, Inhalte DB-gestützt und im Admin pflegbar. Die Dashboard-Kachel
+„Syntax Saga" ist damit aktiv (vorher „coming soon").
+
+### Hinzugefügt
+- **Spiel: Syntax Saga (`/syntaxsaga`):** Missions-Saga in drei **wählbaren Schwierigkeitsstufen**
+  (Junior = eine Lücke, Professional = mehrere Lücken, Senior = ganze Zeile rekonstruieren). Jede
+  Mission besteht aus Erzähltext + optionalem Dialog + Codeblock mit `{{n}}`-Lücken. Eine Lücke kann
+  **mehrere gültige Antworten** haben (z. B. `localhost` / `192.168.0.1`) und optional
+  groß-/kleinschreibungs-unabhängig prüfen (z. B. SQL-Keywords). Eingabe per Freitext; **Prüfung und
+  Score ausschließlich serverseitig** – die Lösungen verlassen nie das Backend (Anti-Cheat wie bei
+  TechTacular/MindMatch).
+- **Fehler-Mechanik:** pro Lücke bis zu drei Versuche mit Hinweis, danach **„Auflösung anzeigen"**; die
+  Geschichte läuft immer weiter (**kein Game-Over**). Punkte je nach Versuch (Erstversuch voll, danach
+  weniger), aufgelöste Lücke = 0 Punkte; Sterne­wertung 0–3.
+- **Admin-Verwaltung (`/admin/syntaxsaga`):** Missionen, Lücken und Lösungen anlegen/bearbeiten/löschen,
+  aktiv/inaktiv schalten. Mitgeliefert: **34 Seed-Missionen** (16 Junior · 10 Professional · 8 Senior,
+  zusammen 44 Lücken) aus `syntaxsaga/content.json` (idempotenter Seeder, lädt nur in leere Tabellen).
+  Themen quer durch den Stack: **Java** (Schleifen, OOP/`class`/`this`, Exceptions, Collections,
+  Operatoren), **SQL** (`WHERE`/`ORDER BY`/`JOIN … ON`/`INSERT`/`UPDATE`/`DELETE`), **Bash**
+  (`cd`/`grep`/Pipe), **Git** (`commit`), **HTML** (Link/Formular) und **Python** (`print`); Senior
+  rekonstruiert ganze Zeilen (z. B. `public static void main(String[] args)`,
+  `Scanner sc = new Scanner(System.in)`) mit ein paar tolerierten Schreibvarianten.
+- Spielstände laufen über die bestehende generische `game_scores`-Tabelle (Spiel-Kennung `syntax-saga`),
+  inkl. Highscore/„Neuer Bestwert" und Statistik im Spiel-HUD.
+
+### Technik
+- Neue Entities `SyntaxSagaMission` / `SyntaxSagaGap` / `SyntaxSagaSolution` + Flyway-Migration
+  `V7__syntax_saga.sql`; server-autoritativer `SyntaxSagaService` (Story ohne Lösungen / serverseitige
+  Prüfung / Score-Recompute beim Abschluss); JSON-API `/api/syntaxsaga/**` (CSRF-ausgenommen). Frontend
+  unter `syntaxsaga.html` / `syntaxsaga.js` / `syntaxsaga.css` (Prefix `ss-`, zentrale `theme.css`-Tokens).
+
+## [Unreleased] – 2026-06-29
+
+Inhaltlicher und optischer Feinschliff: echte Rechtstexte, vollständig
+überarbeitete FinalFlux-Inhalte, neue Login-Optik, eine reparierte
+Konto-Löschung sowie ein app-weiter Farb-Relaunch auf das
+„Back to the Future"-Schema.
+
+### Hinzugefügt
+- **Rechtsseiten:** Impressum-Platzhalter (Hinweis „in Entwicklung / nicht für die öffentliche Nutzung") sowie **echte** Nutzungsbedingungen/AGB, Datenschutzerklärung (DSGVO-konform, spiegelt die tatsächlich verarbeiteten Daten) und Community-/Nutzungsrichtlinien. Neuer `LegalController` (`/nutzungsbedingungen`, `/datenschutz`, `/richtlinien`) + `ImpressumController`; alle Footer-Links app-weit verdrahtet.
+- **Kombinierte Login/Registrierung:** Dual-Panel mit überschiebendem Overlay (Sign-in ↔ „Account erstellen") und Neon-Button mit Hover-Expand und rotierendem Conic-Glow; ausgelagert nach `static/css/auth.css`. Responsiver Fallback (gestapelt) auf schmalen Screens.
+- **FinalFlux – Netzwerktopologien:** fünf theme-adaptive Inline-SVG-Diagramme (Stern, Bus, Ring, Mesh, Baum) in den Erklärungen.
+
+### Geändert
+- **FinalFlux-Inhalte komplett überarbeitet (28 Themen, ~742 Fragen):** die generischen Dummy-Falschantworten („nur Dekoration", „zufälliger Begriff" …) durch plausible, themennahe Distraktoren ersetzt, jede Frage mit echter Begründung und variierender Antwortposition. Jede Themenseite hat jetzt **echten Lehrtext** (Definitionen, Funktionsweise, Rechenbeispiele, Merksätze) statt des bisherigen Stubs.
+- **App-weiter Farb-Relaunch auf „Back to the Future"-Palette:** Primär **Feuer-Amber** (`#f0a81a`) + Gelb-Glow, **Flux-Blau** (`#2d9cce`) als Zweitakzent (u. a. Links); warmer Bernstein-Glow statt Matrix-Grün. Dark/Light bleiben (sehr dunkler/sehr heller Grund). Zentral über `theme.css`-Tokens; Legacy-Cyan in `style.css` auf Theme-Variablen umgestellt.
+- **Spiele-Feedback ohne Grün:** richtig = **Flux-Blau + ✓**, falsch = **Rot + ✗** in FinalFlux, MindMatch und TechTacular (löst den fehlenden Kontrast von „grün auf grün"); neue Tokens `--success`, `--danger`, `--secondary`. Das Fehler-Rot ist ein kühleres Crimson (`#ff4d6d` dunkel / `#be123c` hell), damit es sich klar vom orangen Akzent abhebt (v. a. im Light-Mode).
+- Registrierungs-Duplikat leitet auf `/?registerError` (kombinierte Seite öffnet automatisch das Signup-Panel).
+- **Vollständig responsive / mobiltauglich:** Auf schmalen Screens wird die App-Sidebar nicht mehr ausgeblendet (vorher fehlte die Navigation komplett), sondern zu einer Off-Canvas-Schublade mit Hamburger-Button + Backdrop (global via `theme.js` injiziert, Styles in `theme.css`). Topbar stapelt/umbricht (dekorativer Puls + Suche ausgeblendet), Spielkarten-Grid 3→2→1, breite Tabellen horizontal scrollbar. Spiele, FinalFlux und Login/Registrierung waren bereits responsiv.
+
+### Behoben
+- **Konto-Löschung repariert:** „Profil löschen" warf einen 500er (fehlendes `@Transactional` bei einer abgeleiteten Delete-Query) und löschte nichts. Jetzt werden Konto **plus** Spielstände, Achievements und Profilbild-Datei in einer Transaktion entfernt — erfüllt die in der Datenschutzerklärung zugesicherte Löschung (Art. 17 DSGVO).
+- Impressum-„Zurück"-Link loggte eingeloggte Nutzer scheinbar aus; jetzt login-abhängig (eingeloggt → Dashboard, sonst → Startseite). Gleiche Logik auf den Rechtsseiten.
+- Login-Overlay im **Light-Mode** war weiß-auf-weiß/verwaschen; jetzt kräftiges Orange-Panel mit weißem Text (Dark-Mode unverändert).
+- **Mobile-Bedienbarkeit der Spiele:** MindMatch- und TechTacular-Boards ragten auf dem Handy aus dem Bildschirm, ohne dass man scrollen konnte (`height:100vh; overflow:hidden` + iOS-Adressleiste). Auf Touch-Breiten jetzt scrollbar, Karten/Kacheln mit fester Proportion bzw. Mindesthöhe → alle Felder erreichbar.
+- **FinalFlux-Hub auf Mobil:** Überlappung von Kopfbereich und Inhalt + unerreichbares Themen-Menü. Ursache: das generische `main {}` aus der Alt-`style.css` traf das Hub-`<main>`; jetzt in `.finalflux-main` neutralisiert und die Shell stapelt auf Mobil sauber (`display:block`, Sidebar mit voller Höhe).
+
+### Sicherheit
+- Neue Rechtsseiten öffentlich erreichbar (`permitAll` für `/impressum`, `/nutzungsbedingungen`, `/datenschutz`, `/richtlinien`).
+
+### Hinweise
+- Footer-Links **Support** und **Feedback** sind weiterhin Platzhalter (`href="#"`).
+- Die Rechtstexte sind inhaltlich vollständig, aber KI-erstellt — vor einem öffentlichen Launch fachlich/juristisch prüfen (insb. konkrete Anbieteranschrift im Impressum).
+- Vier ungenutzte Alt-CSS-Dateien (`progress/settings/achievements/soziales.css`, keine Referenzen) blieben vorerst liegen.
+
 ## [Unreleased] – 2026-06-25
 
 Großer Ausbau: zwei vollständige Spiele, durchgängig DB-gestützte und

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"]

STYLEGUIDE.md

@@ -0,0 +1,173 @@
+# Mindflux – Style Guide
+
+Verbindliche Design-Referenz für **Mindflux**. **Single Source of Truth ist
+`src/main/resources/static/css/theme.css`** – diese Datei dokumentiert nur, was dort definiert
+ist. Bei Änderungen immer zuerst `theme.css` anpassen und diese Datei nachziehen.
+
+> **Grundregel:** Niemals Hex-/RGBA-Werte hart in Templates oder Spiele-CSS schreiben. **Immer**
+> die Tokens (`var(--accent)`, `var(--surface)` …) verwenden, damit Dark/Light und künftige
+> Palettenwechsel automatisch greifen.
+
+Theme-Umschaltung: über das Attribut `<html data-theme="dark|light">` (gesetzt/persistiert von
+`theme.js`; injiziert auch den mobilen Off-Canvas-Drawer). **Dark ist Default.**
+
+---
+
+## Farbkonzept – „Back to the Future"
+
+- **Primärakzent = Feuer-Amber** (Dark `#f0a81a` / Light `#d65116`) + **Gelb-Glow** (`--accent-2`)
+  für Verläufe und Leuchten.
+- **Zweitakzent = Flux-Blau** (`#2d9cce`) – für **Links** und das Spiel-Feedback **„richtig"**.
+- **Warmer Bernstein-Glow** statt Matrix-Grün; dunkler bzw. sehr heller Grund je Theme.
+- **Kein Grün** im Erfolgs-Feedback: **richtig = Blau ✓**, **falsch = Rot ✗** (Rot ist ein kühles
+  Crimson, damit es sich klar vom orangen Akzent abhebt – v. a. im Light-Mode).
+
+---
+
+## Token-Referenz (aus `theme.css`)
+
+| Token | Dark | Light | Verwendung |
+|---|---|---|---|
+| `--bg` | `#0a0806` | `#fbf6ec` | Seitenhintergrund (unter `--bg-glow`) |
+| `--bg-glow` | radial `rgba(240,168,26,.10)` | radial `rgba(214,81,22,.10)` | weicher Lichtschein oben |
+| `--panel` | `#13100b` | `#ffffff` | Sidebar, Topbar, Footer |
+| `--panel-2` | `#171209` | `#fdf7ea` | Panel-Variante |
+| `--surface` | `#120f0a` | `#ffffff` | Karten / Panels / Eingaben (Grundfläche) |
+| `--surface-2` | `#1b1610` | `#fbf4e6` | erhöhte Fläche, Hover, Felder |
+| `--border` | `#2a2117` | `#ece1cf` | Standard-Rahmen |
+| `--line` | `#221b12` | `#f1e8d8` | feine Linien, Scrollbar, Chart-Achsen |
+| `--border-accent` | `rgba(240,168,26,.45)` | `rgba(214,81,22,.40)` | akzentuierte Rahmen |
+| `--accent` | `#f0a81a` | `#d65116` | **Primärakzent**: Buttons, aktive Nav, Icons, Headline-Akzent |
+| `--accent-2` | `#f7dc11` | `#e4801d` | Sekundär-Akzent für Verläufe (Gelb-Glow) |
+| `--accent-ink` | `#1c1100` | `#ffffff` | Textfarbe **auf** Akzentflächen |
+| `--secondary` | `#2d9cce` | `#1f86b8` | **Flux-Blau**: Links + „richtig" |
+| `--secondary-2` | `#5cc4e8` | `#2d9cce` | helleres Blau (Hover/Variante) |
+| `--text` | `#ece3d2` | `#33271c` | Fließtext |
+| `--muted` | `#8c8170` | `#8a7d6c` | gedämpfter Text, Labels, Captions |
+| `--heading` | `#ffffff` | `#241a12` | Überschriften |
+| `--success` | `#2d9cce` | `#1f86b8` | **„richtig"** (= Flux-Blau, bewusst kein Grün) |
+| `--danger` | `#ff4d6d` | `#be123c` | **„falsch"** / Fehler / Löschen (kühles Crimson) |
+| `--glow-s` | `rgba(240,168,26,.55)` | `rgba(214,81,22,.40)` | **starker** Glow (Text-/Drop-Shadow auf Akzent) |
+| `--glow-w` | `rgba(240,168,26,.16)` | `rgba(214,81,22,.12)` | **weicher** Ambient-Glow |
+| `--g-soft` | `0 0 18px var(--glow-w)` | `0 6px 18px var(--glow-w)` | Standard-Panel-Schatten |
+
+### Semantik kurz
+- **Akzent (Amber/Orange):** alles Primäre/Interaktive. Text auf Akzent immer `--accent-ink`.
+- **`--accent` + `--accent-2`** zusammen ergeben die typischen Verläufe (`linear-gradient(…,var(--accent),var(--accent-2))`).
+- **Blau (`--secondary` / `--success`):** Links und Erfolg.
+- **Rot (`--danger`):** Fehler, Löschen-Buttons, „falsch".
+
+---
+
+## Spiele-Feedback (verbindlich)
+
+In allen Spielen (FinalFlux, MindMatch, TechTacular, Syntax Saga) gilt einheitlich:
+
+- **richtig** → `var(--success)` (Blau) + Häkchen `✓`
+- **falsch** → `var(--danger)` (Rot) + Kreuz `✗`
+- aufgelöst/neutral (Syntax Saga) → `var(--secondary)`
+
+Muster (siehe z. B. `syntaxsaga.css` / `techtacular.css`):
+```css
+.x-feedback.correct { color: var(--success); }
+.x-feedback.correct::before { content: "\2713  "; }
+.x-feedback.wrong   { color: var(--danger); }
+.x-feedback.wrong::before   { content: "\2717  "; }
+```
+
+---
+
+## Typografie
+
+- **UI/Fließtext:** `"Inter","Segoe UI",system-ui,-apple-system,Roboto,sans-serif`
+- **Code/Monospace:** `"JetBrains Mono","Fira Code","Consolas","Courier New",monospace`
+- **Überschriften:** `font-weight:800`, Farbe `--heading`.
+- **Eyebrow/Labels (`.mf-eyebrow`, Panel-`h4`):** `--accent`, `text-transform:uppercase`,
+  `letter-spacing:.08–.12em`, kleine Schrift.
+
+---
+
+## Glow, Schatten & Radien
+
+- **Glow stark** `--glow-s`: `text-shadow`/`drop-shadow` auf leuchtenden Akzentelementen.
+- **Glow weich** `--glow-w`: dezenter Schein um Panels/Buttons.
+- **Panel-Schatten:** `box-shadow: var(--g-soft)`.
+- **Radien (Konvention):** Badges/Buttons ~`7–9px`, Inputs/Icon-Buttons `10px`, Nav `11px`,
+  Panels `13–14px`, Standalone-Karten `16–18px`, Pills/Bars `99px`.
+- **Spielkarten** (`.mf-card`) haben eine **abgeschrägte Ecke** via `clip-path` (`--n:18px`) statt
+  rundem Radius – ein bewusstes „HUD"-Detail.
+
+---
+
+## Layout-Shell & Responsivität
+
+App-Seiten nutzen das Grid `.mf-shell` (definiert in `theme.css`):
+
+```
+┌── Sidebar 264px ──┬─────── Topbar (Spalte 2–3) ───────┐
+│                   ├──── Main 1fr ────┬─ Rightbar 332px ┤
+└───────────────────┴──────────────────┴─────────────────┘
+```
+- `.mf-shell.no-right` → nur `264px | 1fr` (ohne rechte Spalte).
+- **Breakpoints:** `≤1180px` rechte Spalte aus, 2-spaltig · `≤820px` Shell stapelt, Sidebar wird
+  zum **Off-Canvas-Drawer** (Hamburger + Backdrop, via `theme.js`) · `≤560px` Spielkarten-Grid 1-spaltig.
+- Spielseiten (MindMatch/TechTacular/Syntax Saga) haben eigene, schlankere Shells, nutzen aber
+  dieselben Tokens und sind ebenfalls mobil-tauglich.
+
+---
+
+## Komponenten-Cheatsheet (`.mf-*` aus `theme.css`)
+
+| Klasse | Zweck |
+|---|---|
+| `.mf-btn` | Primär-Button (Akzent). Varianten: `.outline`, `.ghost`, `.danger` |
+| `.mf-panel` | Karte/Box; `.accent` = akzentuierter Rahmen + Glow |
+| `.mf-card` / `.mf-grid` | HUD-Spielkarte (abgeschrägte Ecke) im 3er-Grid |
+| `.mf-input`, `.mf-select`, `textarea.mf-input` | Formularfelder (Fokus = Akzentrahmen + Glow) |
+| `.mf-field`, `.mf-label` | Formular-Zeile + Label |
+| `.mf-table` | Tabellen (Kopf in Akzent, mobil horizontal scrollbar) |
+| `.mf-badge` | kleines Status-Label |
+| `.mf-eyebrow` | Kicker/Overline über Headlines |
+| `.mf-nav` / `.mf-sidebar` | linke Navigation (aktiv = Akzent-Verlauf) |
+| `.mf-bar` + `> i` | Fortschrittsbalken |
+| `.mf-center` / `.mf-cardbox` | zentrierte Standalone-Karte (Login/Rechtsseiten) |
+| `.mf-container`, `.mf-page-head`, `.mf-back` | einfache Inhaltsseiten + Zurück-Link |
+| `.mf-footer` | globale Fußzeile |
+| `.mf-theme` / `.mf-theme-float` | Dark/Light-Umschalter (Logik in `theme.js`) |
+
+---
+
+## Pro-Spiel-CSS
+
+Jedes Spiel hat eine eigene CSS-Datei mit eigenem **Klassen-Prefix**, die **ausschließlich
+Theme-Tokens** verwendet (keine eigenen Farbwerte):
+
+| Spiel | Datei | Prefix |
+|---|---|---|
+| MindMatch | `mindmatch.css` | `mm-` |
+| TechTacular | `techtacular.css` | `tt-` |
+| Syntax Saga | `syntaxsaga.css` | `ss-` |
+| FinalFlux | `finalflux.css` | `finalflux-` |
+
+Neues Spiel → neue `<spiel>.css` mit eigenem Prefix anlegen, **nur** `var(--…)`-Tokens nutzen,
+Feedback-Konvention (Blau/Rot) einhalten.
+
+---
+
+## Do / Don't
+
+**Do**
+- Farben/Schatten/Glow ausschließlich über Tokens.
+- Auf Akzentflächen Text in `--accent-ink`.
+- Erfolg = Blau, Fehler = Rot (nie Grün/Orange für „richtig/falsch").
+- Neue Komponenten an den `.mf-*`-Bausteinen orientieren.
+
+**Don't**
+- Keine hart kodierten Hex-/RGBA-Werte in Templates oder Spiele-CSS.
+- Nicht die **Legacy-Dateien** als Stil-Referenz nehmen: `achievements.css`, `progress.css`,
+  `settings.css`, `soziales.css` (ungenutzt) sowie alte Schrift-Deklarationen
+  (`'Segoe UI'`/`'Poppins'`) entsprechen **nicht** dem aktuellen System. Maßgeblich ist `theme.css`.
+
+---
+
+*Stand: 2026-06-30 · Quelle: `src/main/resources/static/css/theme.css` (BTTF-Palette, Dark/Light).*

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

@@ -0,0 +1,132 @@
+package com.example.mindflux.config;
+
+import com.example.mindflux.model.DevLabGame;
+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;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Befüllt das Dev Lab einmalig (wenn leer) aus devlab/content.json. Jede Aufgabe wird mit
+ * ihrem Typ + vollständigem JSON-Payload gespeichert; der Service liest daraus.
+ */
+@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;
+    private final ObjectMapper objectMapper;
+
+    public DevLabSeeder(DevLabGameRepository gameRepository, ObjectMapper objectMapper) {
+        this.gameRepository = gameRepository;
+        this.objectMapper = objectMapper;
+    }
+
+    @Override
+    @Transactional
+    public void run(String... args) {
+        if (gameRepository.count() > 0) {
+            return;
+        }
+        try {
+            JsonNode root = objectMapper.readTree(new ClassPathResource("devlab/content.json").getInputStream());
+            JsonNode games = root.get("games");
+            if (games == null || !games.isArray()) {
+                log.warn("Dev-Lab-Seed: content.json ohne 'games'.");
+                return;
+            }
+
+            Set<String> used = new HashSet<>();
+            int order = 1;
+            int gameCount = 0;
+            int taskCount = 0;
+            int skipped = 0;
+
+            for (JsonNode gNode : games) {
+                String title = gNode.path("title").asText("");
+                JsonNode tasks = gNode.get("tasks");
+                if (title.isBlank() || tasks == null || !tasks.isArray()) {
+                    continue;
+                }
+                String base = gNode.hasNonNull("slug") ? gNode.get("slug").asText() : title;
+                DevLabGame game = new DevLabGame(
+                        uniqueSlug(base, used),
+                        trim(title, 200),
+                        trim(textOrNull(gNode, "language"), 50),
+                        trim(textOrNull(gNode, "path"), 50),
+                        trim(textOrNull(gNode, "description"), 1000),
+                        order, true);
+
+                int sort = 0;
+                for (JsonNode t : tasks) {
+                    String type = t.path("type").asText("");
+                    String prompt = t.path("prompt").asText("");
+                    if (type.isBlank() || prompt.isBlank()) {
+                        continue;
+                    }
+                    String payload = t.toString();
+                    if (payload.length() > MAX_PAYLOAD) {
+                        skipped++;
+                        continue;
+                    }
+                    game.addTask(new DevLabTask(type, trim(prompt, 300), t.path("points").asInt(100), sort++, payload));
+                    taskCount++;
+                }
+
+                if (!game.getTasks().isEmpty()) {
+                    gameRepository.save(game);
+                    order++;
+                    gameCount++;
+                }
+            }
+            log.info("DevLab: {} Spiele / {} Aufgaben geladen{}.", gameCount, taskCount,
+                    skipped > 0 ? " (" + skipped + " zu groß, übersprungen)" : "");
+        } catch (Exception e) {
+            log.warn("Dev-Lab-Seed übersprungen: {}", e.getMessage(), e);
+        }
+    }
+
+    private String uniqueSlug(String base, Set<String> used) {
+        String slug = base.toLowerCase()
+                .replace("ä", "ae").replace("ö", "oe").replace("ü", "ue").replace("ß", "ss")
+                .replaceAll("[^a-z0-9]+", "-")
+                .replaceAll("(^-|-$)", "");
+        if (slug.isBlank()) {
+            slug = "game";
+        }
+        String candidate = slug;
+        int counter = 2;
+        while (used.contains(candidate) || gameRepository.existsBySlug(candidate)) {
+            candidate = slug + "-" + counter++;
+        }
+        used.add(candidate);
+        return candidate;
+    }
+
+    private String textOrNull(JsonNode node, String field) {
+        if (!node.hasNonNull(field)) {
+            return null;
+        }
+        String value = node.get(field).asText("");
+        return value.isBlank() ? null : value;
+    }
+
+    private String trim(String value, int max) {
+        if (value == null) {
+            return null;
+        }
+        return value.length() <= max ? value : value.substring(0, max);
+    }
+}

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 {
@@ -19,37 +20,43 @@ public class SecurityConfig {
     public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
         http
             .authorizeHttpRequests(auth -> auth
-                .requestMatchers("/", "/login", "/register", "/css/**", "/js/**", "/img/**").permitAll()
-                .requestMatchers("/admin/**").hasRole("ADMIN") // NEU: Adminbereich absichern
+                .requestMatchers("/", "/login", "/register", "/impressum", "/nutzungsbedingungen", "/datenschutz", "/richtlinien", "/css/**", "/js/**", "/img/**").permitAll()
+                .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/**")
+                .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

@@ -0,0 +1,156 @@
+package com.example.mindflux.config;
+
+import com.example.mindflux.model.SyntaxSagaGap;
+import com.example.mindflux.model.SyntaxSagaMission;
+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;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Befüllt Syntax Saga einmalig (wenn leer) aus der kuratierten Inhaltsdatei
+ * syntaxsaga/content.json. Format: Missionen mit Story, Codetemplate (Lücken als
+ * {@code {{n}}}) und je Lücke einer Liste gültiger Lösungen.
+ */
+@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;
+    private final ObjectMapper objectMapper;
+
+    public SyntaxSagaSeeder(SyntaxSagaMissionRepository missionRepository, ObjectMapper objectMapper) {
+        this.missionRepository = missionRepository;
+        this.objectMapper = objectMapper;
+    }
+
+    @Override
+    @Transactional
+    public void run(String... args) {
+        if (missionRepository.count() > 0) {
+            return; // schon befüllt
+        }
+        try {
+            JsonNode root = objectMapper.readTree(
+                    new ClassPathResource("syntaxsaga/content.json").getInputStream());
+            JsonNode missions = root.get("missions");
+            if (missions == null || !missions.isArray()) {
+                log.warn("Syntax-Saga-Seed: content.json ohne 'missions'.");
+                return;
+            }
+
+            Set<String> usedSlugs = new HashSet<>();
+            int order = 1;
+            int missionCount = 0;
+            int gapCount = 0;
+
+            for (JsonNode mNode : missions) {
+                String title = mNode.path("title").asText("");
+                String code = mNode.path("code").asText("");
+                JsonNode gaps = mNode.get("gaps");
+                if (title.isBlank() || code.isBlank() || gaps == null || !gaps.isArray()) {
+                    continue;
+                }
+
+                SyntaxSagaMission mission = new SyntaxSagaMission(
+                        uniqueSlug(title, usedSlugs),
+                        trim(title, 200),
+                        normalizeDifficulty(mNode.path("difficulty").asText("junior")),
+                        trim(mNode.path("narrative").asText(""), 2000),
+                        trim(textOrNull(mNode, "dialog"), 1000),
+                        trim(textOrNull(mNode, "language"), 30),
+                        trim(code, 2000),
+                        trim(textOrNull(mNode, "successText"), 2000),
+                        order, true);
+
+                int pos = 1;
+                for (JsonNode gNode : gaps) {
+                    JsonNode solutions = gNode.get("solutions");
+                    if (solutions == null || !solutions.isArray() || solutions.isEmpty()) {
+                        continue;
+                    }
+                    SyntaxSagaGap gap = new SyntaxSagaGap(
+                            gNode.path("position").asInt(pos),
+                            gNode.path("points").asInt(100),
+                            gNode.path("caseSensitive").asBoolean(true),
+                            trim(textOrNull(gNode, "hint"), 500),
+                            trim(textOrNull(gNode, "placeholder"), 120));
+
+                    int sort = 0;
+                    for (JsonNode s : solutions) {
+                        String st = s.asText("");
+                        if (!st.isBlank()) {
+                            gap.addSolution(new SyntaxSagaSolution(trim(st, 500), sort++));
+                        }
+                    }
+                    if (!gap.getSolutions().isEmpty()) {
+                        mission.addGap(gap);
+                        gapCount++;
+                    }
+                    pos++;
+                }
+
+                if (!mission.getGaps().isEmpty()) {
+                    missionRepository.save(mission);
+                    order++;
+                    missionCount++;
+                }
+            }
+            log.info("SyntaxSaga: {} Missionen / {} Lücken geladen.", missionCount, gapCount);
+        } catch (Exception e) {
+            log.warn("Syntax-Saga-Seed übersprungen: {}", e.getMessage(), e);
+        }
+    }
+
+    private String normalizeDifficulty(String difficulty) {
+        if (difficulty == null) {
+            return "junior";
+        }
+        String x = difficulty.trim().toLowerCase();
+        return DIFFICULTIES.contains(x) ? x : "junior";
+    }
+
+    private String textOrNull(JsonNode node, String field) {
+        if (!node.hasNonNull(field)) {
+            return null;
+        }
+        String value = node.get(field).asText("");
+        return value.isBlank() ? null : value;
+    }
+
+    private String uniqueSlug(String title, Set<String> used) {
+        String base = title.toLowerCase()
+                .replace("ä", "ae").replace("ö", "oe").replace("ü", "ue").replace("ß", "ss")
+                .replaceAll("[^a-z0-9]+", "-")
+                .replaceAll("(^-|-$)", "");
+        if (base.isBlank()) {
+            base = "mission";
+        }
+        String slug = base;
+        int counter = 2;
+        while (used.contains(slug) || missionRepository.existsBySlug(slug)) {
+            slug = base + "-" + counter++;
+        }
+        used.add(slug);
+        return slug;
+    }
+
+    private String trim(String value, int max) {
+        if (value == null) {
+            return null;
+        }
+        return value.length() <= max ? value : value.substring(0, max);
+    }
+}

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/AdminDevLabController.java

@@ -0,0 +1,82 @@
+package com.example.mindflux.controller;
+
+import com.example.mindflux.model.DevLabGame;
+import com.example.mindflux.service.DevLabService;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.*;
+
+/** Admin-Verwaltung der Dev-Lab-Spiele und -Aufgaben (ROLE_ADMIN via /admin/**). */
+@Controller
+@RequestMapping("/admin/devlab")
+public class AdminDevLabController {
+
+    private final DevLabService devLabService;
+
+    public AdminDevLabController(DevLabService devLabService) {
+        this.devLabService = devLabService;
+    }
+
+    @GetMapping("")
+    public String manage(Model model) {
+        model.addAttribute("games", devLabService.gameRows());
+        return "admin/devlab";
+    }
+
+    @GetMapping("/games/{gameId}")
+    public String game(@PathVariable Long gameId, Model model) {
+        DevLabGame game = devLabService.gameWithTasks(gameId);
+        if (game == null) {
+            return "redirect:/admin/devlab";
+        }
+        model.addAttribute("game", game);
+        return "admin/devlab-game";
+    }
+
+    @PostMapping("/games")
+    public String createGame(@RequestParam String title,
+                             @RequestParam(required = false) String language,
+                             @RequestParam(required = false) String path,
+                             @RequestParam(required = false) String description) {
+        Long id = devLabService.createGame(title, language, path, description);
+        return id == null ? "redirect:/admin/devlab" : "redirect:/admin/devlab/games/" + id;
+    }
+
+    @PostMapping("/games/{gameId}/tasks")
+    public String addTask(@PathVariable Long gameId,
+                          @RequestParam String type,
+                          @RequestParam String prompt,
+                          @RequestParam(defaultValue = "100") int points,
+                          @RequestParam String payload) {
+        devLabService.addTask(gameId, type, prompt, points, payload);
+        return "redirect:/admin/devlab/games/" + gameId;
+    }
+
+    @PostMapping("/tasks/{taskId}/update")
+    public String updateTask(@PathVariable Long taskId,
+                             @RequestParam Long gameId,
+                             @RequestParam String prompt,
+                             @RequestParam(defaultValue = "100") int points,
+                             @RequestParam String payload) {
+        devLabService.updateTask(taskId, prompt, points, payload);
+        return "redirect:/admin/devlab/games/" + gameId;
+    }
+
+    @PostMapping("/tasks/{taskId}/delete")
+    public String deleteTask(@PathVariable Long taskId, @RequestParam Long gameId) {
+        devLabService.deleteTask(taskId);
+        return "redirect:/admin/devlab/games/" + gameId;
+    }
+
+    @PostMapping("/games/{gameId}/delete")
+    public String deleteGame(@PathVariable Long gameId) {
+        devLabService.deleteGame(gameId);
+        return "redirect:/admin/devlab";
+    }
+
+    @PostMapping("/games/{gameId}/toggle")
+    public String toggleGame(@PathVariable Long gameId) {
+        devLabService.toggleGame(gameId);
+        return "redirect:/admin/devlab";
+    }
+}

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

@@ -0,0 +1,102 @@
+package com.example.mindflux.controller;
+
+import com.example.mindflux.model.SyntaxSagaMission;
+import com.example.mindflux.service.SyntaxSagaService;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Arrays;
+import java.util.List;
+
+/** Admin-Verwaltung der Syntax-Saga-Missionen, -Lücken und -Lösungen (ROLE_ADMIN via /admin/**). */
+@Controller
+@RequestMapping("/admin/syntaxsaga")
+public class AdminSyntaxSagaController {
+
+    private final SyntaxSagaService syntaxSagaService;
+
+    public AdminSyntaxSagaController(SyntaxSagaService syntaxSagaService) {
+        this.syntaxSagaService = syntaxSagaService;
+    }
+
+    /** Übersicht aller Missionen. */
+    @GetMapping("")
+    public String manage(Model model) {
+        model.addAttribute("missions", syntaxSagaService.missionRows());
+        return "admin/syntaxsaga";
+    }
+
+    /** Detailseite einer Mission mit ihren Lücken. */
+    @GetMapping("/missions/{missionId}")
+    public String mission(@PathVariable Long missionId, Model model) {
+        SyntaxSagaMission mission = syntaxSagaService.missionWithGaps(missionId);
+        if (mission == null) {
+            return "redirect:/admin/syntaxsaga";
+        }
+        model.addAttribute("mission", mission);
+        return "admin/syntaxsaga-mission";
+    }
+
+    @PostMapping("/missions")
+    public String createMission(@RequestParam String title,
+                                @RequestParam(required = false) String difficulty,
+                                @RequestParam(required = false) String narrative,
+                                @RequestParam(required = false) String dialog,
+                                @RequestParam(required = false) String language,
+                                @RequestParam String codeTemplate,
+                                @RequestParam(required = false) String successText) {
+        Long id = syntaxSagaService.createMission(title, difficulty, narrative, dialog,
+                language, codeTemplate, successText);
+        return id == null ? "redirect:/admin/syntaxsaga"
+                : "redirect:/admin/syntaxsaga/missions/" + id;
+    }
+
+    @PostMapping("/missions/{missionId}/update")
+    public String updateMission(@PathVariable Long missionId,
+                                @RequestParam String title,
+                                @RequestParam(required = false) String difficulty,
+                                @RequestParam(required = false) String narrative,
+                                @RequestParam(required = false) String dialog,
+                                @RequestParam(required = false) String language,
+                                @RequestParam String codeTemplate,
+                                @RequestParam(required = false) String successText) {
+        syntaxSagaService.updateMission(missionId, title, difficulty, narrative, dialog,
+                language, codeTemplate, successText);
+        return "redirect:/admin/syntaxsaga/missions/" + missionId;
+    }
+
+    @PostMapping("/missions/{missionId}/gaps")
+    public String addGap(@PathVariable Long missionId,
+                         @RequestParam(defaultValue = "0") int position,
+                         @RequestParam(defaultValue = "100") int points,
+                         @RequestParam(defaultValue = "false") boolean caseSensitive,
+                         @RequestParam(required = false) String hint,
+                         @RequestParam(required = false) String placeholder,
+                         @RequestParam(required = false, defaultValue = "") String solutions) {
+        List<String> parsed = Arrays.stream(solutions.split("\\r?\\n"))
+                .map(String::trim)
+                .filter(s -> !s.isEmpty())
+                .toList();
+        syntaxSagaService.addGap(missionId, position, points, caseSensitive, hint, placeholder, parsed);
+        return "redirect:/admin/syntaxsaga/missions/" + missionId;
+    }
+
+    @PostMapping("/gaps/{gapId}/delete")
+    public String deleteGap(@PathVariable Long gapId, @RequestParam Long missionId) {
+        syntaxSagaService.deleteGap(gapId);
+        return "redirect:/admin/syntaxsaga/missions/" + missionId;
+    }
+
+    @PostMapping("/missions/{missionId}/delete")
+    public String deleteMission(@PathVariable Long missionId) {
+        syntaxSagaService.deleteMission(missionId);
+        return "redirect:/admin/syntaxsaga";
+    }
+
+    @PostMapping("/missions/{missionId}/toggle")
+    public String toggleMission(@PathVariable Long missionId) {
+        syntaxSagaService.toggleMission(missionId);
+        return "redirect:/admin/syntaxsaga";
+    }
+}

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()));
+            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 {
+            // Neuanlage zentral über den UserService (Validierung, Eindeutigkeit, Encoding)
+            userService.createUser(user.getUsername(), user.getEmail(), user.getPassword(), user.getRole());
+        }
+        return "redirect:/admin/users";
+    }
+
+    /** 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/DevLabApiController.java

@@ -0,0 +1,46 @@
+package com.example.mindflux.controller;
+
+import com.example.mindflux.dto.DevLabCheckRequest;
+import com.example.mindflux.dto.DevLabFinishRequest;
+import com.example.mindflux.dto.DevLabResult;
+import com.example.mindflux.service.DevLabService;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.springframework.web.bind.annotation.*;
+
+import java.security.Principal;
+
+/** JSON-API fürs Dev Lab. Server-autoritativ: Lösungen werden nie ausgeliefert. */
+@RestController
+@RequestMapping("/api/devlab")
+public class DevLabApiController {
+
+    private final DevLabService devLabService;
+
+    public DevLabApiController(DevLabService devLabService) {
+        this.devLabService = devLabService;
+    }
+
+    /** Spiele-Katalog für den Hub (nach Pfad gruppierbar). */
+    @GetMapping("/catalog")
+    public JsonNode catalog() {
+        return devLabService.buildCatalog();
+    }
+
+    /** Eine Spielrunde: Aufgaben einer Disziplin – ohne Lösungen. */
+    @GetMapping("/games/{slug}/session")
+    public JsonNode session(@PathVariable String slug) {
+        return devLabService.buildSession(slug);
+    }
+
+    /** Eine Aufgabe serverseitig prüfen; mit {@code reveal=true} auch die Auflösung. */
+    @PostMapping("/check")
+    public JsonNode check(@RequestBody DevLabCheckRequest request) {
+        return devLabService.check(request.getTaskId(), request.isReveal(), request.getSubmission());
+    }
+
+    /** Durchlauf abschließen: Score wird serverseitig neu berechnet und gespeichert. */
+    @PostMapping("/finish")
+    public DevLabResult finish(@RequestBody DevLabFinishRequest request, Principal principal) {
+        return devLabService.finish(principal.getName(), request);
+    }
+}

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

@@ -0,0 +1,21 @@
+package com.example.mindflux.controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+
+@Controller
+public class DevLabController {
+
+    @GetMapping("/devlab")
+    public String showDevLab() {
+        return "devlab";
+    }
+
+    @GetMapping("/devlab/games/{slug}")
+    public String showDevLabGame(@PathVariable String slug, Model model) {
+        model.addAttribute("gameSlug", slug);
+        return "devlab-game";
+    }
+}

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", "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/ImpressumController.java

@@ -0,0 +1,13 @@
+package com.example.mindflux.controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+
+@Controller
+public class ImpressumController {
+
+    @GetMapping("/impressum")
+    public String impressum() {
+        return "impressum"; // verweist auf impressum.html in src/main/resources/templates
+    }
+}

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

@@ -0,0 +1,27 @@
+package com.example.mindflux.controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+
+/**
+ * Liefert die statischen Rechts-/Informationsseiten aus dem Footer:
+ * AGB / Nutzungsbedingungen, Datenschutzerklärung und Community-Richtlinien.
+ */
+@Controller
+public class LegalController {
+
+    @GetMapping("/nutzungsbedingungen")
+    public String nutzungsbedingungen() {
+        return "legal/nutzungsbedingungen";
+    }
+
+    @GetMapping("/datenschutz")
+    public String datenschutz() {
+        return "legal/datenschutz";
+    }
+
+    @GetMapping("/richtlinien")
+    public String richtlinien() {
+        return "legal/richtlinien";
+    }
+}

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);
                 }
             }
 
@@ -179,16 +187,23 @@ public class ProfileController {
     @PostMapping("/profile/delete")
     public String deleteProfile(Principal principal, Authentication authentication, HttpServletRequest request, HttpServletResponse response) {
         String username = principal.getName();
+
+        // Profilbild-Datei von der Platte entfernen (DB-Daten löscht der Service in einer Transaktion).
+        User user = userService.findByUsername(username);
+        if (user != null) {
+            String profilePicture = user.getProfilePicture();
+            if (profilePicture != null && !profilePicture.trim().isEmpty()) {
+                try {
+                    Path picturePath = Paths.get(System.getProperty("user.dir"), "uploads", "profiles", profilePicture);
+                    Files.deleteIfExists(picturePath);
+                } catch (IOException e) {
+                    log.error("Fehler beim Löschen des Profilbilds", e);
+                }
+            }
+        }
+
         userService.deleteByUsername(username);
         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) {
-            model.addAttribute("error", "Benutzername bereits vergeben.");
-            return "register";
-        }
-
-        // 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/SyntaxSagaApiController.java

@@ -0,0 +1,41 @@
+package com.example.mindflux.controller;
+
+import com.example.mindflux.dto.SyntaxSagaCheckRequest;
+import com.example.mindflux.dto.SyntaxSagaCheckResult;
+import com.example.mindflux.dto.SyntaxSagaFinishRequest;
+import com.example.mindflux.dto.SyntaxSagaResult;
+import com.example.mindflux.dto.SyntaxSagaStoryView;
+import com.example.mindflux.service.SyntaxSagaService;
+import org.springframework.web.bind.annotation.*;
+
+import java.security.Principal;
+
+/** JSON-API für Syntax Saga. Server-autoritativ: Lösungen werden nie ausgeliefert. */
+@RestController
+@RequestMapping("/api/syntaxsaga")
+public class SyntaxSagaApiController {
+
+    private final SyntaxSagaService syntaxSagaService;
+
+    public SyntaxSagaApiController(SyntaxSagaService syntaxSagaService) {
+        this.syntaxSagaService = syntaxSagaService;
+    }
+
+    /** Missionen einer Stufe (oder stufenübergreifend) – ohne Lösungen. */
+    @GetMapping("/story")
+    public SyntaxSagaStoryView story(@RequestParam(required = false) String difficulty) {
+        return syntaxSagaService.buildStory(difficulty);
+    }
+
+    /** Eine Mission serverseitig prüfen; mit {@code reveal=true} auch die Auflösung. */
+    @PostMapping("/check")
+    public SyntaxSagaCheckResult check(@RequestBody SyntaxSagaCheckRequest request) {
+        return syntaxSagaService.check(request);
+    }
+
+    /** Durchlauf abschließen: Score wird serverseitig neu berechnet und gespeichert. */
+    @PostMapping("/finish")
+    public SyntaxSagaResult finish(@RequestBody SyntaxSagaFinishRequest request, Principal principal) {
+        return syntaxSagaService.finish(principal.getName(), request);
+    }
+}

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

@@ -4,10 +4,10 @@ import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.GetMapping;
 
 @Controller
-public class SettingsController {
+public class SyntaxSagaController {
 
-    @GetMapping("/profile/settings")
-    public String showSettingsPage() {
-        return "settings"; // lädt templates/settings.html
+    @GetMapping("/syntaxsaga")
+    public String show() {
+        return "syntaxsaga"; // Lädt templates/syntaxsaga.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)
+        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();
         }
+        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/DevLabCheckRequest.java

@@ -0,0 +1,20 @@
+package com.example.mindflux.dto;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+/** Prüft eine Dev-Lab-Aufgabe. {@code submission} ist mechanikspezifisch (JSON). */
+public class DevLabCheckRequest {
+
+    private Long taskId;
+    private boolean reveal;
+    private JsonNode submission;
+
+    public Long getTaskId() { return taskId; }
+    public void setTaskId(Long taskId) { this.taskId = taskId; }
+
+    public boolean isReveal() { return reveal; }
+    public void setReveal(boolean reveal) { this.reveal = reveal; }
+
+    public JsonNode getSubmission() { return submission; }
+    public void setSubmission(JsonNode submission) { this.submission = submission; }
+}

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

@@ -0,0 +1,43 @@
+package com.example.mindflux.dto;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import java.util.List;
+
+/**
+ * Abschluss eines Dev-Lab-Durchlaufs: pro Aufgabe die letzte Eingabe + Versuche/Auflösung.
+ * Der Score wird serverseitig aus den Eingaben neu berechnet.
+ */
+public class DevLabFinishRequest {
+
+    private String slug;
+    private int durationSeconds;
+    private List<Item> items;
+
+    public String getSlug() { return slug; }
+    public void setSlug(String slug) { this.slug = slug; }
+
+    public int getDurationSeconds() { return durationSeconds; }
+    public void setDurationSeconds(int durationSeconds) { this.durationSeconds = durationSeconds; }
+
+    public List<Item> getItems() { return items; }
+    public void setItems(List<Item> items) { this.items = items; }
+
+    public static class Item {
+        private Long taskId;
+        private JsonNode submission;
+        private int attempts;
+        private boolean revealed;
+
+        public Long getTaskId() { return taskId; }
+        public void setTaskId(Long taskId) { this.taskId = taskId; }
+
+        public JsonNode getSubmission() { return submission; }
+        public void setSubmission(JsonNode submission) { this.submission = submission; }
+
+        public int getAttempts() { return attempts; }
+        public void setAttempts(int attempts) { this.attempts = attempts; }
+
+        public boolean isRevealed() { return revealed; }
+        public void setRevealed(boolean revealed) { this.revealed = revealed; }
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.example.mindflux.dto;
+
+/** Eine Zeile in der Admin-Spieleübersicht (ohne alle Aufgaben zu laden). */
+public class DevLabGameRow {
+    private final Long id;
+    private final String slug;
+    private final String title;
+    private final String language;
+    private final String path;
+    private final boolean active;
+    private final long taskCount;
+
+    public DevLabGameRow(Long id, String slug, String title, String language, String path,
+                         boolean active, long taskCount) {
+        this.id = id;
+        this.slug = slug;
+        this.title = title;
+        this.language = language;
+        this.path = path;
+        this.active = active;
+        this.taskCount = taskCount;
+    }
+
+    public Long getId() { return id; }
+    public String getSlug() { return slug; }
+    public String getTitle() { return title; }
+    public String getLanguage() { return language; }
+    public String getPath() { return path; }
+    public boolean isActive() { return active; }
+    public long getTaskCount() { return taskCount; }
+}

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

@@ -0,0 +1,35 @@
+package com.example.mindflux.dto;
+
+/** Endergebnis eines Dev-Lab-Durchlaufs (Score serverseitig berechnet) + Highscore-Stand. */
+public class DevLabResult {
+
+    private final int score;
+    private final int maxScore;
+    private final int solvedTasks;
+    private final int totalTasks;
+    private final int stars;
+    private final int highscore;
+    private final boolean newHighscore;
+    private final long plays;
+
+    public DevLabResult(int score, int maxScore, int solvedTasks, int totalTasks, int stars,
+                        int highscore, boolean newHighscore, long plays) {
+        this.score = score;
+        this.maxScore = maxScore;
+        this.solvedTasks = solvedTasks;
+        this.totalTasks = totalTasks;
+        this.stars = stars;
+        this.highscore = highscore;
+        this.newHighscore = newHighscore;
+        this.plays = plays;
+    }
+
+    public int getScore() { return score; }
+    public int getMaxScore() { return maxScore; }
+    public int getSolvedTasks() { return solvedTasks; }
+    public int getTotalTasks() { return totalTasks; }
+    public int getStars() { return stars; }
+    public int getHighscore() { return highscore; }
+    public boolean isNewHighscore() { return newHighscore; }
+    public long getPlays() { return plays; }
+}

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/dto/SyntaxSagaCheckRequest.java

@@ -0,0 +1,31 @@
+package com.example.mindflux.dto;
+
+import java.util.List;
+
+/** Eine Mission prüfen: die eingetippten Lücken (+ ob die Auflösung angefordert wird). */
+public class SyntaxSagaCheckRequest {
+
+    private Long missionId;
+    private boolean reveal;
+    private List<GapAnswer> answers;
+
+    public Long getMissionId() { return missionId; }
+    public void setMissionId(Long missionId) { this.missionId = missionId; }
+
+    public boolean isReveal() { return reveal; }
+    public void setReveal(boolean reveal) { this.reveal = reveal; }
+
+    public List<GapAnswer> getAnswers() { return answers; }
+    public void setAnswers(List<GapAnswer> answers) { this.answers = answers; }
+
+    public static class GapAnswer {
+        private int position;
+        private String text;
+
+        public int getPosition() { return position; }
+        public void setPosition(int position) { this.position = position; }
+
+        public String getText() { return text; }
+        public void setText(String text) { this.text = text; }
+    }
+}

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

@@ -0,0 +1,37 @@
+package com.example.mindflux.dto;
+
+import java.util.List;
+
+/**
+ * Serverseitige Bewertung einer Mission (instant feedback). {@code solution} ist nur
+ * gefüllt, wenn die Auflösung angefordert wurde und die Lücke nicht korrekt war.
+ */
+public class SyntaxSagaCheckResult {
+
+    private final boolean allCorrect;
+    private final List<GapVerdict> results;
+
+    public SyntaxSagaCheckResult(boolean allCorrect, List<GapVerdict> results) {
+        this.allCorrect = allCorrect;
+        this.results = results;
+    }
+
+    public boolean isAllCorrect() { return allCorrect; }
+    public List<GapVerdict> getResults() { return results; }
+
+    public static class GapVerdict {
+        private final int position;
+        private final boolean correct;
+        private final String solution;
+
+        public GapVerdict(int position, boolean correct, String solution) {
+            this.position = position;
+            this.correct = correct;
+            this.solution = solution;
+        }
+
+        public int getPosition() { return position; }
+        public boolean isCorrect() { return correct; }
+        public String getSolution() { return solution; }
+    }
+}

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

@@ -0,0 +1,46 @@
+package com.example.mindflux.dto;
+
+import java.util.List;
+
+/**
+ * Abschluss eines Saga-Durchlaufs: alle eingetippten Lücken über alle Missionen einer
+ * Stufe (+ Versuche und ob aufgelöst wurde). Der Score wird serverseitig neu berechnet.
+ */
+public class SyntaxSagaFinishRequest {
+
+    private String difficulty;
+    private int durationSeconds;
+    private List<FinishGap> gaps;
+
+    public String getDifficulty() { return difficulty; }
+    public void setDifficulty(String difficulty) { this.difficulty = difficulty; }
+
+    public int getDurationSeconds() { return durationSeconds; }
+    public void setDurationSeconds(int durationSeconds) { this.durationSeconds = durationSeconds; }
+
+    public List<FinishGap> getGaps() { return gaps; }
+    public void setGaps(List<FinishGap> gaps) { this.gaps = gaps; }
+
+    public static class FinishGap {
+        private Long missionId;
+        private int position;
+        private String text;
+        private int attempts;
+        private boolean revealed;
+
+        public Long getMissionId() { return missionId; }
+        public void setMissionId(Long missionId) { this.missionId = missionId; }
+
+        public int getPosition() { return position; }
+        public void setPosition(int position) { this.position = position; }
+
+        public String getText() { return text; }
+        public void setText(String text) { this.text = text; }
+
+        public int getAttempts() { return attempts; }
+        public void setAttempts(int attempts) { this.attempts = attempts; }
+
+        public boolean isRevealed() { return revealed; }
+        public void setRevealed(boolean revealed) { this.revealed = revealed; }
+    }
+}

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

@@ -0,0 +1,28 @@
+package com.example.mindflux.dto;
+
+/** Eine Zeile in der Admin-Missionsübersicht (ohne alle Lücken zu laden). */
+public class SyntaxSagaMissionRow {
+    private final Long id;
+    private final String slug;
+    private final String title;
+    private final String difficulty;
+    private final boolean active;
+    private final long gapCount;
+
+    public SyntaxSagaMissionRow(Long id, String slug, String title, String difficulty,
+                                boolean active, long gapCount) {
+        this.id = id;
+        this.slug = slug;
+        this.title = title;
+        this.difficulty = difficulty;
+        this.active = active;
+        this.gapCount = gapCount;
+    }
+
+    public Long getId() { return id; }
+    public String getSlug() { return slug; }
+    public String getTitle() { return title; }
+    public String getDifficulty() { return difficulty; }
+    public boolean isActive() { return active; }
+    public long getGapCount() { return gapCount; }
+}

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

@@ -0,0 +1,35 @@
+package com.example.mindflux.dto;
+
+/** Endergebnis eines Saga-Durchlaufs (Score serverseitig berechnet) + Highscore-Stand. */
+public class SyntaxSagaResult {
+
+    private final int score;
+    private final int maxScore;
+    private final int solvedGaps;
+    private final int totalGaps;
+    private final int stars;
+    private final int highscore;
+    private final boolean newHighscore;
+    private final long plays;
+
+    public SyntaxSagaResult(int score, int maxScore, int solvedGaps, int totalGaps, int stars,
+                            int highscore, boolean newHighscore, long plays) {
+        this.score = score;
+        this.maxScore = maxScore;
+        this.solvedGaps = solvedGaps;
+        this.totalGaps = totalGaps;
+        this.stars = stars;
+        this.highscore = highscore;
+        this.newHighscore = newHighscore;
+        this.plays = plays;
+    }
+
+    public int getScore() { return score; }
+    public int getMaxScore() { return maxScore; }
+    public int getSolvedGaps() { return solvedGaps; }
+    public int getTotalGaps() { return totalGaps; }
+    public int getStars() { return stars; }
+    public int getHighscore() { return highscore; }
+    public boolean isNewHighscore() { return newHighscore; }
+    public long getPlays() { return plays; }
+}

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

@@ -0,0 +1,82 @@
+package com.example.mindflux.dto;
+
+import java.util.List;
+
+/**
+ * Die Missionen einer Schwierigkeitsstufe fürs Frontend. Bewusst OHNE Lösungen –
+ * geprüft und gewertet wird ausschließlich serverseitig.
+ */
+public class SyntaxSagaStoryView {
+
+    private final String difficulty;
+    private final List<Mission> missions;
+    private final int maxScore;
+    private final int totalGaps;
+
+    public SyntaxSagaStoryView(String difficulty, List<Mission> missions, int maxScore, int totalGaps) {
+        this.difficulty = difficulty;
+        this.missions = missions;
+        this.maxScore = maxScore;
+        this.totalGaps = totalGaps;
+    }
+
+    public String getDifficulty() { return difficulty; }
+    public List<Mission> getMissions() { return missions; }
+    public int getMaxScore() { return maxScore; }
+    public int getTotalGaps() { return totalGaps; }
+
+    public static class Mission {
+        private final Long missionId;
+        private final String title;
+        private final String difficulty;
+        private final String language;
+        private final String narrative;
+        private final String dialog;
+        private final String codeTemplate;
+        private final String successText;
+        private final List<Gap> gaps;
+
+        public Mission(Long missionId, String title, String difficulty, String language,
+                       String narrative, String dialog, String codeTemplate,
+                       String successText, List<Gap> gaps) {
+            this.missionId = missionId;
+            this.title = title;
+            this.difficulty = difficulty;
+            this.language = language;
+            this.narrative = narrative;
+            this.dialog = dialog;
+            this.codeTemplate = codeTemplate;
+            this.successText = successText;
+            this.gaps = gaps;
+        }
+
+        public Long getMissionId() { return missionId; }
+        public String getTitle() { return title; }
+        public String getDifficulty() { return difficulty; }
+        public String getLanguage() { return language; }
+        public String getNarrative() { return narrative; }
+        public String getDialog() { return dialog; }
+        public String getCodeTemplate() { return codeTemplate; }
+        public String getSuccessText() { return successText; }
+        public List<Gap> getGaps() { return gaps; }
+    }
+
+    public static class Gap {
+        private final int position;
+        private final int points;
+        private final String hint;
+        private final String placeholder;
+
+        public Gap(int position, int points, String hint, String placeholder) {
+            this.position = position;
+            this.points = points;
+            this.hint = hint;
+            this.placeholder = placeholder;
+        }
+
+        public int getPosition() { return position; }
+        public int getPoints() { return points; }
+        public String getHint() { return hint; }
+        public String getPlaceholder() { return placeholder; }
+    }
+}

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

@@ -0,0 +1,88 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Ein Dev-Lab-Spiel (z.B. "SQL Detective"). Bündelt themengleiche Aufgaben unterschiedlicher
+ * Mechaniken. Inhalte DB-gestützt und im Admin pflegbar; server-autoritativ geprüft.
+ */
+@Entity
+@Table(name = "devlab_games")
+public class DevLabGame {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(unique = true)
+    private String slug;
+
+    private String title;
+
+    /** Anzeige-Sprache/Domäne, z.B. "SQL", "CSS", "Git". */
+    @Column(name = "code_language")
+    private String language;
+
+    /** Trainingspfad: "syntax" | "debugging" | "visual". */
+    @Column(name = "lab_path")
+    private String path;
+
+    private String description;
+
+    @Column(name = "sort_order")
+    private int sortOrder;
+
+    private boolean active = true;
+
+    @OneToMany(mappedBy = "game", cascade = CascadeType.ALL, orphanRemoval = true)
+    @OrderBy("sortOrder ASC, id ASC")
+    private List<DevLabTask> tasks = new ArrayList<>();
+
+    public DevLabGame() {
+    }
+
+    public DevLabGame(String slug, String title, String language, String path,
+                      String description, int sortOrder, boolean active) {
+        this.slug = slug;
+        this.title = title;
+        this.language = language;
+        this.path = path;
+        this.description = description;
+        this.sortOrder = sortOrder;
+        this.active = active;
+    }
+
+    public void addTask(DevLabTask task) {
+        task.setGame(this);
+        this.tasks.add(task);
+    }
+
+    public Long getId() { return id; }
+    public void setId(Long id) { this.id = id; }
+
+    public String getSlug() { return slug; }
+    public void setSlug(String slug) { this.slug = slug; }
+
+    public String getTitle() { return title; }
+    public void setTitle(String title) { this.title = title; }
+
+    public String getLanguage() { return language; }
+    public void setLanguage(String language) { this.language = language; }
+
+    public String getPath() { return path; }
+    public void setPath(String path) { this.path = path; }
+
+    public String getDescription() { return description; }
+    public void setDescription(String description) { this.description = description; }
+
+    public int getSortOrder() { return sortOrder; }
+    public void setSortOrder(int sortOrder) { this.sortOrder = sortOrder; }
+
+    public boolean isActive() { return active; }
+    public void setActive(boolean active) { this.active = active; }
+
+    public List<DevLabTask> getTasks() { return tasks; }
+    public void setTasks(List<DevLabTask> tasks) { this.tasks = tasks; }
+}

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

@@ -0,0 +1,69 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+
+/**
+ * Eine Dev-Lab-Aufgabe. Der {@code type} bestimmt die Spielmechanik (cloze, choice, order,
+ * spot, match, regex); die mechanikspezifischen Daten inkl. Lösung stehen als JSON im
+ * {@code payload}. Der {@code payload} verlässt nie unverändert das Backend – der Service baut
+ * daraus eine bereinigte Sicht (ohne Lösung) und prüft serverseitig.
+ */
+@Entity
+@Table(name = "devlab_tasks")
+public class DevLabTask {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "game_id")
+    private DevLabGame game;
+
+    /** Mechanik: cloze | choice | order | spot | match | regex. */
+    @Column(name = "task_type")
+    private String type;
+
+    /** Kurzer Aufgabentitel (für Anzeige + Admin-Liste). */
+    private String prompt;
+
+    private int points = 100;
+
+    @Column(name = "sort_order")
+    private int sortOrder;
+
+    /** Vollständige Aufgabenspezifikation als JSON (inkl. Lösung). */
+    private String payload;
+
+    public DevLabTask() {
+    }
+
+    public DevLabTask(String type, String prompt, int points, int sortOrder, String payload) {
+        this.type = type;
+        this.prompt = prompt;
+        this.points = points;
+        this.sortOrder = sortOrder;
+        this.payload = payload;
+    }
+
+    public Long getId() { return id; }
+    public void setId(Long id) { this.id = id; }
+
+    public DevLabGame getGame() { return game; }
+    public void setGame(DevLabGame game) { this.game = game; }
+
+    public String getType() { return type; }
+    public void setType(String type) { this.type = type; }
+
+    public String getPrompt() { return prompt; }
+    public void setPrompt(String prompt) { this.prompt = prompt; }
+
+    public int getPoints() { return points; }
+    public void setPoints(int points) { this.points = points; }
+
+    public int getSortOrder() { return sortOrder; }
+    public void setSortOrder(int sortOrder) { this.sortOrder = sortOrder; }
+
+    public String getPayload() { return payload; }
+    public void setPayload(String payload) { this.payload = payload; }
+}

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/model/SyntaxSagaGap.java

@@ -0,0 +1,112 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Eine Lücke in einer {@link SyntaxSagaMission}. Die {@link #position} entspricht der
+ * Markernummer {@code {{n}}} im Codetemplate. Eine Lücke kann mehrere gültige Lösungen
+ * haben (z.B. {@code 192.168.0.1} oder {@code localhost}). Die Prüfung passiert
+ * serverseitig über {@link #matches(String)} – das Frontend kennt die Lösung nie.
+ */
+@Entity
+@Table(name = "syntax_saga_gaps")
+public class SyntaxSagaGap {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "mission_id")
+    private SyntaxSagaMission mission;
+
+    /** 1-basierte Position, = Markernummer {@code {{n}}} im Codetemplate. */
+    @Column(name = "gap_position")
+    private int position;
+
+    private int points = 100;
+
+    /** Groß-/Kleinschreibung relevant? (true für Java-Bezeichner, false z.B. für SQL-Keywords). */
+    @Column(name = "case_sensitive")
+    private boolean caseSensitive = true;
+
+    private String hint;
+
+    /** Kurzlabel/Platzhalter im Eingabefeld, z.B. "Methodenname". */
+    private String placeholder;
+
+    @OneToMany(mappedBy = "gap", cascade = CascadeType.ALL, orphanRemoval = true)
+    @OrderBy("sortOrder ASC, id ASC")
+    private List<SyntaxSagaSolution> solutions = new ArrayList<>();
+
+    public SyntaxSagaGap() {
+    }
+
+    public SyntaxSagaGap(int position, int points, boolean caseSensitive, String hint, String placeholder) {
+        this.position = position;
+        this.points = points;
+        this.caseSensitive = caseSensitive;
+        this.hint = hint;
+        this.placeholder = placeholder;
+    }
+
+    public void addSolution(SyntaxSagaSolution solution) {
+        solution.setGap(this);
+        this.solutions.add(solution);
+    }
+
+    /** Normalisiert (trim + interne Whitespace zu einem Space). */
+    private static String normalize(String value) {
+        return value == null ? "" : value.trim().replaceAll("\\s+", " ");
+    }
+
+    /** Prüft eine Eingabe serverseitig gegen alle gültigen Lösungen. */
+    public boolean matches(String typed) {
+        if (typed == null) {
+            return false;
+        }
+        String t = normalize(typed);
+        if (t.isEmpty()) {
+            return false;
+        }
+        for (SyntaxSagaSolution solution : solutions) {
+            String sol = normalize(solution.getText());
+            boolean equal = caseSensitive ? t.equals(sol) : t.equalsIgnoreCase(sol);
+            if (equal) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /** Kanonische Lösung (für die "Auflösung anzeigen"-Funktion). */
+    public String firstSolution() {
+        return solutions.isEmpty() ? "" : solutions.get(0).getText();
+    }
+
+    public Long getId() { return id; }
+    public void setId(Long id) { this.id = id; }
+
+    public SyntaxSagaMission getMission() { return mission; }
+    public void setMission(SyntaxSagaMission mission) { this.mission = mission; }
+
+    public int getPosition() { return position; }
+    public void setPosition(int position) { this.position = position; }
+
+    public int getPoints() { return points; }
+    public void setPoints(int points) { this.points = points; }
+
+    public boolean isCaseSensitive() { return caseSensitive; }
+    public void setCaseSensitive(boolean caseSensitive) { this.caseSensitive = caseSensitive; }
+
+    public String getHint() { return hint; }
+    public void setHint(String hint) { this.hint = hint; }
+
+    public String getPlaceholder() { return placeholder; }
+    public void setPlaceholder(String placeholder) { this.placeholder = placeholder; }
+
+    public List<SyntaxSagaSolution> getSolutions() { return solutions; }
+    public void setSolutions(List<SyntaxSagaSolution> solutions) { this.solutions = solutions; }
+}

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

@@ -0,0 +1,114 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Eine Syntax-Saga-Mission (ein Kapitel): Story + optionaler Dialog + Codeblock mit
+ * Lücken. Im {@code codeTemplate} markieren {@code {{1}}}, {@code {{2}}} … die Lücken
+ * (Nummer = {@link SyntaxSagaGap#getPosition() position}). Gespielt wird je
+ * Schwierigkeitsgrad als eigene lineare Saga.
+ */
+@Entity
+@Table(name = "syntax_saga_missions")
+public class SyntaxSagaMission {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(unique = true)
+    private String slug;
+
+    private String title;
+
+    /** "junior" | "professional" | "senior". */
+    private String difficulty;
+
+    /** Erzähltext / Szene. */
+    private String narrative;
+
+    /** Optionales Zitat ("Bitte… repariere mich…"). */
+    private String dialog;
+
+    /** Sprache des Codes für Badge/Darstellung, z.B. "java", "sql", "bash". */
+    @Column(name = "code_language")
+    private String language;
+
+    /** Code mit {@code {{n}}}-Markern an den Lücken. */
+    @Column(name = "code_template")
+    private String codeTemplate;
+
+    /** Fortsetzung nach dem Lösen ("Das Terminal erwacht…"). */
+    @Column(name = "success_text")
+    private String successText;
+
+    @Column(name = "sort_order")
+    private int sortOrder;
+
+    private boolean active = true;
+
+    @OneToMany(mappedBy = "mission", cascade = CascadeType.ALL, orphanRemoval = true)
+    @OrderBy("position ASC, id ASC")
+    private List<SyntaxSagaGap> gaps = new ArrayList<>();
+
+    public SyntaxSagaMission() {
+    }
+
+    public SyntaxSagaMission(String slug, String title, String difficulty, String narrative,
+                             String dialog, String language, String codeTemplate,
+                             String successText, int sortOrder, boolean active) {
+        this.slug = slug;
+        this.title = title;
+        this.difficulty = difficulty;
+        this.narrative = narrative;
+        this.dialog = dialog;
+        this.language = language;
+        this.codeTemplate = codeTemplate;
+        this.successText = successText;
+        this.sortOrder = sortOrder;
+        this.active = active;
+    }
+
+    public void addGap(SyntaxSagaGap gap) {
+        gap.setMission(this);
+        this.gaps.add(gap);
+    }
+
+    public Long getId() { return id; }
+    public void setId(Long id) { this.id = id; }
+
+    public String getSlug() { return slug; }
+    public void setSlug(String slug) { this.slug = slug; }
+
+    public String getTitle() { return title; }
+    public void setTitle(String title) { this.title = title; }
+
+    public String getDifficulty() { return difficulty; }
+    public void setDifficulty(String difficulty) { this.difficulty = difficulty; }
+
+    public String getNarrative() { return narrative; }
+    public void setNarrative(String narrative) { this.narrative = narrative; }
+
+    public String getDialog() { return dialog; }
+    public void setDialog(String dialog) { this.dialog = dialog; }
+
+    public String getLanguage() { return language; }
+    public void setLanguage(String language) { this.language = language; }
+
+    public String getCodeTemplate() { return codeTemplate; }
+    public void setCodeTemplate(String codeTemplate) { this.codeTemplate = codeTemplate; }
+
+    public String getSuccessText() { return successText; }
+    public void setSuccessText(String successText) { this.successText = successText; }
+
+    public int getSortOrder() { return sortOrder; }
+    public void setSortOrder(int sortOrder) { this.sortOrder = sortOrder; }
+
+    public boolean isActive() { return active; }
+    public void setActive(boolean active) { this.active = active; }
+
+    public List<SyntaxSagaGap> getGaps() { return gaps; }
+    public void setGaps(List<SyntaxSagaGap> gaps) { this.gaps = gaps; }
+}

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

@@ -0,0 +1,43 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+
+/** Eine gültige Antwort zu einer {@link SyntaxSagaGap} (eine Lücke kann mehrere haben). */
+@Entity
+@Table(name = "syntax_saga_solutions")
+public class SyntaxSagaSolution {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "gap_id")
+    private SyntaxSagaGap gap;
+
+    @Column(name = "solution_text")
+    private String text;
+
+    @Column(name = "sort_order")
+    private int sortOrder;
+
+    public SyntaxSagaSolution() {
+    }
+
+    public SyntaxSagaSolution(String text, int sortOrder) {
+        this.text = text;
+        this.sortOrder = sortOrder;
+    }
+
+    public Long getId() { return id; }
+    public void setId(Long id) { this.id = id; }
+
+    public SyntaxSagaGap getGap() { return gap; }
+    public void setGap(SyntaxSagaGap gap) { this.gap = gap; }
+
+    public String getText() { return text; }
+    public void setText(String text) { this.text = text; }
+
+    public int getSortOrder() { return sortOrder; }
+    public void setSortOrder(int sortOrder) { this.sortOrder = sortOrder; }
+}

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

@@ -7,4 +7,7 @@ import java.util.List;
 
 public interface AchievementRepository extends JpaRepository<Achievement, Long> {
     List<Achievement> findByUsername(String username);
+
+    /** Alle Achievements eines Spielers löschen (z. B. beim Löschen des Kontos). */
+    void deleteByUsername(String username);
 }

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/DevLabGameRepository.java

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

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

@@ -0,0 +1,9 @@
+package com.example.mindflux.repository;
+
+import com.example.mindflux.model.DevLabTask;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface DevLabTaskRepository extends JpaRepository<DevLabTask, Long> {
+
+    long countByGameId(Long gameId);
+}

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> {
@@ -15,4 +18,27 @@ public interface GameScoreRepository extends JpaRepository<GameScore, Long> {
 
     /** Wie oft ein Spieler ein Spiel abgeschlossen hat. */
     long countByUsernameAndGame(String username, String game);
+
+    /** 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/SyntaxSagaGapRepository.java

@@ -0,0 +1,9 @@
+package com.example.mindflux.repository;
+
+import com.example.mindflux.model.SyntaxSagaGap;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface SyntaxSagaGapRepository extends JpaRepository<SyntaxSagaGap, Long> {
+
+    long countByMissionId(Long missionId);
+}

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

@@ -0,0 +1,20 @@
+package com.example.mindflux.repository;
+
+import com.example.mindflux.model.SyntaxSagaMission;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface SyntaxSagaMissionRepository extends JpaRepository<SyntaxSagaMission, Long> {
+
+    /** Aktive Missionen einer Schwierigkeitsstufe in Spielreihenfolge. */
+    List<SyntaxSagaMission> findAllByActiveTrueAndDifficultyOrderBySortOrderAscIdAsc(String difficulty);
+
+    /** Alle aktiven Missionen in Spielreihenfolge (stufenübergreifend). */
+    List<SyntaxSagaMission> findAllByActiveTrueOrderBySortOrderAscIdAsc();
+
+    /** Alle Missionen (Admin-Übersicht). */
+    List<SyntaxSagaMission> findAllByOrderBySortOrderAscIdAsc();
+
+    boolean existsBySlug(String slug);
+}

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

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

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/DevLabService.java

@@ -0,0 +1,555 @@
+package com.example.mindflux.service;
+
+import com.example.mindflux.dto.DevLabFinishRequest;
+import com.example.mindflux.dto.DevLabGameRow;
+import com.example.mindflux.dto.DevLabResult;
+import com.example.mindflux.dto.ScoreResult;
+import com.example.mindflux.model.DevLabGame;
+import com.example.mindflux.model.DevLabTask;
+import com.example.mindflux.repository.DevLabGameRepository;
+import com.example.mindflux.repository.DevLabTaskRepository;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.regex.Pattern;
+
+/**
+ * Server-autoritative Logik fürs Dev Lab. Aus dem JSON-Payload jeder Aufgabe wird eine
+ * bereinigte Sicht (ohne Lösung) gebaut; geprüft wird ausschließlich serverseitig per
+ * Text-/Reihenfolge-/Verhaltensvergleich gegen den gespeicherten Payload. Mechaniken:
+ * cloze, choice, order, spot, match, regex.
+ */
+@Service
+public class DevLabService {
+
+    private static final String GAME = "devlab";
+    private static final Set<String> KNOWN_TYPES = Set.of("cloze", "choice", "order", "spot", "match", "regex");
+    private static final Set<String> KNOWN_PATHS = Set.of("syntax", "debugging", "visual");
+
+    private final DevLabGameRepository gameRepository;
+    private final DevLabTaskRepository taskRepository;
+    private final GameScoreService gameScoreService;
+    private final ObjectMapper mapper;
+    private final Random random = new Random();
+
+    public DevLabService(DevLabGameRepository gameRepository, DevLabTaskRepository taskRepository,
+                         GameScoreService gameScoreService, ObjectMapper mapper) {
+        this.gameRepository = gameRepository;
+        this.taskRepository = taskRepository;
+        this.gameScoreService = gameScoreService;
+        this.mapper = mapper;
+    }
+
+    // ---------- Katalog (Hub) ----------
+
+    /** Aktive Spiele nach Trainingspfad gruppiert (für den Hub). */
+    @Transactional(readOnly = true)
+    public JsonNode buildCatalog() {
+        ObjectNode root = mapper.createObjectNode();
+        ArrayNode games = root.putArray("games");
+        for (DevLabGame game : gameRepository.findAllByActiveTrueOrderBySortOrderAscIdAsc()) {
+            if (game.getTasks().isEmpty()) {
+                continue;
+            }
+            ObjectNode g = games.addObject();
+            g.put("slug", game.getSlug());
+            g.put("title", game.getTitle());
+            g.put("language", game.getLanguage());
+            g.put("path", game.getPath());
+            g.put("description", game.getDescription());
+            g.put("taskCount", game.getTasks().size());
+        }
+        return root;
+    }
+
+    // ---------- Spielrunde ----------
+
+    /** Eine Spielrunde: Spiel-Meta + alle aktiven Aufgaben als bereinigte Sicht (ohne Lösung). */
+    @Transactional(readOnly = true)
+    public JsonNode buildSession(String slug) {
+        DevLabGame game = gameRepository.findBySlug(slug).filter(DevLabGame::isActive).orElse(null);
+        ObjectNode root = mapper.createObjectNode();
+        if (game == null) {
+            root.put("found", false);
+            return root;
+        }
+        root.put("found", true);
+        root.put("slug", game.getSlug());
+        root.put("title", game.getTitle());
+        root.put("language", game.getLanguage());
+        root.put("path", game.getPath());
+        root.put("description", game.getDescription());
+
+        ArrayNode tasks = root.putArray("tasks");
+        int maxScore = 0;
+        for (DevLabTask task : game.getTasks()) {
+            ObjectNode view = sanitize(task);
+            if (view == null) {
+                continue;
+            }
+            tasks.add(view);
+            maxScore += task.getPoints();
+        }
+        root.put("maxScore", maxScore);
+        root.put("totalTasks", tasks.size());
+        return root;
+    }
+
+    /** Baut die spielerseitige Sicht einer Aufgabe – ohne Lösung. */
+    private ObjectNode sanitize(DevLabTask task) {
+        JsonNode p = parse(task.getPayload());
+        if (p == null) {
+            return null;
+        }
+        ObjectNode v = mapper.createObjectNode();
+        v.put("taskId", task.getId());
+        v.put("type", task.getType());
+        v.put("prompt", task.getPrompt());
+        v.put("points", task.getPoints());
+        copyText(p, v, "narrative");
+        copyText(p, v, "instruction");
+        copyText(p, v, "question");
+        copyText(p, v, "code");
+        copyText(p, v, "hint");
+        copyText(p, v, "successText");
+
+        switch (task.getType()) {
+            case "cloze" -> {
+                copyText(p, v, "codeTemplate");
+                ArrayNode gaps = v.putArray("gaps");
+                for (JsonNode g : array(p, "gaps")) {
+                    ObjectNode gv = gaps.addObject();
+                    gv.put("position", g.path("position").asInt());
+                    gv.put("placeholder", g.path("placeholder").asText(""));
+                    gv.put("hint", g.path("hint").asText(""));
+                }
+            }
+            case "choice" -> v.set("options", shuffledTextArray(stringList(p, "options")));
+            case "order" -> v.set("items", shuffledTextArray(stringList(p, "items")));
+            case "spot" -> {
+                ArrayNode tokens = v.putArray("tokens");
+                for (JsonNode t : array(p, "tokens")) {
+                    tokens.add(t.asText(""));
+                }
+            }
+            case "match" -> {
+                ArrayNode left = v.putArray("left");
+                ArrayNode right = v.putArray("right");
+                List<String> rights = new ArrayList<>();
+                for (JsonNode pair : array(p, "pairs")) {
+                    if (pair.isArray() && pair.size() >= 2) {
+                        left.add(pair.get(0).asText(""));
+                        rights.add(pair.get(1).asText(""));
+                    }
+                }
+                Collections.shuffle(rights, random);
+                rights.forEach(right::add);
+            }
+            case "regex" -> {
+                ArrayNode samples = v.putArray("samples");
+                for (JsonNode s : array(p, "samples")) {
+                    ObjectNode sv = samples.addObject();
+                    sv.put("text", s.path("text").asText(""));
+                    sv.put("shouldMatch", s.path("shouldMatch").asBoolean(false));
+                }
+            }
+            default -> { return null; }
+        }
+        return v;
+    }
+
+    // ---------- Prüfung ----------
+
+    /** Prüft eine Aufgabe serverseitig; mit {@code reveal} kommt die Auflösung dazu. */
+    @Transactional(readOnly = true)
+    public JsonNode check(Long taskId, boolean reveal, JsonNode submission) {
+        ObjectNode result = mapper.createObjectNode();
+        DevLabTask task = taskId == null ? null : taskRepository.findById(taskId).orElse(null);
+        JsonNode p = task == null ? null : parse(task.getPayload());
+        if (p == null) {
+            result.put("correct", false);
+            return result;
+        }
+        JsonNode sub = submission == null ? mapper.createObjectNode() : submission;
+        boolean correct = switch (task.getType()) {
+            case "cloze" -> checkCloze(p, sub, result, reveal);
+            case "choice" -> checkChoice(p, sub, result, reveal);
+            case "order" -> checkOrder(p, sub, result, reveal);
+            case "spot" -> checkSpot(p, sub, result, reveal);
+            case "match" -> checkMatch(p, sub, result, reveal);
+            case "regex" -> checkRegex(p, sub, result, reveal);
+            default -> false;
+        };
+        result.put("correct", correct);
+        if (correct && p.hasNonNull("successText")) {
+            result.put("successText", p.get("successText").asText());
+        }
+        return result;
+    }
+
+    private boolean checkCloze(JsonNode p, JsonNode sub, ObjectNode result, boolean reveal) {
+        Map<Integer, String> typed = new HashMap<>();
+        for (JsonNode g : array(sub, "gaps")) {
+            typed.put(g.path("position").asInt(), g.path("text").asText(""));
+        }
+        ArrayNode detail = result.putArray("detail");
+        boolean all = true;
+        for (JsonNode gap : array(p, "gaps")) {
+            int pos = gap.path("position").asInt();
+            boolean caseSensitive = gap.path("caseSensitive").asBoolean(true);
+            boolean ok = anyEquals(stringList(gap, "solutions"), typed.get(pos), caseSensitive);
+            if (!ok) {
+                all = false;
+            }
+            ObjectNode d = detail.addObject();
+            d.put("position", pos);
+            d.put("correct", ok);
+            if (reveal && !ok) {
+                List<String> sols = stringList(gap, "solutions");
+                d.put("solution", sols.isEmpty() ? "" : sols.get(0));
+            }
+        }
+        return all;
+    }
+
+    private boolean checkChoice(JsonNode p, JsonNode sub, ObjectNode result, boolean reveal) {
+        List<String> options = stringList(p, "options");
+        int correctIndex = p.path("correctIndex").asInt(-1);
+        String correctText = (correctIndex >= 0 && correctIndex < options.size()) ? options.get(correctIndex) : null;
+        boolean ok = correctText != null && textEquals(correctText, sub.path("choice").asText(""), false);
+        if (reveal && !ok && correctText != null) {
+            result.put("solution", correctText);
+        }
+        return ok;
+    }
+
+    private boolean checkOrder(JsonNode p, JsonNode sub, ObjectNode result, boolean reveal) {
+        List<String> correctOrder = stringList(p, "items");
+        List<String> given = stringList(sub, "order");
+        boolean ok = given.size() == correctOrder.size();
+        for (int i = 0; ok && i < correctOrder.size(); i++) {
+            if (!textEquals(correctOrder.get(i), given.get(i), false)) {
+                ok = false;
+            }
+        }
+        if (reveal && !ok) {
+            result.put("solution", String.join("  →  ", correctOrder));
+        }
+        return ok;
+    }
+
+    private boolean checkSpot(JsonNode p, JsonNode sub, ObjectNode result, boolean reveal) {
+        int bugIndex = p.path("bugIndex").asInt(-1);
+        boolean ok = sub.path("index").asInt(-2) == bugIndex;
+        if (reveal && !ok) {
+            ObjectNode sol = result.putObject("solution");
+            sol.put("index", bugIndex);
+            sol.put("fix", p.path("fix").asText(""));
+        }
+        return ok;
+    }
+
+    private boolean checkMatch(JsonNode p, JsonNode sub, ObjectNode result, boolean reveal) {
+        Map<String, String> correctPairs = new HashMap<>();
+        ArrayNode solution = mapper.createArrayNode();
+        for (JsonNode pair : array(p, "pairs")) {
+            if (pair.isArray() && pair.size() >= 2) {
+                correctPairs.put(normalize(pair.get(0).asText("")), normalize(pair.get(1).asText("")));
+                ArrayNode pv = solution.addArray();
+                pv.add(pair.get(0).asText(""));
+                pv.add(pair.get(1).asText(""));
+            }
+        }
+        int matched = 0;
+        for (JsonNode pair : array(sub, "pairs")) {
+            if (pair.isArray() && pair.size() >= 2) {
+                String want = correctPairs.get(normalize(pair.get(0).asText("")));
+                if (want != null && want.equals(normalize(pair.get(1).asText("")))) {
+                    matched++;
+                }
+            }
+        }
+        boolean ok = matched == correctPairs.size() && matched > 0;
+        if (reveal && !ok) {
+            result.set("solution", solution);
+        }
+        return ok;
+    }
+
+    private boolean checkRegex(JsonNode p, JsonNode sub, ObjectNode result, boolean reveal) {
+        String patternText = sub.path("pattern").asText("");
+        boolean ok = false;
+        if (!patternText.isBlank()) {
+            try {
+                Pattern pattern = Pattern.compile(patternText);
+                ok = true;
+                for (JsonNode s : array(p, "samples")) {
+                    boolean shouldMatch = s.path("shouldMatch").asBoolean(false);
+                    boolean matches = pattern.matcher(s.path("text").asText("")).matches();
+                    if (matches != shouldMatch) {
+                        ok = false;
+                        break;
+                    }
+                }
+            } catch (RuntimeException ex) {
+                result.put("error", "Ungültiges Regex-Muster.");
+                ok = false;
+            }
+        }
+        if (reveal && !ok && p.hasNonNull("pattern")) {
+            result.put("solution", p.get("pattern").asText());
+        }
+        return ok;
+    }
+
+    // ---------- Abschluss ----------
+
+    /** Schließt einen Durchlauf ab: Score wird aus den Eingaben recomputed und gespeichert. */
+    @Transactional
+    public DevLabResult finish(String username, DevLabFinishRequest request) {
+        int score = 0;
+        int maxScore = 0;
+        int solved = 0;
+        int total = 0;
+
+        if (request.getItems() != null) {
+            for (DevLabFinishRequest.Item item : request.getItems()) {
+                if (item.getTaskId() == null) {
+                    continue;
+                }
+                DevLabTask task = taskRepository.findById(item.getTaskId()).orElse(null);
+                if (task == null) {
+                    continue;
+                }
+                total++;
+                maxScore += task.getPoints();
+                JsonNode verdict = check(task.getId(), false, item.getSubmission());
+                if (verdict.path("correct").asBoolean(false) && !item.isRevealed()) {
+                    solved++;
+                    score += awardedPoints(task.getPoints(), item.getAttempts());
+                }
+            }
+        }
+
+        int stars = stars(score, maxScore);
+        int seconds = Math.max(request.getDurationSeconds(), 0);
+        String deck = request.getSlug() == null ? null : request.getSlug();
+        ScoreResult saved = gameScoreService.recordScore(username, GAME, deck, score, solved, seconds);
+        return new DevLabResult(score, maxScore, solved, total, stars,
+                saved.getHighscore(), saved.isNewHighscore(), saved.getPlays());
+    }
+
+    private int awardedPoints(int points, int attempts) {
+        int a = Math.max(1, attempts);
+        double factor = switch (a) {
+            case 1 -> 1.0;
+            case 2 -> 0.6;
+            default -> 0.3;
+        };
+        return (int) Math.round(points * factor);
+    }
+
+    private int stars(int score, int maxScore) {
+        if (maxScore <= 0 || score <= 0) {
+            return 0;
+        }
+        double ratio = (double) score / maxScore;
+        if (ratio >= 0.8) {
+            return 3;
+        }
+        if (ratio >= 0.5) {
+            return 2;
+        }
+        return 1;
+    }
+
+    // ---------- Admin ----------
+
+    @Transactional(readOnly = true)
+    public List<DevLabGameRow> gameRows() {
+        return gameRepository.findAllByOrderBySortOrderAscIdAsc().stream()
+                .map(g -> new DevLabGameRow(g.getId(), g.getSlug(), g.getTitle(), g.getLanguage(),
+                        g.getPath(), g.isActive(), taskRepository.countByGameId(g.getId())))
+                .toList();
+    }
+
+    @Transactional(readOnly = true)
+    public DevLabGame gameWithTasks(Long id) {
+        DevLabGame game = gameRepository.findById(id).orElse(null);
+        if (game != null) {
+            game.getTasks().size(); // lazy init
+        }
+        return game;
+    }
+
+    @Transactional
+    public Long createGame(String title, String language, String path, String description) {
+        if (title == null || title.isBlank()) {
+            return null;
+        }
+        String clean = title.trim();
+        int order = (int) gameRepository.count() + 1;
+        DevLabGame game = new DevLabGame(uniqueSlug(clean), clean, blankToNull(language),
+                normalizePath(path), blankToNull(description), order, true);
+        gameRepository.save(game);
+        return game.getId();
+    }
+
+    @Transactional
+    public void addTask(Long gameId, String type, String prompt, int points, String payload) {
+        if (type == null || prompt == null || prompt.isBlank()
+                || !KNOWN_TYPES.contains(type.trim()) || !isValidJson(payload)) {
+            return;
+        }
+        gameRepository.findById(gameId).ifPresent(game -> {
+            int sort = game.getTasks().size();
+            game.addTask(new DevLabTask(type.trim(), cap(prompt.trim(), 300), normalizePoints(points), sort, payload.trim()));
+            gameRepository.save(game);
+        });
+    }
+
+    @Transactional
+    public void updateTask(Long taskId, String prompt, int points, String payload) {
+        taskRepository.findById(taskId).ifPresent(task -> {
+            if (prompt != null && !prompt.isBlank()) {
+                task.setPrompt(cap(prompt.trim(), 300));
+            }
+            task.setPoints(normalizePoints(points));
+            if (isValidJson(payload)) {
+                task.setPayload(payload.trim());
+            }
+        });
+    }
+
+    @Transactional
+    public void deleteTask(Long taskId) {
+        taskRepository.deleteById(taskId);
+    }
+
+    @Transactional
+    public void deleteGame(Long gameId) {
+        gameRepository.deleteById(gameId);
+    }
+
+    @Transactional
+    public void toggleGame(Long gameId) {
+        gameRepository.findById(gameId).ifPresent(g -> g.setActive(!g.isActive()));
+    }
+
+    // ---------- Helfer ----------
+
+    private boolean isValidJson(String json) {
+        if (json == null || json.isBlank()) {
+            return false;
+        }
+        try {
+            return mapper.readTree(json).isObject();
+        } catch (Exception ex) {
+            return false;
+        }
+    }
+
+    private String blankToNull(String value) {
+        return (value == null || value.isBlank()) ? null : value.trim();
+    }
+
+    private String normalizePath(String path) {
+        if (path == null) {
+            return "syntax";
+        }
+        String p = path.trim().toLowerCase();
+        return KNOWN_PATHS.contains(p) ? p : "syntax";
+    }
+
+    private int normalizePoints(int points) {
+        return points <= 0 ? 100 : Math.min(1000, points);
+    }
+
+    private String cap(String value, int max) {
+        return value.length() <= max ? value : value.substring(0, max);
+    }
+
+    private String uniqueSlug(String title) {
+        String base = title.toLowerCase()
+                .replace("ä", "ae").replace("ö", "oe").replace("ü", "ue").replace("ß", "ss")
+                .replaceAll("[^a-z0-9]+", "-")
+                .replaceAll("(^-|-$)", "");
+        if (base.isBlank()) {
+            base = "game";
+        }
+        String slug = base;
+        int counter = 2;
+        while (gameRepository.existsBySlug(slug)) {
+            slug = base + "-" + counter++;
+        }
+        return slug;
+    }
+
+    private JsonNode parse(String json) {
+        if (json == null || json.isBlank()) {
+            return null;
+        }
+        try {
+            return mapper.readTree(json);
+        } catch (Exception ex) {
+            return null;
+        }
+    }
+
+    private static String normalize(String value) {
+        return value == null ? "" : value.trim().replaceAll("\\s+", " ");
+    }
+
+    private static boolean textEquals(String a, String b, boolean caseSensitive) {
+        String na = normalize(a);
+        String nb = normalize(b);
+        return caseSensitive ? na.equals(nb) : na.equalsIgnoreCase(nb);
+    }
+
+    private static boolean anyEquals(List<String> candidates, String value, boolean caseSensitive) {
+        if (value == null || normalize(value).isEmpty()) {
+            return false;
+        }
+        for (String candidate : candidates) {
+            if (textEquals(candidate, value, caseSensitive)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private Iterable<JsonNode> array(JsonNode node, String field) {
+        JsonNode arr = node == null ? null : node.get(field);
+        return (arr != null && arr.isArray()) ? arr : mapper.createArrayNode();
+    }
+
+    private List<String> stringList(JsonNode node, String field) {
+        List<String> out = new ArrayList<>();
+        for (JsonNode item : array(node, field)) {
+            out.add(item.asText(""));
+        }
+        return out;
+    }
+
+    private ArrayNode shuffledTextArray(List<String> texts) {
+        List<String> copy = new ArrayList<>(texts);
+        Collections.shuffle(copy, random);
+        ArrayNode arr = mapper.createArrayNode();
+        copy.forEach(arr::add);
+        return arr;
+    }
+
+    private void copyText(JsonNode source, ObjectNode target, String field) {
+        if (source.hasNonNull(field)) {
+            String value = source.get(field).asText();
+            if (!value.isEmpty()) {
+                target.put(field, value);
+            }
+        }
+    }
+}

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/SyntaxSagaService.java

@@ -0,0 +1,318 @@
+package com.example.mindflux.service;
+
+import com.example.mindflux.dto.*;
+import com.example.mindflux.model.SyntaxSagaGap;
+import com.example.mindflux.model.SyntaxSagaMission;
+import com.example.mindflux.model.SyntaxSagaSolution;
+import com.example.mindflux.repository.SyntaxSagaGapRepository;
+import com.example.mindflux.repository.SyntaxSagaMissionRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+/**
+ * Server-autoritative Logik für Syntax Saga: baut die Story (ohne Lösungen), prüft
+ * Eingaben serverseitig und berechnet den Score beim Abschluss neu. Wertung wandert
+ * über {@link GameScoreService} unter der Spiel-Kennung "syntax-saga" in die DB.
+ */
+@Service
+public class SyntaxSagaService {
+
+    private static final String GAME = "syntax-saga";
+    private static final Set<String> DIFFICULTIES = Set.of("junior", "professional", "senior");
+
+    private final SyntaxSagaMissionRepository missionRepository;
+    private final SyntaxSagaGapRepository gapRepository;
+    private final GameScoreService gameScoreService;
+
+    public SyntaxSagaService(SyntaxSagaMissionRepository missionRepository,
+                             SyntaxSagaGapRepository gapRepository,
+                             GameScoreService gameScoreService) {
+        this.missionRepository = missionRepository;
+        this.gapRepository = gapRepository;
+        this.gameScoreService = gameScoreService;
+    }
+
+    // ---------- Spieler ----------
+
+    /** Liefert die aktiven Missionen einer Stufe (oder stufenübergreifend) – ohne Lösungen. */
+    @Transactional(readOnly = true)
+    public SyntaxSagaStoryView buildStory(String difficulty) {
+        String diff = normalizeOrNull(difficulty);
+        List<SyntaxSagaMission> missions = (diff == null)
+                ? missionRepository.findAllByActiveTrueOrderBySortOrderAscIdAsc()
+                : missionRepository.findAllByActiveTrueAndDifficultyOrderBySortOrderAscIdAsc(diff);
+
+        List<SyntaxSagaStoryView.Mission> views = new ArrayList<>();
+        int maxScore = 0;
+        int totalGaps = 0;
+
+        for (SyntaxSagaMission mission : missions) {
+            if (mission.getGaps().isEmpty()) {
+                continue;
+            }
+            List<SyntaxSagaStoryView.Gap> gapViews = new ArrayList<>();
+            for (SyntaxSagaGap gap : mission.getGaps()) {
+                gapViews.add(new SyntaxSagaStoryView.Gap(
+                        gap.getPosition(), gap.getPoints(), gap.getHint(), gap.getPlaceholder()));
+                maxScore += gap.getPoints();
+                totalGaps++;
+            }
+            views.add(new SyntaxSagaStoryView.Mission(
+                    mission.getId(), mission.getTitle(), mission.getDifficulty(), mission.getLanguage(),
+                    mission.getNarrative(), mission.getDialog(), mission.getCodeTemplate(),
+                    mission.getSuccessText(), gapViews));
+        }
+        return new SyntaxSagaStoryView(diff == null ? "all" : diff, views, maxScore, totalGaps);
+    }
+
+    /** Prüft die getippten Lücken einer Mission serverseitig (Frontend kennt die Lösung nicht). */
+    @Transactional(readOnly = true)
+    public SyntaxSagaCheckResult check(SyntaxSagaCheckRequest request) {
+        List<SyntaxSagaCheckResult.GapVerdict> results = new ArrayList<>();
+        if (request == null || request.getMissionId() == null) {
+            return new SyntaxSagaCheckResult(false, results);
+        }
+        SyntaxSagaMission mission = missionRepository.findById(request.getMissionId()).orElse(null);
+        if (mission == null) {
+            return new SyntaxSagaCheckResult(false, results);
+        }
+
+        Map<Integer, String> typedByPosition = new HashMap<>();
+        if (request.getAnswers() != null) {
+            for (SyntaxSagaCheckRequest.GapAnswer answer : request.getAnswers()) {
+                typedByPosition.put(answer.getPosition(), answer.getText());
+            }
+        }
+
+        boolean allCorrect = true;
+        for (SyntaxSagaGap gap : mission.getGaps()) {
+            boolean correct = gap.matches(typedByPosition.get(gap.getPosition()));
+            if (!correct) {
+                allCorrect = false;
+            }
+            String solution = (request.isReveal() && !correct) ? gap.firstSolution() : null;
+            results.add(new SyntaxSagaCheckResult.GapVerdict(gap.getPosition(), correct, solution));
+        }
+        return new SyntaxSagaCheckResult(allCorrect, results);
+    }
+
+    /** Schließt einen Durchlauf ab: Score wird aus den tatsächlichen Eingaben recomputed und gespeichert. */
+    @Transactional
+    public SyntaxSagaResult finish(String username, SyntaxSagaFinishRequest request) {
+        int score = 0;
+        int maxScore = 0;
+        int solvedGaps = 0;
+        int totalGaps = 0;
+
+        Map<Long, SyntaxSagaMission> missionCache = new HashMap<>();
+
+        if (request.getGaps() != null) {
+            for (SyntaxSagaFinishRequest.FinishGap fg : request.getGaps()) {
+                if (fg.getMissionId() == null) {
+                    continue;
+                }
+                SyntaxSagaMission mission = missionCache.computeIfAbsent(
+                        fg.getMissionId(), id -> missionRepository.findById(id).orElse(null));
+                if (mission == null) {
+                    continue;
+                }
+                SyntaxSagaGap gap = gapByPosition(mission, fg.getPosition());
+                if (gap == null) {
+                    continue;
+                }
+                totalGaps++;
+                maxScore += gap.getPoints();
+
+                boolean correct = gap.matches(fg.getText());
+                if (correct && !fg.isRevealed()) {
+                    solvedGaps++;
+                    score += awardedPoints(gap.getPoints(), fg.getAttempts());
+                }
+            }
+        }
+
+        int stars = stars(score, maxScore);
+        int seconds = Math.max(request.getDurationSeconds(), 0);
+        String deck = normalizeOrNull(request.getDifficulty());
+        ScoreResult saved = gameScoreService.recordScore(
+                username, GAME, deck == null ? "all" : deck, score, solvedGaps, seconds);
+
+        return new SyntaxSagaResult(score, maxScore, solvedGaps, totalGaps, stars,
+                saved.getHighscore(), saved.isNewHighscore(), saved.getPlays());
+    }
+
+    private SyntaxSagaGap gapByPosition(SyntaxSagaMission mission, int position) {
+        for (SyntaxSagaGap gap : mission.getGaps()) {
+            if (gap.getPosition() == position) {
+                return gap;
+            }
+        }
+        return null;
+    }
+
+    /** Volle Punkte bei Erstversuch, weniger bei mehr Versuchen. */
+    private int awardedPoints(int points, int attempts) {
+        int a = Math.max(1, attempts);
+        double factor = switch (a) {
+            case 1 -> 1.0;
+            case 2 -> 0.6;
+            default -> 0.3;
+        };
+        return (int) Math.round(points * factor);
+    }
+
+    private int stars(int score, int maxScore) {
+        if (maxScore <= 0 || score <= 0) {
+            return 0;
+        }
+        double ratio = (double) score / maxScore;
+        if (ratio >= 0.8) {
+            return 3;
+        }
+        if (ratio >= 0.5) {
+            return 2;
+        }
+        return 1;
+    }
+
+    // ---------- Admin ----------
+
+    /** Leichte Übersicht: Missionen mit Lücken-Anzahl (lädt nicht alle Lücken). */
+    @Transactional(readOnly = true)
+    public List<SyntaxSagaMissionRow> missionRows() {
+        return missionRepository.findAllByOrderBySortOrderAscIdAsc().stream()
+                .map(m -> new SyntaxSagaMissionRow(m.getId(), m.getSlug(), m.getTitle(),
+                        m.getDifficulty(), m.isActive(), gapRepository.countByMissionId(m.getId())))
+                .toList();
+    }
+
+    /** Eine Mission inkl. Lücken und Lösungen (für die Detailseite). */
+    @Transactional(readOnly = true)
+    public SyntaxSagaMission missionWithGaps(Long id) {
+        SyntaxSagaMission mission = missionRepository.findById(id).orElse(null);
+        if (mission != null) {
+            mission.getGaps().forEach(g -> g.getSolutions().size()); // lazy init
+        }
+        return mission;
+    }
+
+    @Transactional
+    public Long createMission(String title, String difficulty, String narrative, String dialog,
+                              String language, String codeTemplate, String successText) {
+        if (title == null || title.isBlank() || codeTemplate == null || codeTemplate.isBlank()) {
+            return null;
+        }
+        String clean = title.trim();
+        int order = (int) missionRepository.count() + 1;
+        SyntaxSagaMission mission = new SyntaxSagaMission(
+                uniqueSlug(clean), clean, normalizeDifficulty(difficulty),
+                narrative == null ? "" : narrative.trim(),
+                blankToNull(dialog), blankToNull(language),
+                codeTemplate.trim(), blankToNull(successText), order, true);
+        missionRepository.save(mission);
+        return mission.getId();
+    }
+
+    @Transactional
+    public void updateMission(Long missionId, String title, String difficulty, String narrative,
+                              String dialog, String language, String codeTemplate, String successText) {
+        missionRepository.findById(missionId).ifPresent(m -> {
+            if (title != null && !title.isBlank()) {
+                m.setTitle(title.trim());
+            }
+            m.setDifficulty(normalizeDifficulty(difficulty));
+            m.setNarrative(narrative == null ? "" : narrative.trim());
+            m.setDialog(blankToNull(dialog));
+            m.setLanguage(blankToNull(language));
+            if (codeTemplate != null && !codeTemplate.isBlank()) {
+                m.setCodeTemplate(codeTemplate.trim());
+            }
+            m.setSuccessText(blankToNull(successText));
+        });
+    }
+
+    @Transactional
+    public void addGap(Long missionId, int position, int points, boolean caseSensitive,
+                       String hint, String placeholder, List<String> solutions) {
+        if (solutions == null) {
+            return;
+        }
+        missionRepository.findById(missionId).ifPresent(mission -> {
+            int pos = position > 0 ? position : mission.getGaps().size() + 1;
+            SyntaxSagaGap gap = new SyntaxSagaGap(
+                    pos, normalizePoints(points), caseSensitive, blankToNull(hint), blankToNull(placeholder));
+            int sort = 0;
+            for (String s : solutions) {
+                if (s != null && !s.isBlank()) {
+                    gap.addSolution(new SyntaxSagaSolution(s.trim(), sort++));
+                }
+            }
+            if (!gap.getSolutions().isEmpty()) {
+                mission.addGap(gap);
+                missionRepository.save(mission);
+            }
+        });
+    }
+
+    @Transactional
+    public void deleteGap(Long gapId) {
+        gapRepository.deleteById(gapId);
+    }
+
+    @Transactional
+    public void deleteMission(Long missionId) {
+        missionRepository.deleteById(missionId);
+    }
+
+    @Transactional
+    public void toggleMission(Long missionId) {
+        missionRepository.findById(missionId).ifPresent(m -> m.setActive(!m.isActive()));
+    }
+
+    // ---------- Helfer ----------
+
+    private int normalizePoints(int points) {
+        if (points <= 0) {
+            return 100;
+        }
+        return Math.min(1000, points);
+    }
+
+    private String normalizeDifficulty(String difficulty) {
+        if (difficulty == null) {
+            return "junior";
+        }
+        String x = difficulty.trim().toLowerCase();
+        return DIFFICULTIES.contains(x) ? x : "junior";
+    }
+
+    private String normalizeOrNull(String difficulty) {
+        if (difficulty == null || difficulty.isBlank()) {
+            return null;
+        }
+        String x = difficulty.trim().toLowerCase();
+        return DIFFICULTIES.contains(x) ? x : null;
+    }
+
+    private String blankToNull(String value) {
+        return (value == null || value.isBlank()) ? null : value.trim();
+    }
+
+    private String uniqueSlug(String title) {
+        String base = title.toLowerCase()
+                .replace("ä", "ae").replace("ö", "oe").replace("ü", "ue").replace("ß", "ss")
+                .replaceAll("[^a-z0-9]+", "-")
+                .replaceAll("(^-|-$)", "");
+        if (base.isBlank()) {
+            base = "mission";
+        }
+        String slug = base;
+        int counter = 2;
+        while (missionRepository.existsBySlug(slug)) {
+            slug = base + "-" + counter++;
+        }
+        return slug;
+    }
+}

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

@@ -1,19 +1,64 @@
 package com.example.mindflux.service;
 
 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]+$");
+
+    private final UserRepository userRepository;
+    private final GameScoreRepository gameScoreRepository;
+    private final AchievementRepository achievementRepository;
+    private final BCryptPasswordEncoder passwordEncoder;
+
+    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
@@ -22,7 +67,84 @@ public class UserServiceImpl implements UserService {
     }
 
     @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) {
+        // 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/V7__syntax_saga.sql

@@ -0,0 +1,38 @@
+-- Syntax Saga: interaktive IT-Geschichten mit Code-Lücken (Junior/Professional/Senior).
+-- Mission -> Lücken (eine oder mehrere je Codeblock) -> Lösungen (eine Lücke kann mehrere
+-- gültige Antworten haben). Inhalte DB-basiert und Admin-pflegbar; gefüllt per Seeder
+-- aus syntaxsaga/content.json. Server-autoritativ: Lösungen verlassen nie das Backend.
+
+CREATE TABLE syntax_saga_missions (
+    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,
+    narrative     VARCHAR(2000) NOT NULL,
+    dialog        VARCHAR(1000),
+    code_language VARCHAR(30),
+    code_template VARCHAR(2000) NOT NULL,
+    success_text  VARCHAR(2000),
+    sort_order    INT           NOT NULL DEFAULT 0,
+    active        BOOLEAN       NOT NULL DEFAULT TRUE
+);
+
+CREATE TABLE syntax_saga_gaps (
+    id             BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    mission_id     BIGINT  NOT NULL REFERENCES syntax_saga_missions (id) ON DELETE CASCADE,
+    gap_position   INT     NOT NULL,
+    points         INT     NOT NULL DEFAULT 100,
+    case_sensitive BOOLEAN NOT NULL DEFAULT TRUE,
+    hint           VARCHAR(500),
+    placeholder    VARCHAR(120)
+);
+
+CREATE TABLE syntax_saga_solutions (
+    id            BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    gap_id        BIGINT       NOT NULL REFERENCES syntax_saga_gaps (id) ON DELETE CASCADE,
+    solution_text VARCHAR(500) NOT NULL,
+    sort_order    INT          NOT NULL DEFAULT 0
+);
+
+CREATE INDEX idx_syntax_saga_gaps_mission  ON syntax_saga_gaps (mission_id);
+CREATE INDEX idx_syntax_saga_solutions_gap ON syntax_saga_solutions (gap_id);

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

@@ -0,0 +1,26 @@
+-- Dev Lab: Entwicklerlabor mit mehreren Spielmechaniken (cloze, choice, order, spot, match, regex).
+-- Spiel -> Aufgaben; je Aufgabe ein Typ + JSON-Payload (inkl. Lösung). Inhalte DB-basiert und
+-- Admin-pflegbar; server-autoritativ geprüft (Lösungen verlassen nie unverändert das Backend).
+
+CREATE TABLE devlab_games (
+    id            BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    slug          VARCHAR(150)  NOT NULL UNIQUE,
+    title         VARCHAR(200)  NOT NULL,
+    code_language VARCHAR(50),
+    lab_path      VARCHAR(50),
+    description   VARCHAR(1000),
+    sort_order    INT           NOT NULL DEFAULT 0,
+    active        BOOLEAN       NOT NULL DEFAULT TRUE
+);
+
+CREATE TABLE devlab_tasks (
+    id         BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    game_id    BIGINT        NOT NULL REFERENCES devlab_games (id) ON DELETE CASCADE,
+    task_type  VARCHAR(30)   NOT NULL,
+    prompt     VARCHAR(300)  NOT NULL,
+    points     INT           NOT NULL DEFAULT 100,
+    sort_order INT           NOT NULL DEFAULT 0,
+    payload    VARCHAR(8000) NOT NULL
+);
+
+CREATE INDEX idx_devlab_tasks_game ON devlab_tasks (game_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/auth.css

@@ -0,0 +1,143 @@
+/* Auth (Login/Signup) – kombiniertes Dual-Panel mit Neon-Buttons.
+   Bewusst als statische CSS-Datei: enthält @property mit '<angle>',
+   was im Thymeleaf-Inline-Style als HTML-Tag fehlinterpretiert würde. */
+
+/* Rotierender Winkel für den Conic-Gradient-Glow (Bild 1) */
+@property --mf-ang { syntax: '<angle>'; initial-value: 0deg; inherits: false; }
+
+.auth-stage { width:100%; display:flex; flex-direction:column; align-items:center; gap:1.4rem; }
+
+/* ---- Dual-Panel-Container (Bild 2) ---- */
+.auth-container {
+    position:relative; width:100%; max-width:840px; min-height:560px;
+    background:var(--surface); border:1px solid var(--border-accent);
+    border-radius:22px; box-shadow:0 0 44px var(--glow-w); overflow:hidden;
+}
+.form-box {
+    position:absolute; top:0; height:100%; width:50%;
+    display:flex; align-items:center; justify-content:center;
+    padding:2.4rem 2.6rem; transition:transform .65s ease-in-out, opacity .65s ease-in-out;
+}
+.form-box .inner { width:100%; max-width:320px; }
+.form-box.login  { left:0; z-index:2; }
+.form-box.signup { left:0; opacity:0; z-index:1; }
+
+.auth-container.active .form-box.login  { transform:translateX(100%); opacity:0; z-index:1; }
+.auth-container.active .form-box.signup { transform:translateX(100%); opacity:1; z-index:5; }
+
+/* ---- Überschiebendes Gradient-Overlay ---- */
+.overlay-container {
+    position:absolute; top:0; left:50%; width:50%; height:100%;
+    overflow:hidden; z-index:100; transition:transform .65s ease-in-out;
+    box-shadow: -1px 0 0 var(--border-accent), -26px 0 55px -30px var(--glow-s);
+}
+.auth-container.active .overlay-container { transform:translateX(-100%); }
+.overlay {
+    position:relative; left:-100%; width:200%; height:100%; transform:translateX(0);
+    transition:transform .65s ease-in-out;
+    background:
+        radial-gradient(540px 380px at 70% 22%, var(--glow-s), transparent 60%),
+        radial-gradient(420px 300px at 20% 90%, var(--glow-w), transparent 65%),
+        linear-gradient(150deg, var(--surface-2), var(--surface));
+}
+.auth-container.active .overlay { transform:translateX(50%); }
+.overlay-panel {
+    position:absolute; top:0; height:100%; width:50%;
+    display:flex; flex-direction:column; align-items:center; justify-content:center;
+    text-align:center; padding:0 2.4rem; color:var(--text);
+    transition:transform .65s ease-in-out;
+}
+.overlay-left  { transform:translateX(-18%); }
+.auth-container.active .overlay-left  { transform:translateX(0); }
+.overlay-right { right:0; transform:translateX(0); }
+.auth-container.active .overlay-right { transform:translateX(18%); }
+
+.overlay-panel .o-emblem {
+    width:56px; height:56px; background:var(--accent); margin-bottom:1rem;
+    -webkit-mask:url("/img/mindflux-emblem.png") center/contain no-repeat;
+            mask:url("/img/mindflux-emblem.png") center/contain no-repeat;
+    filter:drop-shadow(0 0 12px var(--glow-s));
+}
+.overlay-panel h3 { color:var(--heading); font-size:1.5rem; font-weight:800; margin-bottom:.6rem; letter-spacing:.01em; text-shadow:0 0 18px var(--glow-w); }
+.overlay-panel p  { color:var(--text); font-size:.9rem; line-height:1.65; margin-bottom:1.6rem; max-width:280px; }
+
+/* ---- Formularkopf ---- */
+.auth-head { text-align:center; margin-bottom:1.4rem; }
+.auth-head .mark {
+    width:52px; height:52px; margin:0 auto .55rem; background:var(--accent);
+    -webkit-mask:url("/img/mindflux-emblem.png") center/contain no-repeat;
+            mask:url("/img/mindflux-emblem.png") center/contain no-repeat;
+    filter:drop-shadow(0 0 12px var(--glow-s));
+}
+.auth-head b { display:block; color:var(--accent); font-weight:800; letter-spacing:.16em; font-size:1.05rem; text-shadow:0 0 14px var(--glow-s); }
+.auth-head h2 { color:var(--heading); font-size:1.35rem; font-weight:800; margin-top:.5rem; }
+.auth-head .sub { color:var(--muted); font-size:.82rem; margin-top:.2rem; }
+
+.mf-alert { padding:.6rem .8rem; border-radius:10px; font-size:.82rem; margin-bottom:.9rem; text-align:center; }
+.mf-alert.err { color:var(--danger); border:1px solid var(--danger); background:rgba(255,95,107,.08); }
+.mf-alert.ok  { color:var(--accent); border:1px solid var(--border-accent); background:var(--surface-2); }
+
+/* ---- Neon-Button mit Hover-Expand + rotierendem Conic-Glow (Bild 1) ---- */
+.neon-btn {
+    position:relative; z-index:0; width:100%; margin-top:.4rem;
+    display:inline-flex; align-items:center; justify-content:center; gap:.55rem;
+    padding:.85rem 1.3rem; border:0; border-radius:999px; cursor:pointer;
+    font-weight:800; font-size:.82rem; letter-spacing:.08em; text-transform:uppercase;
+    color:var(--accent-ink); background:var(--accent); box-shadow:0 0 18px var(--glow-s);
+    transition:transform .3s ease, letter-spacing .3s ease, box-shadow .3s ease;
+}
+.neon-btn::before {
+    content:""; position:absolute; inset:-3px; border-radius:inherit; z-index:-1;
+    background:conic-gradient(from var(--mf-ang),
+        var(--accent), var(--accent-2), var(--accent), var(--accent-2), var(--accent));
+    filter:blur(9px); opacity:0; transition:opacity .35s ease;
+    animation:mf-spin 4s linear infinite;
+}
+.neon-btn:hover { transform:translateY(-2px); letter-spacing:.16em; box-shadow:0 0 28px var(--glow-s); }
+.neon-btn:hover::before { opacity:.9; }
+.neon-btn:focus-visible { outline:2px solid var(--accent-2); outline-offset:3px; }
+.neon-btn .lock { font-size:.95em; }
+@keyframes mf-spin { to { --mf-ang:360deg; } }
+
+/* Outline-Variante für die Overlay-Buttons (auf Gradient) */
+.ghost-btn {
+    display:inline-flex; align-items:center; justify-content:center; gap:.5rem;
+    padding:.75rem 1.8rem; border-radius:999px; cursor:pointer; font-weight:800;
+    font-size:.8rem; letter-spacing:.1em; text-transform:uppercase;
+    background:transparent; color:var(--accent); border:2px solid var(--border-accent);
+    box-shadow:0 0 16px var(--glow-w);
+    transition:transform .25s ease, background .25s ease, box-shadow .25s ease;
+}
+.ghost-btn:hover { transform:translateY(-2px); background:var(--surface-2); box-shadow:0 0 22px var(--glow-s); }
+
+/* ---- Light-Mode: Overlay als kräftiges Orange-Panel mit weißem Text ----
+   (im Dark-Mode ist das Overlay ein dunkles Panel mit Glow; im Light-Mode
+   wären die Surface-Töne weiß -> Panel verschwände. Daher hier farbig.) */
+[data-theme="light"] .overlay {
+  background:
+    radial-gradient(600px 340px at 28% 6%, rgba(255,255,255,.18), transparent 60%),
+    linear-gradient(150deg, var(--accent-2), var(--accent) 48%);
+}
+[data-theme="light"] .overlay-panel { color:#fff; }
+[data-theme="light"] .overlay-panel h3 { color:#fff; text-shadow:0 1px 12px rgba(0,0,0,.22); }
+[data-theme="light"] .overlay-panel p  { color:#fff; opacity:.96; }
+[data-theme="light"] .overlay-panel .o-emblem { background:#fff; filter:drop-shadow(0 0 10px rgba(0,0,0,.25)); }
+[data-theme="light"] .ghost-btn { color:#fff; border-color:rgba(255,255,255,.9); box-shadow:none; }
+[data-theme="light"] .ghost-btn:hover { background:rgba(255,255,255,.18); box-shadow:none; }
+
+.mobile-switch { display:none; text-align:center; margin-top:1.2rem; color:var(--muted); font-size:.84rem; }
+.mobile-switch a { color:var(--accent); font-weight:700; text-decoration:none; cursor:pointer; }
+
+/* ---- Responsiv: gestapelt, ohne Overlay ---- */
+@media (max-width:760px) {
+    .auth-container { max-width:420px; min-height:auto; }
+    .overlay-container { display:none; }
+    .form-box {
+        position:relative; width:100%; padding:2rem 1.6rem;
+        transform:none !important; opacity:1 !important; transition:none;
+    }
+    .form-box.signup { display:none; }
+    .auth-container.active .form-box.login  { display:none; }
+    .auth-container.active .form-box.signup { display:flex; }
+    .mobile-switch { display:block; }
+}