19 Commits
Author SHA1 Message Date
gartmaflorin 8271a88bf1 Merge pull request 'add-frontend-code-comments' (#11) from add-frontend-code-comments into main
Reviewed-on: #11
2026-06-09 18:37:21 +02:00
Trompi001 3d606a1a3d docs: Add detailed German comments to HTML templates 2026-06-09 18:21:46 +02:00
Trompi001 8aed9d5346 docs: Add comprehensive German comments to frontend codebase 2026-06-09 18:13:24 +02:00
Trompi001 9beec6e113 update team role 2026-06-09 18:04:10 +02:00
joostadrian 5c16f7296a Merge pull request 'impressum' (#10) from impressum into main
Reviewed-on: #10
2026-06-01 21:20:43 +02:00
Adrian Joost 447b12bed1 merge main into impressum, manual conflict resolve in custom.css 2026-06-01 21:17:43 +02:00
joostadrian 28335b32a6 Merge pull request 'message_challenges' (#9) from message_challenges into main
Reviewed-on: #9
2026-05-31 17:47:09 +02:00
DST81 96175ae699 Annpassung challenge-Logik, beide Spieler erhalten den selben Text 2026-05-31 14:53:16 +02:00
DST81 5199b32471 Challenge-Logik überarbeitet und fertig gestellt 2026-05-28 15:22:35 +02:00
Trompi001 909eb97bbb update styling 2026-05-25 17:41:51 +02:00
Trompi001 2d51443c94 Notifications only visible when logged in 2026-05-25 17:25:11 +02:00
Trompi001 6eaaa8d555 Update play.js to track input duration and adjust score timing 2026-05-25 16:09:47 +02:00
Trompi001 73c60f949d Add description paragraph to leaderboard section 2026-05-25 15:41:21 +02:00
Trompi001 cf4a07e4d0 add Meine Scores 2026-05-25 15:39:48 +02:00
DST81 be451f36ce Improve Challenge-Logik... aber noch nicht fertig 2026-05-25 13:25:34 +02:00
Trompi001 c060590a4a update Backend API 2026-05-25 11:55:54 +02:00
Trompi001 2488859dbf Update README so that it meets the evaluation criteria 2026-05-24 20:20:13 +02:00
DST81 c533198c38 Add Message/Challenge-Logik 2026-05-23 16:17:57 +02:00
DST81 cf36809d28 kleine Anpassungen css 2026-05-17 15:46:46 +02:00
26 changed files with 3802 additions and 149 deletions

No files matched your search

+417 -15
View File
@@ -1,22 +1,424 @@
# lorem_ipsum
# Lorem Ipsum – Memory Game Webanwendung
## Inhaltsverzeichnis
- [Projektbeschreibung](#projektbeschreibung)
- [Anforderungen & Features](#anforderungen--features)
- [Installation & Setup](#installation--setup)
- [Verwendung](#verwendung)
- [Projektstruktur](#projektstruktur)
- [Technologie-Stack](#technologie-stack)
- [Architektur & Technische Entscheidungen](#architektur--technische-entscheidungen)
- [Sicherheit](#sicherheit)
- [KI-Werkzeuge & deren Einsatz](#ki-werkzeuge--deren-einsatz)
- [Herausforderungen & Lerneffekte](#herausforderungen--lerneffekte)
- [Team](#team)
---
## Projektbeschreibung
Das Projekt Lorem Ipsum ist ein kleines Spiel, bei dem ein User einen Text für eine gewisse Zeit angezeigt bekommt. Der User soll sich in dieser Zeit möglichst viel des Textes auswendig merken. Nach Ablauf der Zeit kann der Nutzer den Text in einem Feld eingeben. Er oder sie erhält Punkte entsprechend dem, wieviele Wörter richtig eingetippt wurden.
Der User kann seinen Score auf ein globales Leaderboard hochladen und sich mit anderen Usern vergleichen. Der User kann sich eine Top10 Tabelle des globalen Leaderboards anzeigen lassen.
**Lorem Ipsum** ist eine interaktive Webanwendung, die das Kurzzeitgedächtnis trainiert. Nutzer werden mit zufälligen Texten präsentiert, die sie sich innerhalb einer definierten Zeitspanne einprägen müssen. Nach Ablauf der Zeit reproduzieren sie den Text so akkurat wie möglich. Das System bewertet die Leistung durch Wort-für-Wort-Vergleich und vergibt Punkte.
## Features
- Ein User kann sich einen Account anlegen. und erhält dann ein Zugangspasswort.
- Ein User kann in seinem Namen erspielte Scores submitten.
- Ein User kann das Spiel spielen.
- Ein User kann sich all seine Scores anzeigen lassen.
- Ein User kann das globale Leaderboard anschauen.
Die Anwendung ermöglicht soziale Interaktion durch ein globales Leaderboard, auf dem Nutzer ihre Scores veröffentlichen und sich mit anderen Spielern vergleichen können.
## Technologieen
Als CSS Framework wird Bootstrap 5.3.8 verwendet.
---
## Gruppenmitglieder
## Anforderungen & Features
* Florin Gartmann
* Daniela Studer-Müller
* Adrian Joost
### Funktionale Anforderungen
| Feature | Beschreibung |
|---------|-------------|
| **Benutzerverwaltung** | Benutzer können ein Konto erstellen und erhalten ein eindeutiges Passwort |
| **Spielmechanik** | Zufällige Texte werden angezeigt und müssen nach Ablauf einer Zeitspanne reproduziert werden |
| **Score-System** | Automatische Bewertung basierend auf korrekt eingegebenen Wörtern mit Punkt-Vergabe |
| **Persönliche Scores** | Nutzer können alle ihre bisherigen Scores ansehen und verwalten |
| **Globales Leaderboard** | Echtzeit-Anzeige der Top 10 Spieler mit ihren besten Scores |
| **Nachrichten-System** | Nutzer können sich gegenseitig Nachrichten/Challenges schreiben |
---
## Installation & Setup
### Voraussetzungen
- Moderner Webbrowser (Chrome, Firefox, Safari, Edge)
- Node.js (optional, nur für lokale Backend-Entwicklung)
- Zugriff auf die Backend-API (`config-service.js` für API-Konfiguration)
### Schnellstart
```bash
# 1. Repository klonen
git clone <repository-url>
cd lorem_ipsum
# 2. Abhängigkeiten installieren (falls Backend vorhanden)
npm install
# 3. Applikation starten
# Option A: Mit Live-Server (VS Code Extension)
# Rechtsklick auf index.html → "Open with Live Server"
# Option B: Mit Python (falls vorhanden)
python -m http.server 8000
# Dann öffnen: http://localhost:8000
# Option C: Mit Node.js
npx http-server
```
### Backend-Konfiguration
Die API-Endpoints sind in `assets/src/service/config-service.js` konfiguriert:
```javascript
// config-service.js
export const API_BASE_URL = "https://api.example.com";
export const API_VERSION = "v1";
```
---
## Verwendung
### Für neue Benutzer
1. **Account erstellen**: Auf der Startseite auf "Registrieren" klicken
2. **Login**: Mit dem erhaltenen Passwort anmelden
3. **Spiel spielen**: "Spiel Starten" wählen
- Text wird 15 Sekunden lang angezeigt
- Nach Ablauf Text reproduzieren
- Automatische Bewertung wird angezeigt
4. **Scores verwalten**: Persönliche Scores einsehen und ggf. auf Leaderboard hochladen
5. **Leaderboard**: Top 10 Spieler in Echtzeit betrachten
6. **Nachrichten**: Mit anderen Spielern kommunizieren oder Challenges stellen
### Beispiel-Workflows
**Workflow 1: Account erstellen**
```
Home → Login/Registrieren → Username eingeben → Username und Passwort speichern
```
**Workflow 2: Leaderboard ansehen**
```
Home → Leaderboard → Top 10 wird geladen und angezeigt
```
---
## Projektstruktur
```
lorem_ipsum/
├── index.html # Startseite
├── README.md # Dokumentation (diese Datei)
├── pages/
│ ├── login.html # Login/Registrierung
│ ├── home.html # Startseite nach Login
│ ├── play.html # Spielseite
│ ├── scores.html # Persönliche Scores
│ ├── leaderboard.html # Globales Leaderboard
│ └── messages.html # Nachrichts-/Challenge-System
├── js/
│ ├── login.js # Login-Logik & Event-Handler
│ ├── play.js # Spiel-Logik (Timer, Text-Vergleich)
│ ├── leaderboard.js # Leaderboard-Rendering
│ ├── navigation.js # Navigations-Controls
│ └── messages.js # Nachrichten-Funktionalität
├── assets/
│ ├── css/
│ │ └── custom.css # Custom-Styles
│ ├── src/
│ │ ├── service/
│ │ │ ├── user-service.js # User-API-Aufrufe (Login, Register)
│ │ │ ├── leaderboard-service.js # Leaderboard-API-Aufrufe
│ │ │ ├── score-service.js # Score-Management
│ │ │ ├── message-service.js # Nachrichten-API
│ │ │ ├── challenge-service.js # Challenge-API
│ │ │ └── config-service.js # API-Konfiguration & Konstanten
│ │ └── sites/
│ │ └── exampleAPI.js # API-Test/Beispiel
│ └── bootstrap-5.3.8-dist/ # Bootstrap Framework (v5.3.8)
└── pages/
└── [weitere Pages wie oben]
```
### Dateibenennungs-Konventionen
- **HTML-Dateien**: `kebab-case` (z.B. `login.html`, `play.html`)
- **JavaScript-Dateien**: `kebab-case` (z.B. `login.js`, `play.js`, `user-service.js`)
- **Service-Dateien**: Suffix `-service.js` (z.B. `score-service.js`, `leaderboard-service.js`)
- **CSS-Klassen**: Bootstrap-Utilities + Custom Selektoren; BEM bei komplexen Komponenten (z.B. `.play-challenge-result__title`)
---
## Technologie-Stack
| Layer | Technologie | Version | Begründung |
|-------|-------------|---------|-----------|
| **Markup** | HTML5 | 5 | Semantische Struktur, barrierefreundlich |
| **Styling** | Bootstrap CSS | 5.3.8 | Responsive Grid, vordefinierte Komponenten, Accessibility |
| **Custom CSS** | CSS3 | - | Flexbox/Grid für Layout-Feinheiten, Custom Properties |
| **Frontend-Logik** | Vanilla JavaScript | ES6+ | Keine externen Abhängigkeiten nötig, vollständige Kontrolle |
| **API-Kommunikation** | Fetch API | - | Modern, Promise-basiert, Error-Handling via try/catch |
| **Versionsverwaltung** | Git | - | Nachvollziehbarer Entwicklungsverlauf |
### Warum Vanilla JS statt Framework?
- Projekt-Anforderungen sind moderat (keine komplexe State-Verwaltung nötig)
- Fetch API mit async/await bietet ausreichende Abstraktionen
- Schnellere Ladezeiten ohne Framework-Overhead
- Volles Verständnis über den Code ohne "Black Box"-Effekte
### Warum Bootstrap?
- Responsive Design out-of-the-box (12er Grid-System)
- Umfangreiches Komponenten-Portfolio (Modals, Forms, Cards)
- WCAG Level A Compliance bereits implementiert
- Konsistentes Design über alle Seiten hinweg
---
## Architektur & Technische Entscheidungen
### Service-orientierte Architektur
Die Anwendung folgt einer **Service-orientierten Architektur**:
```
UI Layer (HTML/CSS)
↓
Event Handler (login.js, play.js, ...)
↓
Service Layer (user-service.js, score-service.js, ...)
↓
Fetch API → Backend REST API
```
**Vorteile:**
- **Separation of Concerns**: Jeder Service hat eine klare Verantwortung
- **Wiederverwendbarkeit**: Services können von mehreren Seiten genutzt werden
- **Testbarkeit**: Services können isoliert getestet werden
- **Wartbarkeit**: API-Änderungen erfordern nur Anpassung in einem Ort
### Datenfluss beim Spielen
```javascript
1. play.js: generateGameText() // Zufälligen Text lokal generieren
2. play.js: Timer starten (15s)
3. User tippt Text ein
4. play.js: Wort-für-Wort-Vergleich nach Position
5. score-service.postScore() // Score zum Server senden
6. UI zeigt Ergebnis sofort an, Speichern läuft asynchron
```
### Authentifizierungs-Design
**Besonderheit: Backend generiert Passwörter statt User-Input**
```
Konventionell (problematisch): Unser Ansatz (bewusst gewählt):
User gibt Passwort ein → Backend generiert zufälliges Passwort
Risiko: User nimmt häufig genutztes → Keine Passwort-Reuse-Gefahr
Passwort → Für diese Session gültig
```
**Begründung dieser Entscheidung:**
1. **Sicherheitsausrichtung**: Nutzer gefährden kein häufig genutztes Passwort (Lernaspekt: User-Sicherheit)
2. **Frontend-Fokus**: Komplexe Auth-Logik (Hashing, Salting) sind nicht im scope dieses Moduls
3. **Transparenz**: Diese Limitierung ist im Code und README dokumentiert – nicht versteckt
**Konsequenzen für OWASP:**
- ⚠️ localStorage speichert plaintext-Passwort (A07:2021 – nicht konform)
- ✅ Aber: Generierte Passwörter sind Wegwerf-Token, kein häufig genutztes Passwort
### HTML5 Semantik
Alle HTML-Dateien nutzen semantisch korrekte Elemente:
```html
<header> <!-- Navigation und Kopfzeile -->
<main>
<section> <!-- Logische Abschnitte -->
<article> <!-- Spielinhalte -->
<form> <!-- Benutzer-Input -->
<footer> <!-- Impressum, Credits -->
```
---
## Sicherheit
### OWASP-Risiken im Kontext dieser Anwendung
#### 1. **Cross-Site Scripting (XSS)** – A03:2021
**Risiko**: Nutzer-Input (Scores, Nachrichten) könnte als Code interpretiert werden
**Implementierte Maßnahmen:**
```javascript
// ✅ SICHER: Text-Encoding statt HTML-Parsing
const scoreElement = document.createElement('div');
scoreElement.textContent = userScore; // textContent encodiert automatisch
// ❌ NICHT SICHER: scoreElement.innerHTML = userScore
// ✅ SICHER: Template Literals mit textContent
const formattedScore = `User: ${userName}`; // nie mit innerHTML
```
**Begründung**: `textContent` und DOM-APIs encodieren automatisch; `innerHTML` mit Benutzerdaten ist ein XSS-Vektor.
#### 2. **Authentifizierung & Session-Management** – A07:2021
**Risiko**: Passwort-Speicherung im localStorage, plaintext-Übertragung als Custom-Header
**Implementierte Maßnahmen:**
- ✅ API nutzt HTTPS (TLS-Verschlüsselung für Übertragung)
- ✅ localStorage mit Auth-Daten nur clientseitig (nicht persistent auf Server)
**OWASP-Perspektive – nicht konform:**
```javascript
// ❌ Passwort unverschlüsselt im localStorage
localStorage.setItem('auth', JSON.stringify({
username: user,
password: generatedPassword
}));
// ✅ Produktiv würde man verwenden:
// - HTTP-Only Cookies (vom Server gesetzt, nicht via JS zugreifbar)
// - JWT mit Refresh-Token-Rotation
// - OAuth 2.0 / OpenID Connect
```
**Begründung dieser Limitierung**: Siehe Abschnitt [Authentifizierungs-Design](#authentifizierungs-design) in der Architektur. Die Designentscheidung, dass das Backend Passwörter generiert, minimiert das Reuse-Risiko. Auth-Komplexität ist Backend-Responsibility.
---
## KI-Werkzeuge & deren Einsatz
### ChatGPT / Claude – Code-Review & Debugging
**Einsatzbereiche:**
- Fehlersuche in asynchronen Promise-Ketten
- Code-Style-Verbesserungen (ES6+ Best Practices)
- Regex-Optimierungen für Text-Vergleich
- Generierung visueller Assets: Logo, Icon sowie Challenge-Grafiken für Gewonnen/Verloren/Unentschieden wurden mit ChatGPT erstellt und anschließend im Projekt eingebunden
**Kritische Bewertung:**
- ✅ **Effektiv für**: Schnelle Fehlerbehebung, Best-Practice-Vorschläge
- ⚠️ **Vorsicht**: KI-Vorschläge nicht blind übernehmen, Logik selbst verstehen
- ✅ **Angewendet**: Alle KI-Vorschläge wurden auf Korrektheit geprüft
### GitHub Copilot – Auto-Completion
**Einsatzbereiche:**
- Service-Boilerplate-Code (Fetch-Aufrufe, Error-Handling)
- Wiederholte DOM-Manipulationen
**Kritische Bewertung:**
- ✅ **Hilfreich für**: Reduktion von Boilerplate-Code
- ⚠️ **Problematisch**: Code-Qualität variiert, manchmal ineffiziente Patterns
- ✅ **Angewendet**: Nur nach manueller Prüfung und Refactoring integriert
---
## Herausforderungen & Lerneffekte
### 🔴 Herausforderungen
#### 1. **Text-Vergleich mit Sonderzeichen**
**Problem**: Unterschiedliche Behandlung von Umlauten, Leerzeichen, Satzzeichen
```
Original: "Café"
User-Input: "cafe" // Accent wird nicht erkannt
```
**Lösung**:
- Normalisierung mit `String.prototype.normalize('NFD')`
- Regelwerk für Sonderzeichen-Ignorieren
- **Gelernt**: Unicode-Handling in JavaScript ist komplex
#### 2. **Asynchrone State-Verwaltung**
**Problem**: Race-Conditions bei mehreren parallelen API-Calls
```javascript
// ❌ PROBLEMATISCH
const data1 = fetch('/users'); // Promise 1
const data2 = fetch('/scores'); // Promise 2
// Welche Promise löst sich zuerst auf?
```
**Lösung**:
- `Promise.all()` für parallele Aufrufe
- `async/await` für sequenzielle Aufrufe
- Globale Loading-States um UI zu synchronisieren
- **Gelernt**: Promise-Sequenzierung ist essentiell für konsistente UI
#### 3. **Responsive Design auf mobilen Geräten**
**Problem**: Bootstrap Grid bricht bei sehr kleinen Viewports zusammen
**Lösung**:
- Custom Breakpoints mit CSS Media Queries
- Flexbox für flexible Card-Layouts
- Touch-friendly Button-Größen (min 44x44px)
- **Gelernt**: Mobile-first Approach hätte von Anfang an helfen sollen
### 🟢 Lerneffekte
| Bereich | Erkenntnis |
|---------|-----------|
| **Fetch API & Error-Handling** | `try/catch` bei Async/Await ist unmissbar; HTTP 400/500 Responses sind nicht automatisch Exceptions |
| **DOM-Manipulation** | Event-Delegation spart Code; `querySelector` ist ausreichend für diese Projekt-Größe |
| **State Management** | Ohne centralized Store (Redux, Vuex) führt komplexe State schnell zu Bugs; globale Variablen sind anfällig |
| **Git Workflow** | Feature-Branches + aussagekräftige Commit-Messages machen Debugging später viel einfacher |
| **Accessibility** | WCAG nicht als "nice-to-have" sehen; frühe Integration spart viel Refactoring |
| **Testing-Ansatz** | Manuelles Testen auf mehreren Browsern/Geräten ist zeitaufwendig; automatisierte Tests würden helfen |
### 💡 Was würde anders gemacht werden
1. **Service Layer von Anfang an**: Hätte API-Changes sehr vereinfacht
2. **TypeScript**: Würde viele Typo-Fehler early-stage finden
3. **Unit-Tests**: Für Score-Logik und Text-Vergleich empfohlen
4. **CSS-Präprozessor** (SASS): Für komplexere Styling-Szenarien hilfreich
---
## Code-Kommentierung & Qualität
### Kommentierung-Standard
```javascript
// ✅ KURZ & AUSSAGEKRÄFTIG (bevorzugt)
// Vergleiche Texte zeichenweise und zähle korrekte Wörter
function compareTexts(original, userInput) { ... }
// ❌ ÜBERFLÜSSIG (code ist selbsterklärend)
// Inkrementiere counter um 1
counter++;
// ⚠️ NUR FÜR NON-OFFENSICHTLICHES
// Normalisiere Unicode-Sequenzen, da Nutzer-Input oft Umlaute enthält (z.B. "Café")
const normalized = str.normalize('NFD');
```
### Naming-Konventionen
- Funktionen: **Verb + Substantiv** → `getRandomText()`, `compareScores()`
- Variablen: **aussagekräftig** → `userInputText` (nicht `txt` oder `u`)
- Konstanten: **UPPER_SNAKE_CASE** → `MAX_TEXT_LENGTH = 5000`
- Private Funktionen: **Prefix `_`** → `_calculateScore()` (Convention only)
---
## Team
| Name | Rolle & Verantwortungsbereich |
|------|-------------------------------|
| *Adrian Joost* | *Projektleitung & Architektur*: Gesamtüberblick, Projektinitialisierung, Definition der Schnittstellen sowie Analyse von Sicherheitslücken und Edge-Cases (inkl. „Cheating“-Szenarien). |
| *Daniela Studer-Müller* | *Core-Game-Logic*: Implementierung der Spielmechanik, Text-Generierung sowie Entwicklung der Message- und Challenge-Logik. |
| *Florin Gartmann* | *Score-System & Ranking*: Entwicklung der Bewertungslogik (Scoring-Algorithmus) und Implementierung des globalen Leaderboards. |
---
## Lizenz
Dieses Projekt ist für Ausbildungszwecke entwickelt worden.
---
## Weitere Ressourcen
- [Bootstrap 5 Dokumentation](https://getbootstrap.com/docs/5.3/)
- [MDN: Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
- [OWASP Top 10](https://owasp.org/www-project-top-ten/)
**Zuletzt aktualisiert:** 2026-05-24
+303 -7
View File
@@ -14,13 +14,15 @@ body {
}
.navbar .nav-link {
color: #fff;
transition: color 0.3s, background-color 0.3s;
transition: color 0.3s, background-color 0.3s, border-color 0.3s;
margin: 0 5px;
border: 2px solid transparent;
border-radius: 6px;
}
.navbar .nav-link:hover {
background-color: #ffd166;
background-color: rgba(255, 209, 102, 0.7);
color: #1b1b2f;
border-radius: 6px;
border-color: rgba(255, 209, 102, 0.9);
padding: 5px 10px;
}
@@ -28,10 +30,38 @@ body {
background-color: #ffd166;
color: #1b1b2f;
font-weight: bold;
border: 2px solid #ffd166;
border-radius: 6px;
padding: 5px 10px;
}
.navbar .nav-link.has-unread-messages {
background-color: #dc3545;
color: #ffffff;
font-weight: bold;
border: 2px solid #ffd166;
border-radius: 6px;
padding: 5px 10px;
}
.navbar .nav-link.has-unread-messages {
background-color: #dc3545;
color: #ffffff;
font-weight: bold;
border-radius: 6px;
padding: 5px 10px;
}
.navbar .nav-link.has-unread-messages::after {
content: "";
display: inline-block;
width: 8px;
height: 8px;
margin-left: 8px;
border-radius: 50%;
background: #ffffff;
}
/* Main content styles */
.container-dashboard {
flex-wrap: wrap;
@@ -45,9 +75,7 @@ body {
border-radius: 12px;
box-shadow: 0 4px 15px rgba(0,0,0,0.1);
padding: 25px;
font-size: 30px;
flex: 1 1 100%;
text-align: center;
transition: transform 0.3s, box-shadow 0.3s;
}
.container > div:not(.modal):hover {
@@ -93,6 +121,13 @@ p {
.btn:hover {
background-color: #2b4a7c;
}
.btn:disabled,
.btn.disabled {
background-color: #adb5bd;
color: #495057;
cursor: not-allowed;
opacity: 1;
}
.btn-danger {
background-color: #a84848;
color: #fff;
@@ -121,19 +156,23 @@ p {
}
#sidebar .nav-link {
margin: 0.5rem 0;
transition: color 0.3s, background-color 0.3s;
transition: color 0.3s, background-color 0.3s, border-color 0.3s;
color: white;
padding: 5px 10px;
border-radius: 6x;
border: 2px solid transparent;
border-radius: 6px;
}
#sidebar .nav-link:hover {
color: #1b1b2f;
background-color: rgba(255, 209, 102, 0.7);
border-color: rgba(255, 209, 102, 0.9);
border-radius: 6px;
}
#sidebar .nav-link.active {
color: #1b1b2f;
font-weight: bold;
background-color: #ffd166;
border: 2px solid #ffd166;
border-radius: 6px;
padding: 5px 10px;
}
@@ -220,6 +259,7 @@ p {
background: #ffffff;
border-radius: 10px;
overflow: hidden;
font-size: 1rem;
}
.leaderboard-table th,
@@ -227,6 +267,7 @@ p {
padding: 8px;
text-align: left;
border-bottom: 1px solid #ddd;
font-size: 16px;
}
.leaderboard-table thead th {
@@ -277,3 +318,258 @@ p {
.leaderboard-table tbody tr:last-child td {
border-bottom: none;
}
/* Messages */
.container > .messages-card:not(.modal),
.messages-card {
text-align: left;
font-size: 1rem;
}
.container > .messages-card:not(.modal):hover,
.messages-card:hover {
transform: none;
}
.messages-header,
.messages-inbox-title {
display: flex;
align-items: center;
justify-content: space-between;
gap: 1rem;
}
.messages-panel {
background: #f8f9fa;
border: 1px solid #dbe3ef;
border-radius: 8px;
padding: 18px;
}
.messages-panel h3 {
font-size: 1.1rem;
margin: 0 0 14px;
}
.messages-user-list {
display: grid;
gap: 10px;
}
.messages-user-button {
width: 100%;
border: 1px solid #c9d6e8;
border-radius: 6px;
background: #ffffff;
color: #1b1b2f;
padding: 10px 12px;
text-align: left;
transition: background-color 0.2s, border-color 0.2s;
}
.messages-user-button:hover {
background: #e8f0fb;
border-color: #4a6fa5;
}
.message-form textarea {
resize: vertical;
}
.message-list {
display: grid;
gap: 12px;
}
.message-item {
border-left: 4px solid #4a6fa5;
border-radius: 8px;
background: #ffffff;
padding: 12px 14px;
}
.message-item-unread {
border-left-color: #dc3545;
background: #fff4f4;
}
.challenge-message-group {
border-left-color: #6f7fb7;
}
.challenge-thread {
display: grid;
gap: 8px;
margin-top: 12px;
border-top: 1px solid #e5e7eb;
padding-top: 10px;
}
.challenge-thread.d-none {
display: none;
}
.challenge-thread-toggle {
border: none;
background: transparent;
color: #4a6fa5;
display: inline-flex;
font-size: 0.9rem;
font-weight: 600;
margin-top: 10px;
padding: 0;
}
.challenge-thread-toggle:hover {
color: #2b4a7c;
text-decoration: underline;
}
.challenge-thread-item {
border-radius: 6px;
background: #f8fafc;
padding: 8px 10px;
}
.challenge-thread-item span {
display: block;
color: #64748b;
font-size: 0.82rem;
margin-bottom: 4px;
}
.message-meta {
display: flex;
justify-content: space-between;
gap: 1rem;
color: #1b1b2f;
font-size: 0.9rem;
margin-bottom: 8px;
}
.message-meta span,
.messages-empty {
color: #667085;
}
.message-item p,
.messages-empty {
margin: 0;
}
.challenge-status-button:disabled {
background-color: #e5e7eb;
border: 1px solid #cbd5e1;
color: #64748b;
}
.challenge-result-graphic,
.play-challenge-result {
margin-top: 12px;
border-radius: 8px;
border: 1px solid #dbe3ef;
background: #ffffff;
overflow: hidden;
}
.challenge-result-headline,
.play-challenge-result-title {
padding: 10px 14px;
font-weight: 700;
color: #ffffff;
}
.challenge-outcome {
align-items: center;
background: #f8fafc;
display: flex;
gap: 12px;
padding: 14px;
}
.challenge-outcome img {
border-radius: 8px;
height: 72px;
object-fit: cover;
width: 72px;
}
.challenge-outcome strong {
color: #1b1b2f;
font-size: 1.5rem;
}
.challenge-outcome-win {
background: #e8f7ee;
}
.challenge-outcome-loss {
background: #fdecec;
}
.challenge-outcome-draw {
background: #eef3fb;
}
.challenge-result-win,
.play-challenge-result-winner .play-challenge-result-title {
background: #198754;
}
.challenge-result-draw,
.play-challenge-result-draw .play-challenge-result-title {
background: #4a6fa5;
}
.play-challenge-result-loser .play-challenge-result-title {
background: #a84848;
}
.challenge-result-scores,
.play-challenge-result-scores {
display: grid;
grid-template-columns: repeat(2, minmax(0, 1fr));
gap: 1px;
background: #dbe3ef;
}
.challenge-result-score,
.play-challenge-result-score {
display: grid;
gap: 4px;
background: #ffffff;
padding: 12px;
}
.challenge-result-score span,
.play-challenge-result-score span {
color: #4a6fa5;
font-size: 1.25rem;
font-weight: 700;
}
.challenge-hint {
display: inline-block;
margin-top: 8px;
border-radius: 6px;
background: #fff4cc;
color: #1b1b2f;
padding: 6px 10px;
font-size: 0.95rem;
font-weight: 600;
}
@media (max-width: 768px) {
.messages-header,
.messages-inbox-title,
.message-meta {
align-items: flex-start;
flex-direction: column;
}
.challenge-result-scores,
.play-challenge-result-scores {
grid-template-columns: 1fr;
}
}
+95
View File
@@ -0,0 +1,95 @@
/**
* Service-Klasse für Duelle/Herausforderungen (Challenge Service).
* Ermöglicht das Erstellen und Abschließen von direkt verlinkten Challenges im Backend.
*/
class ChallengeService {
/**
* Erstellt eine Instanz des ChallengeService.
* @param {Object} config - Das globale Konfigurationsobjekt.
*/
constructor(config) {
this.baseUrl = config.API_BASE_URL;
this.urlTail = "challenges";
}
/**
* Erstellt eine neue Herausforderung für einen gegnerischen Spieler.
* @param {string} username - Name des herausfordernden Spielers.
* @param {string} password - Passwort des herausfordernden Spielers.
* @param {string} opponent - Name des herausgeforderten Spielers.
* @param {string} text - Der Rundentext und optionale Zusatznachrichten.
* @returns {Promise<Object>} Ein Promise mit den erstellten Challenge-Details im Body.
*/
async postChallenge(username, password, opponent, text) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-Username": username,
"X-Password": password,
},
body: JSON.stringify({
opponent: opponent,
text: text,
}),
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in postChallenge");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Schließt eine bestehende Herausforderung ab, indem das Spielergebnis übermittelt wird.
* @param {string} username - Name des Spielers, der die Challenge abschließt.
* @param {string} password - Passwort des Spielers.
* @param {string|number} challengeId - Eindeutige ID der Challenge im Backend.
* @param {number} score - Die erreichte Punktzahl.
* @param {number} time - Die benötigte Zeit in Sekunden.
* @param {string} text - Der Originaltext der Challenge-Runde.
* @param {string} userWrittenText - Der vom Spieler eingegebene Text.
* @returns {Promise<Object>} Ein Promise mit der Bestätigung und dem berechneten Ergebnis.
*/
async completeChallenge(username, password, challengeId, score, time, text, userWrittenText) {
const response = await fetch(`${this.baseUrl}${this.urlTail}/${challengeId}/complete`, {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-Username": username,
"X-Password": password,
},
body: JSON.stringify({
score: score,
time: time,
text: text,
userWrittenText: userWrittenText,
}),
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in completeChallenge");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
}
// Global verfügbar machen
window.ChallengeService = ChallengeService;
+8 -1
View File
@@ -1,5 +1,12 @@
/**
* Konfiguration für die Backend-Verbindung.
* Enthält die Basis-URL für alle API-Anfragen der Anwendung.
*/
const config = {
API_BASE_URL: "https://316214-1.web.fhgr.education/10001/api/"
// Die Basis-URL des Backends, an die alle REST-Anfragen gesendet werden.
API_BASE_URL: "https://webdev.iten-web.ch/10001/api/"
}
// Globales Konfigurationsobjekt im window-Scope registrieren,
// damit alle anderen Service-Klassen darauf zugreifen können.
window.config = config;␍
+16
View File
@@ -1,9 +1,23 @@
/**
* Service-Klasse für die Bestenliste (Leaderboard Service).
* Kapselt den REST-API-Aufruf zur Abfrage der globalen Highscore-Liste.
*/
class LeaderboardService {
/**
* Erstellt eine Instanz des LeaderboardService.
* @param {Object} config - Das globale Konfigurationsobjekt.
*/
constructor(config) {
this.baseUrl = config.API_BASE_URL;
this.urlTail = "leaderboard";
}
/**
* Ruft einen Ausschnitt der globalen Bestenliste ab (Paging).
* @param {number} offset - Der Startindex der abzufragenden Einträge (0-basiert).
* @param {number} limit - Die maximale Anzahl der zurückzugebenden Einträge (z.B. 10 für Top 10).
* @returns {Promise<Object>} Ein Promise mit der Liste der Top-Spieler im Body.
*/
async getLeaderboard(offset, limit) {
const response = await fetch(
`${this.baseUrl}${this.urlTail}?offset=${offset}&limit=${limit}`,
@@ -26,4 +40,6 @@ class LeaderboardService {
}
}
// Global verfügbar machen
window.LeaderboardService = LeaderboardService;
+145
View File
@@ -0,0 +1,145 @@
/**
* Service-Klasse für das Nachrichtensystem (Message Service).
* Ermöglicht den Abruf und Versand von Systemnachrichten und Herausforderungen (Challenges)
* sowie das Ändern des Gelesen-Status von Nachrichten.
*/
class MessageService {
/**
* Erstellt eine Instanz des MessageService.
* @param {Object} config - Das globale Konfigurationsobjekt.
*/
constructor(config) {
this.baseUrl = config.API_BASE_URL;
this.urlTail = "messages";
}
/**
* Lädt alle Nachrichten (eingehend und ausgehend) für den authentifizierten Benutzer.
* @param {string} username - Der Benutzername.
* @param {string} password - Das Passwort des Benutzers.
* @returns {Promise<Object>} Ein Promise mit der Liste aller Nachrichten im Body.
*/
async getMessages(username, password) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "GET",
headers: {
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in getMessages");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Sendet eine Nachricht (oder eine eingebettete Challenge) an einen anderen Benutzer.
* @param {string} username - Der Benutzername des Senders.
* @param {string} password - Das Passwort des Senders.
* @param {string} recipient - Der Empfänger der Nachricht.
* @param {string} type - Der Typ der Nachricht (z. B. "standard" oder "challenge").
* @param {string} text - Der eigentliche Textinhalt (kann eingebettete Challenge-JSON-Daten enthalten).
* @returns {Promise<Object>} Ein Promise mit der Antwort des Servers im Body.
*/
async postMessage(username, password, recipient, type, text) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-Username": username,
"X-Password": password,
},
body: JSON.stringify({
recipient: recipient,
type: type,
text: text,
}),
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in postMessage");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Markiert eine spezifische Nachricht als gelesen.
* @param {string} username - Der Benutzername des Empfängers.
* @param {string} password - Das Passwort des Empfängers.
* @param {string|number} messageId - Eindeutige ID der Nachricht.
* @returns {Promise<Object>} Ein Promise mit dem Resultat der PATCH-Anfrage.
*/
async markMessageAsRead(username, password, messageId) {
const response = await fetch(`${this.baseUrl}${this.urlTail}/${messageId}/read`, {
method: "PATCH",
headers: {
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in markMessageAsRead");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Markiert alle ungelesenen Nachrichten des Benutzers auf einmal als gelesen.
* @param {string} username - Der Benutzername.
* @param {string} password - Das Passwort des Benutzers.
* @returns {Promise<Object>} Ein Promise mit dem Status der Bulk-Operation.
*/
async markAllMessagesAsRead(username, password) {
const response = await fetch(`${this.baseUrl}${this.urlTail}/read`, {
method: "PATCH",
headers: {
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in markAllMessagesAsRead");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
}
// Global verfügbar machen
window.MessageService = MessageService;
+34 -1
View File
@@ -1,11 +1,25 @@
/**
* Service-Klasse für die Spielstände (Score Service).
* Kapselt alle REST-Anfragen an das Backend zur Speicherung und zum Laden von Scores.
*/
class ScoreService {
/**
* Erstellt eine Instanz des ScoreService.
* @param {Object} config - Das globale Konfigurationsobjekt.
*/
constructor(config) {
this.baseUrl = config.API_BASE_URL;
this.urlTail = "score";
}
/**
* Lädt alle Scores eines bestimmten Benutzers.
* @param {string} username - Der Name des Benutzers, dessen Scores geladen werden sollen.
* @returns {Promise<Object>} Ein Promise mit der Liste aller Benutzer-Scores im Body.
*/
async getScoreByName(username) {
// Note: When user does not exist, we get a 200 with empty array, not a 404
// Hinweis: Wenn der Benutzer nicht existiert, liefert das Backend einen Status 200
// mit einem leeren Array statt eines 404-Fehlers.
const response = await fetch(`${this.baseUrl}${this.urlTail}/${username}`, {
method: "GET",
});
@@ -23,6 +37,16 @@ class ScoreService {
};
}
/**
* Speichert einen neu erzielten Score im Backend.
* @param {string} username - Benutzername des Spielers.
* @param {string} password - Passwort des Spielers zur Autorisierung.
* @param {number} score - Die erreichte Punktzahl (Anzahl korrekter Wörter).
* @param {number} time - Die für die Eingabe benötigte Zeit in Sekunden.
* @param {string} text - Der vorgegebene Originaltext der Spielrunde.
* @param {string} userWrittenText - Der vom Benutzer eingegebene Text.
* @returns {Promise<Object>} Ein Promise mit der Antwort des Servers (inkl. vergebenem Rang im Body).
*/
async postScore(username, password, score, time, text, userWrittenText) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "POST",
@@ -53,6 +77,13 @@ class ScoreService {
};
}
/**
* Löscht ein bestimmtes Score-Ergebnis anhand seiner ID (falls vom Backend unterstützt).
* @param {string} username - Benutzername des Spielers.
* @param {string} password - Passwort des Spielers zur Autorisierung.
* @param {string|number} scoreId - Die eindeutige ID des zu löschenden Scores.
* @returns {Promise<Object>} Ein Promise mit dem Resultat der Löschung.
*/
async deleteScore(username, password, scoreId) {
const response = await fetch(`${this.baseUrl}${this.urlTail}/${scoreId}`, {
method: "DELETE",
@@ -76,4 +107,6 @@ class ScoreService {
}
}
// Global verfügbar machen
window.ScoreService = ScoreService;
+57
View File
@@ -1,13 +1,29 @@
/**
* Service-Klasse für die Benutzerverwaltung (User Service).
* Kapselt alle REST-Anfragen an das Backend bezüglich Login, Registrierung,
* Abfrage aller Benutzer und Löschung von Konten.
*/
class UserService {
/**
* Erstellt eine Instanz des UserService.
* @param {Object} config - Das globale Konfigurationsobjekt (enthält API_BASE_URL).
*/
constructor(config) {
this.baseUrl = config.API_BASE_URL;
this.urlTail = "user";
}
/**
* Authentifiziert einen Benutzer und ruft dessen Kontoinformationen ab.
* @param {string} username - Der Benutzername.
* @param {string} password - Das Passwort des Benutzers.
* @returns {Promise<Object>} Ein Promise mit dem HTTP-Status, dem OK-Flag und den Benutzerdaten (Body).
*/
async getUser(username, password) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "GET",
headers: {
// Authentifizierung erfolgt über benutzerdefinierte HTTP-Header
"X-Username": username,
"X-Password": password,
},
@@ -26,6 +42,40 @@ class UserService {
};
}
/**
* Ruft eine Liste aller im System registrierten Benutzer ab (z. B. für die Challenge-Auswahl).
* @param {string} username - Der Benutzername des anfragenden Benutzers.
* @param {string} password - Das Passwort des anfragenden Benutzers.
* @returns {Promise<Object>} Ein Promise mit der Benutzerliste im Response-Body.
*/
async getUsers(username, password) {
const response = await fetch(`${this.baseUrl}users`, {
method: "GET",
headers: {
"X-Username": username,
"X-Password": password,
},
});
let body = null;
try {
body = await response.json();
} catch {
console.error("Error in getUsers");
}
return {
status: response.status,
ok: response.ok,
body: body,
};
}
/**
* Löscht das eigene Benutzerkonto unwiderruflich aus dem System.
* @param {string} username - Der Benutzername des zu löschenden Kontos.
* @param {string} password - Das Passwort des Kontos.
* @returns {Promise<Object>} Ein Promise mit dem Status der Löschoperation.
*/
async deleteUser(username, password) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "DELETE",
@@ -48,6 +98,11 @@ class UserService {
};
}
/**
* Registriert einen neuen Benutzer im System. Das Passwort wird vom Backend generiert und zurückgegeben.
* @param {string} username - Der gewünschte neue Benutzername.
* @returns {Promise<Object>} Ein Promise mit den erstellten Account-Daten (inkl. generiertem Passwort) im Body.
*/
async postUser(username) {
const response = await fetch(`${this.baseUrl}${this.urlTail}`, {
method: "POST",
@@ -74,4 +129,6 @@ class UserService {
}
}
// Global verfügbar machen
window.UserService = UserService;
Binary file not shown.
+297
View File
@@ -86,6 +86,42 @@ If a user with that name already exists, it should return a 400.
}
```
### GET all users
**Endpoint**
GET /users
**Description** Returns all existing users so the frontend can show a list of possible challenge recipients. Requires authentication.
**Authentication Headers (required)**
- X-Username
- X-Password
**Response (List\<UserListItemDTO\>)**
``` json
[
{
"username": "string"
}
]
```
Alternative response shape accepted by the frontend:
``` json
[
{
"name": "string"
}
]
```
**Status Codes**
- 200 if users were loaded successfully
- 401 if authentication failed
------------------------------------------------------------------------
## 2. Score
@@ -193,5 +229,266 @@ The response should return the created object. It should give the place, the sco
]
```
------------------------------------------------------------------------
## 4. Messages / Challenges
Messages are used for user-to-user challenges. A challenge is just a message with `type: "challenge"`.
All message endpoints require authentication via the existing headers.
**Authentication Headers (required)**
- X-Username
- X-Password
### GET messages
**Endpoint**
GET /messages
**Description** Returns all messages relevant for the authenticated user. The response should include received messages and may also include sent messages, so the frontend can show a complete conversation history. The frontend uses this endpoint on page load and polls it regularly to turn the navbar item "Nachrichten" red when unread messages exist.
**Response (List\<MessageDTO\>)**
``` json
[
{
"id": 0,
"sender": "string",
"recipient": "string",
"type": "challenge",
"text": "string",
"read": false,
"createdAt": "2026-05-23T15:42:00",
"challenge": null
},
{
"id": 1,
"sender": "System",
"recipient": "string",
"type": "challenge-result",
"text": "Daniela gewinnt gegen Florin mit 18 zu 14 Punkten.",
"read": false,
"createdAt": "2026-05-23T15:48:00",
"challenge": {
"id": 5,
"challenger": "Florin",
"opponent": "Daniela",
"challengerScore": 14,
"opponentScore": 18,
"winner": "Daniela"
}
}
]
```
**Status Codes**
- 200 if messages were loaded successfully
- 401 if authentication failed
### POST message
**Endpoint**
POST /messages
**Description** Creates a new message from the authenticated user to another existing user. The sender must be taken from the authentication headers, not from the request body.
**Request Body (CreateMessageDTO)**
``` json
{
"recipient": "string",
"type": "challenge",
"text": "string"
}
```
**Response (MessageDTO)**
``` json
{
"id": 0,
"sender": "string",
"recipient": "string",
"type": "challenge",
"text": "string",
"read": false,
"createdAt": "2026-05-23T15:42:00"
}
```
**Status Codes**
- 201 if the message was created successfully
- 400 if recipient, type, or text is missing or invalid
- 401 if authentication failed
- 404 if the recipient user does not exist
### PATCH single message as read
**Endpoint**
PATCH /messages/{id}/read
**Description** Marks one received message as read. Only the recipient of the message is allowed to mark it as read.
**Response (MessageDTO)**
``` json
{
"id": 0,
"sender": "string",
"recipient": "string",
"type": "challenge",
"text": "string",
"read": true,
"createdAt": "2026-05-23T15:42:00"
}
```
**Status Codes**
- 200 if the message was marked as read
- 401 if authentication failed
- 403 if the authenticated user is not the recipient
- 404 if the message does not exist
### PATCH all messages as read
**Endpoint**
PATCH /messages/read
**Description** Marks all received messages of the authenticated user as read. This endpoint is optional, but recommended. If it is not implemented, the frontend can call `PATCH /messages/{id}/read` for each unread message.
**Response**
``` json
{
"message": "Alle Nachrichten wurden als gelesen markiert."
}
```
**Status Codes**
- 200 if all received messages were marked as read
- 401 if authentication failed
------------------------------------------------------------------------
## 5. Challenges
Challenges are competitive rounds between two users. The challenged user's current reference result is sent back when the challenge is created. The challenger then plays a round. When the round is completed, the backend compares both scores and creates result messages for both users.
All challenge endpoints require authentication via the existing headers.
**Authentication Headers (required)**
- X-Username
- X-Password
### POST challenge
**Endpoint**
POST /challenges
**Description** Creates a challenge from the authenticated user against another user. The backend should determine the opponent's reference result, ideally the opponent's best score from `/score/{opponent}`. The response is used by the frontend to start the challenger into the game with the opponent score visible.
**Request Body (CreateChallengeDTO)**
``` json
{
"opponent": "string",
"text": "Ich fordere dich zu einer Lorem-Ipsum-Challenge heraus!"
}
```
**Response (ChallengeDTO)**
``` json
{
"id": 0,
"challenger": "string",
"opponent": "string",
"opponentScore": 18,
"opponentScoreId": 42,
"status": "open",
"createdAt": "2026-05-23T15:42:00"
}
```
**Backend behavior**
- The sender/challenger must be taken from the authentication headers.
- `opponentScore` should be the opponent's best available score.
- If the opponent has no score yet, return `opponentScore: 0` or reject with 409. Returning 0 is easier for the frontend.
- The backend may also create an informational message for the opponent that they were challenged.
**Status Codes**
- 201 if the challenge was created successfully
- 400 if opponent is missing or invalid
- 401 if authentication failed
- 404 if the opponent user does not exist
- 409 optional, if the opponent has no score and the backend does not want to use 0
### POST complete challenge
**Endpoint**
POST /challenges/{id}/complete
**Description** Completes an open challenge with the authenticated user's played result. The backend compares challenger and opponent scores and creates a `challenge-result` message for both users.
**Request Body (CompleteChallengeDTO)**
``` json
{
"score": 14,
"time": 15,
"text": "string",
"userWrittenText": "string"
}
```
**Response (ChallengeResultDTO)**
``` json
{
"id": 0,
"challenger": "Florin",
"opponent": "Daniela",
"challengerScore": 14,
"opponentScore": 18,
"winner": "Daniela",
"status": "completed",
"completedAt": "2026-05-23T15:48:00",
"messages": [
{
"id": 10,
"recipient": "Florin",
"type": "challenge-result"
},
{
"id": 11,
"recipient": "Daniela",
"type": "challenge-result"
}
]
}
```
For a draw, `winner` can be `null` or `"draw"`.
**Backend behavior**
- Only the original challenger should be allowed to complete the challenge.
- The backend should persist the challenger's new result or link to the already persisted score if `/score` is called separately.
- After comparing the scores, the backend must create one unread result message for the challenger and one unread result message for the opponent.
- The result message should have `type: "challenge-result"` and include the nested `challenge` result object shown in `GET /messages`, so the frontend can render the winner/loser graphic.
**Status Codes**
- 200 if the challenge was completed successfully
- 400 if score data is missing or invalid
- 401 if authentication failed
- 403 if the authenticated user is not allowed to complete the challenge
- 404 if the challenge does not exist
- 409 if the challenge was already completed
BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 111 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 144 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 118 KiB

+34 -19
View File
@@ -4,12 +4,15 @@
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Lorem Ipsum - Das Spiel</title>
<link rel="icon" type="image/png" href="image/icon_l.png">
<!-- Bootstrap CSS -->
<link rel="stylesheet" href="assets/bootstrap-5.3.8-dist/css/bootstrap.min.css">
<link rel="stylesheet" href="assets/css/custom.css">
<!-- Favicon -->
<link class="icon" type="image/png" href="image/icon_l.png">
<!-- Kleine Korrektur direkt hier, falls Sie custom.css nicht sofort ändern wollen -->
<!-- Bootstrap CSS (Lokale Distribution) -->
<link rel="stylesheet" href="assets/bootstrap-5.3.8-dist/css/bootstrap.min.css">
<!-- Eigene Styles für Design-Anpassungen -->
<link rel="stylesheet" href="assets/css/custom.css?v=challenge-flow-20260528e">
<!-- Inline-CSS-Anpassungen zur Behebung von Flexbox-Layout-Verschiebungen -->
<style>
/* Sicherstellen, dass der Main-Area den ganzen Platz einnimmt */
#main-area {
@@ -30,15 +33,14 @@
/* Body Padding entfernen für sauberes Dashboard-Layout */
body {
padding: 0 !important;
padding: 0;
overflow-x: hidden; /* Verhindert horizontales Scrollen durch Sidebar */
}
</style>
</head>
<!-- class="p-4" entfernt -->
<body>
<!-- Navigation -->
<!-- Navigation: Navbar am oberen Bildschirmrand -->
<nav class="navbar navbar-expand-lg navbar-dark bg-dark">
<div class="container-fluid">
<a class="navbar-brand" href="#">Lorem Ipsum - Das Spiel</a>
@@ -47,6 +49,7 @@
</button>
<div class="collapse navbar-collapse" id="navbarNav">
<ul class="navbar-nav ms-auto">
<!-- Navigationslinks für Nachrichten (Inbox) und den Login/Registrierungsstatus -->
<li class ="nav-item"><a class="nav-link" href="#" id="navbar-messages">Nachrichten</a></li>
<li class="nav-item"><a class="nav-link" href="#" id="navbar-login">Login / Registrieren</a></li>
</ul>
@@ -54,8 +57,9 @@
</div>
</nav>
<!-- Hauptseiten-Wrapper für das Flexbox-Layout -->
<div id="page-wrapper">
<!-- Sidebar -->
<!-- Sidebar Navigation auf der linken Seite (oder einklappbar auf Mobilgeräten) -->
<nav id="sidebar" class="bg-dark text-white p-3">
<ul class="nav flex-column">
<li class="nav-item"><a class="nav-link" href="#" id="nav-home">Home</a></li>
@@ -65,22 +69,22 @@
</ul>
</nav>
<!-- Main Area: Enthält jetzt Topbar, Content UND Footer -->
<!-- Hauptbereich: Enthält Topbar, Content und Footer -->
<div id="main-area">
<!-- Topbar -->
<!-- Topbar (Seiten-Überschrift) -->
<header id="topbar">
<h1 class="text-center mb-4">Dashboard</h1>
</header>
<!-- Content -->
<!-- Dynamischer Inhalts-Container: Hier werden die HTML-Dateien aus pages/ hineingeladen -->
<main class="container mt-4" id="main-content">
<!-- Hier werden die pages.html geladen -->
</main>
<!-- Footer: Jetzt INSIDE main-area, damit Flexbox funktioniert -->
<!-- Footer-Bereich mit Impressums- und Urheberrechtsangaben -->
<footer class="bg-dark text-black py-4 border-top border-secondary">
<div class="container">
<!-- Oberer Bereich -->
<!-- Modul-Informationen -->
<div class="row mb-3">
<div class="col-12">Made with <span class="text-danger">♥</span> für das Modul Frontend
<h5 class="text-warning">Made with Bootstrap 5.3.8.</h5>
@@ -90,7 +94,7 @@
</div>
</div>
<!-- Impressum -->
<!-- Impressumsdetails -->
<div class="row mt-2">
<div class="col-12">
<span class="text-warning fw-bold d-block mb-2" style="font-size: 0.7rem;">Impressum</span>
@@ -113,6 +117,7 @@
</div>
</div>
</div>
<!-- Copyright-Angabe -->
<div class="text-center mt-2">
<p class="mb-0 text-black-50" style="font-size: 0.65rem;">
&copy; 2026 Modul Frontend Projekt. Alle Rechte vorbehalten.
@@ -125,16 +130,26 @@
</div>
</div>
<!-- Bootstrap JS Bundle -->
<!-- JavaScript-Einbindungen -->
<!-- Bootstrap JS Bundle (Lokale Distribution) -->
<script src="assets/bootstrap-5.3.8-dist/js/bootstrap.bundle.min.js"></script>
<!-- Backend API Services -->
<script src="assets/src/service/config-service.js"></script>
<script src="assets/src/service/user-service.js"></script>
<script src="assets/src/service/score-service.js"></script>
<script src="assets/src/service/leaderboard-service.js"></script>
<script src="assets/src/service/message-service.js"></script>
<script src="assets/src/service/challenge-service.js"></script>
<!-- Frontend Logik-Skripte -->
<script src="js/login.js"></script>
<script src="js/leaderboard.js"></script>
<!--Navigation Script -->
<script src="js/play.js"></script>
<script src="js/navigation.js"></script>
<script src="js/scores.js"></script>
<script src="js/messages.js?v=challenge-flow-20260531b"></script>
<script src="js/play.js?v=challenge-flow-20260531b"></script>
<!-- Hauptnavigations-Steuerung -->
<script src="js/navigation.js?v=challenge-flow-20260528"></script>
</body>
</html>
+69 -8
View File
@@ -1,4 +1,16 @@
// Formatiert Sekunden als m:ss. Bei ungültigem Wert wird ein Platzhalter angezeigt.
/**
* Bestenliste (Leaderboard) verwalten und anzeigen.
* Dieses Modul lädt die Top-10-Spieler vom Server. Falls der aktuell angemeldete
* Benutzer nicht in diesen Top-10 vertreten ist, lädt es zusätzlich dessen
* persönliches Bestergebnis und zeigt dieses optisch getrennt darunter an.
*/
/**
* Formatiert Sekunden in ein lesbares MM:SS Format (z.B. 75 Sekunden -> "1:15").
* Bei ungültigen Werten wird ein Strich ausgegeben.
* @param {number} seconds - Anzahl Sekunden.
* @returns {string} Formatiertes Zeit-String.
*/
function formatTime(seconds) {
if (typeof seconds !== "number" || Number.isNaN(seconds)) {
return "-";
@@ -9,7 +21,10 @@ function formatTime(seconds) {
return `${minutes}:${String(remainingSeconds).padStart(2, "0")}`;
}
// Liefert den aktuellen Login-Kontext, falls Auth global verfügbar ist.
/**
* Holt die aktuellen Authentifizierungsdaten aus dem globalen Auth-Modul.
* @returns {Object|null} Auth-Objekt (mit username) oder null.
*/
function getLoggedInAuth() {
if (!window.AppAuth || typeof window.AppAuth.getAuth !== "function") {
return null;
@@ -23,11 +38,19 @@ function getLoggedInAuth() {
return auth;
}
// Vereinheitlicht Benutzernamen für robuste Vergleiche (z. B. Groß-/Kleinschreibung).
/**
* Normalisiert einen Benutzernamen (Trimming und Kleinschreibung) für robuste Vergleiche.
* @param {string} username - Der Benutzername.
* @returns {string} Der bereinigte Benutzername.
*/
function normalizeUsername(username) {
return String(username ?? "").trim().toLowerCase();
}
/**
* Ermittelt den normalisierten Benutzernamen des aktuell angemeldeten Benutzers.
* @returns {string|null} Der bereinigte Name oder null.
*/
function getLoggedInUsername() {
const auth = getLoggedInAuth();
if (!auth) {
@@ -37,7 +60,13 @@ function getLoggedInUsername() {
return normalizeUsername(auth.username);
}
// Nutzt den vom Backend gelieferten Rang, fallback auf die aktuelle Listenposition.
/**
* Ermittelt den anzuzeigenden Rang eines Bestenlisten-Eintrags.
* Nutzt vorrangig den vom Backend gelieferten Platz ("place"), andernfalls den Listenindex.
* @param {Object} entry - Der Listeneintrag.
* @param {number} index - Der Listenindex.
* @returns {number} Der anzuzeigende Rang.
*/
function getDisplayedRank(entry, index) {
const place = Number(entry?.place);
if (!Number.isNaN(place) && place > 0) {
@@ -47,7 +76,12 @@ function getDisplayedRank(entry, index) {
return index + 1;
}
// Bestes Ergebnis: höchste Punktzahl, bei Gleichstand die geringere Zeit.
/**
* Ermittelt das beste Ergebnis aus einer Liste von Scores.
* Sortiert nach Score (absteigend) und bei Gleichstand nach Zeit (aufsteigend).
* @param {Array<Object>} entries - Eine Liste von Score-Einträgen.
* @returns {Object|null} Der beste Score-Eintrag.
*/
function getBestScoreEntry(entries) {
return entries
.slice()
@@ -64,6 +98,11 @@ function getBestScoreEntry(entries) {
})[0] ?? null;
}
/**
* Holt das beste Ergebnis des aktuell angemeldeten Benutzers aus dem Backend.
* @param {string} username - Der Benutzername des eingeloggten Spielers.
* @returns {Promise<Object|null>} Das beste Spielergebnis oder null.
*/
async function getCurrentUserLeaderboardEntry(username) {
if (!window.ScoreService || !username) {
return null;
@@ -79,7 +118,14 @@ async function getCurrentUserLeaderboardEntry(username) {
return getBestScoreEntry(result.body);
}
// Rendert die Top-Liste und markiert den eingeloggten Nutzer visuell.
/**
* Rendert die Bestenliste im DOM.
* Hebt die Zeile des aktuell angemeldeten Benutzers farblich hervor.
* Falls extraUserEntry übergeben wird (wenn der User nicht in den Top-10 ist),
* wird am Ende eine Trennzeile und der Eintrag des Benutzers angehängt.
* @param {Array<Object>} entries - Die Top-10 Leaderboard-Einträge.
* @param {Object|null} extraUserEntry - Der separate Bestenlisten-Eintrag des angemeldeten Benutzers.
*/
function renderLeaderboard(entries, extraUserEntry = null) {
const tableBody = document.getElementById("leaderboard-body");
if (!tableBody) {
@@ -90,10 +136,12 @@ function renderLeaderboard(entries, extraUserEntry = null) {
tableBody.innerHTML = "";
// Rendern der Top-10
entries.forEach((entry, index) => {
const row = document.createElement("tr");
const rowUsername = normalizeUsername(entry.username);
// Zeile grün hervorheben, wenn es sich um den eigenen Account handelt
if (loggedInUsername && rowUsername === loggedInUsername) {
row.classList.add("leaderboard-row-current-user");
}
@@ -108,13 +156,15 @@ function renderLeaderboard(entries, extraUserEntry = null) {
tableBody.appendChild(row);
});
// Wenn der User eingeloggt ist, aber nicht in den Top-10 vertreten war, hängen wir ihn unten an
if (extraUserEntry) {
// Trennt Top-10 und eigenen Eintrag optisch, wenn der Nutzer nicht in den Top-10 ist.
// Optische Lücke (Leerzeile) einfügen
const spacerRow = document.createElement("tr");
spacerRow.classList.add("leaderboard-row-gap");
spacerRow.innerHTML = '<td colspan="4"></td>';
tableBody.appendChild(spacerRow);
// Zeile des angemeldeten Benutzers anhängen
const userRow = document.createElement("tr");
userRow.classList.add("leaderboard-row-current-user");
userRow.classList.add("leaderboard-row-current-user-extra");
@@ -129,8 +179,13 @@ function renderLeaderboard(entries, extraUserEntry = null) {
}
}
/**
* Lädt die Top-10-Bestenliste vom Backend und prüft,
* ob der angemeldete Benutzer separat geladen werden muss.
*/
async function loadTopTenLeaderboard() {
const leaderboardService = new window.LeaderboardService(window.config);
// Holt die Bestenliste beginnend bei Rang 1 (Offset 0) mit maximal 10 Einträgen
const result = await leaderboardService.getLeaderboard(0, 10);
if (!result.ok || !Array.isArray(result.body)) {
@@ -143,11 +198,12 @@ async function loadTopTenLeaderboard() {
if (auth && auth.username) {
const loggedInUsername = normalizeUsername(auth.username);
// Falls der Nutzer nicht in den Top-10 erscheint, wird sein bestes Ergebnis separat gezeigt.
// Prüfen, ob der angemeldete Benutzer bereits in den Top-10 vorhanden ist
const isInTopTen = result.body.some(
(entry) => normalizeUsername(entry.username) === loggedInUsername,
);
// Wenn er nicht in den Top-10 ist, rufen wir sein bestes Ergebnis separat ab
if (!isInTopTen) {
extraUserEntry = await getCurrentUserLeaderboardEntry(auth.username);
}
@@ -156,9 +212,14 @@ async function loadTopTenLeaderboard() {
renderLeaderboard(result.body, extraUserEntry);
}
/**
* Globale Initialisierungsfunktion, die von navigation.js aufgerufen wird,
* sobald die leaderboard.html-Teilseite geladen wurde.
*/
window.initLeaderboardPage = function initLeaderboardPage() {
loadTopTenLeaderboard().catch((error) => {
console.error("Fehler beim Laden des Leaderboards:", error);
renderLeaderboard([]);
});
};
+101 -5
View File
@@ -1,6 +1,16 @@
/**
* Benutzer-Authentifizierung und Account-Verwaltung.
* Verwaltet den Login-Status über den LocalStorage, steuert die Anzeige im Header,
* verarbeitet Login- und Registrierungsformulare und ermöglicht das Löschen des Kontos.
*/
(function () {
// Der Schlüssel, unter dem die Benutzerdaten im LocalStorage abgelegt werden.
const AUTH_STORAGE_KEY = "loremIpsumAuth";
/**
* Liest die aktuellen Anmeldedaten aus dem LocalStorage des Browsers.
* @returns {Object|null} Ein Objekt mit {username, password} oder null, falls nicht angemeldet oder ungültig.
*/
function readAuth() {
const raw = localStorage.getItem(AUTH_STORAGE_KEY);
if (!raw) {
@@ -9,15 +19,22 @@
try {
const parsed = JSON.parse(raw);
// Validieren, dass die Pflichtfelder vorhanden sind
if (!parsed.username || !parsed.password) {
return null;
}
return parsed;
} catch {
// Fehler beim JSON-Parsen (z.B. manipulierte Daten) -> als nicht angemeldet behandeln
return null;
}
}
/**
* Speichert die Benutzerdaten verschlüsselt als JSON-String im LocalStorage.
* @param {string} username - Der Benutzername.
* @param {string} password - Das generierte/eingegebene Passwort.
*/
function saveAuth(username, password) {
localStorage.setItem(
AUTH_STORAGE_KEY,
@@ -25,24 +42,37 @@
);
}
/**
* Entfernt die Anmeldedaten aus dem LocalStorage (Logout).
*/
function clearAuth() {
localStorage.removeItem(AUTH_STORAGE_KEY);
}
/**
* Aktualisiert die Anzeige des Benutzernamens im Header und den Login-Button.
*/
function updateHeaderUsername() {
const usernameDisplay = document.getElementById("username-display");
const navbarLogin = document.getElementById("navbar-login");
const auth = readAuth();
// Text im Header anpassen ("User: Guest" oder "User: <Name>")
if (usernameDisplay) {
usernameDisplay.textContent = auth ? "User: " + auth.username : "User: Guest";
}
// Text des Login-Links in der Navbar anpassen
if (navbarLogin) {
navbarLogin.textContent = auth ? auth.username : "Login / Registrieren";
}
}
/**
* Zeigt dem Benutzer Feedback (z. B. Fehlermeldungen) auf der Login-Seite an.
* @param {string} message - Die anzuzeigende Nachricht.
* @param {string} type - Der Bootstrap-Alert-Typ (danger, warning, success, info).
*/
function setFeedback(message, type) {
const feedback = document.getElementById("auth-feedback");
if (!feedback) {
@@ -51,9 +81,13 @@
feedback.className = "alert alert-" + type;
feedback.textContent = message;
feedback.classList.remove("d-none");
feedback.classList.remove("d-none"); // Alert einblenden
}
/**
* Aktualisiert den Zustand der Session-Box (Anzeige der aktuellen Anmeldung).
* Blendet die Forms aus bzw. ein und aktiviert/deaktiviert die Buttons.
*/
function updateSessionBox() {
const sessionText = document.getElementById("current-session-text");
const logoutButton = document.getElementById("logout-button");
@@ -67,12 +101,14 @@
const auth = readAuth();
if (auth) {
// Wenn eingeloggt: Session-Info anzeigen und Buttons aktivieren
sessionText.textContent = "Eingeloggt als " + auth.username + ".";
logoutButton.disabled = false;
deleteAccountButton.disabled = false;
currentSessionBox.classList.remove("d-none");
authFormsRow.classList.remove("d-none");
} else {
// Wenn nicht eingeloggt: Info setzen und Session-Box verbergen
sessionText.textContent = "Nicht eingeloggt.";
logoutButton.disabled = true;
deleteAccountButton.disabled = true;
@@ -81,6 +117,10 @@
}
}
/**
* Hilfsfunktion zum Instanziieren des UserService.
* @returns {UserService|null} Eine UserService-Instanz oder null.
*/
function getUserService() {
if (!window.config || !window.UserService) {
return null;
@@ -89,6 +129,11 @@
return new window.UserService(window.config);
}
/**
* Behandelt das Absenden des Login-Formulars.
* Authentifiziert den Benutzer beim Backend und speichert die Session bei Erfolg.
* @param {Event} event - Das Submit-Event des Formulars.
*/
async function handleLoginSubmit(event) {
event.preventDefault();
@@ -100,7 +145,7 @@
const usernameInput = document.getElementById("login-username");
const passwordInput = document.getElementById("login-password");
const submitButton = event.submitter;
const submitButton = event.submitter; // Der geklickte Button
const username = usernameInput.value.trim();
const password = passwordInput.value.trim();
@@ -109,6 +154,7 @@
return;
}
// Button während der Anfrage sperren und Ladeindikator zeigen
if (submitButton) {
submitButton.disabled = true;
submitButton.textContent = "Einloggen...";
@@ -127,16 +173,25 @@
return;
}
// Button wieder freigeben
if (submitButton) {
submitButton.disabled = false;
submitButton.textContent = "Einloggen";
}
if (result.ok) {
// Login erfolgreich: Daten speichern, Ansicht aktualisieren und zur Startseite leiten
saveAuth(username, password);
setFeedback("Login erfolgreich.", "success");
updateSessionBox();
updateHeaderUsername();
// Falls das Navigationsmenü geöffnet ist, dessen Status aktualisieren
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
// Kurze Verzögerung für visuelles Feedback vor dem Seitenwechsel
setTimeout(function() {
if (typeof window.loadPage === "function") {
window.loadPage("home", "nav-home");
@@ -153,6 +208,12 @@
setFeedback("Login fehlgeschlagen (Status " + result.status + ").", "danger");
}
/**
* Behandelt das Absenden des Registrierungsformulars.
* Sendet den gewünschten Benutzernamen ans Backend, welches das Passwort generiert.
* Zeigt das Passwort anschließend in einem Bootstrap-Modal an, da es nur einmalig sichtbar ist.
* @param {Event} event - Das Submit-Event des Formulars.
*/
async function handleRegisterSubmit(event) {
event.preventDefault();
@@ -172,24 +233,30 @@
const result = await userService.postUser(username);
if (result.ok && result.body) {
// Registrierung erfolgreich: Antwortdaten auslesen
const createdName = result.body.name || username;
const createdPassword = result.body.password || "";
// Direkt einloggen mit den erhaltenen Daten
saveAuth(createdName, createdPassword);
updateSessionBox();
updateHeaderUsername();
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
// Modal mit Daten füllen und anzeigen
// Modal mit den generierten Zugangsdaten befüllen
const modalUsername = document.getElementById("modal-username");
const modalPassword = document.getElementById("modal-password");
if (modalUsername) modalUsername.textContent = createdName;
if (modalPassword) modalPassword.textContent = createdPassword;
// Das Passwort-Modal anzeigen
const passwordModalElement = document.getElementById("password-modal");
if (passwordModalElement) {
const passwordModal = new window.bootstrap.Modal(passwordModalElement);
// Listener für Modals-Schließen: zur Startseite navigieren
// Nach Schließen des Modals automatisch auf die Startseite weiterleiten
passwordModalElement.addEventListener("hidden.bs.modal", function handleClose() {
if (typeof window.loadPage === "function") {
window.loadPage("home", "nav-home");
@@ -199,7 +266,7 @@
passwordModal.show();
} else {
// Fallback wenn Modal nicht gefunden
// Fallback, falls das Bootstrap-Modal im DOM nicht gefunden wurde
setFeedback(
"Account erstellt. Username: " + createdName + ", Passwort: " + createdPassword,
"success",
@@ -211,6 +278,7 @@
}, 1500);
}
// Formularfelder für eventuelle spätere Logins vorausfüllen
const loginUsernameInput = document.getElementById("login-username");
const loginPasswordInput = document.getElementById("login-password");
if (loginUsernameInput && loginPasswordInput) {
@@ -221,6 +289,7 @@
return;
}
// Fehlerbehandlung
if (result.status === 400) {
const errorMessage = result.body && result.body.message
? result.body.message
@@ -235,13 +304,24 @@
);
}
/**
* Loggt den aktuellen Benutzer aus (löscht Auth-Daten aus LocalStorage und aktualisiert UI).
*/
function handleLogout() {
clearAuth();
setFeedback("Du wurdest ausgeloggt.", "info");
updateSessionBox();
updateHeaderUsername();
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
}
/**
* Behandelt das Löschen des eigenen Accounts.
* Fordert eine Sicherheitsbestätigung an, sendet die Löschanfrage ans Backend
* und führt bei Erfolg einen automatischen Logout aus.
*/
async function handleDeleteAccount() {
const auth = readAuth();
if (!auth) {
@@ -249,6 +329,7 @@
return;
}
// Sicherheitsabfrage im Browser
const wantsDelete = window.confirm(
"Möchtest du den Account \"" + auth.username + "\" wirklich löschen?",
);
@@ -264,9 +345,13 @@
const result = await userService.deleteUser(auth.username, auth.password);
if (result.ok) {
// Account erfolgreich gelöscht: Lokal ausloggen und Feedback geben
clearAuth();
updateSessionBox();
updateHeaderUsername();
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
setFeedback("Account wurde gelöscht.", "success");
return;
}
@@ -282,6 +367,10 @@
);
}
/**
* Initialisiert die Login-Seite.
* Bindet alle Event-Listener an die Formulare und Buttons nach dem Laden des HTML-Inhalts.
*/
function initLoginPage() {
const loginForm = document.getElementById("login-form");
const registerForm = document.getElementById("register-form");
@@ -297,15 +386,22 @@
logoutButton.addEventListener("click", handleLogout);
deleteAccountButton.addEventListener("click", handleDeleteAccount);
// Initialen UI-Zustand herstellen
updateSessionBox();
updateHeaderUsername();
}
// Bindet die Initialisierungsfunktion an das globale Fensterobjekt für navigation.js
window.initLoginPage = initLoginPage;
// Stellt Authentifizierungsfunktionen global bereit, damit andere Module (z. B. play.js)
// prüfen können, ob und wer eingeloggt ist.
window.AppAuth = {
getAuth: readAuth,
clearAuth: clearAuth,
};
// Beim allerersten Laden der Anwendung direkt den Header anpassen
document.addEventListener("DOMContentLoaded", updateHeaderUsername);
})();
+1188
View File
File diff suppressed because it is too large. Load diff
+45 -5
View File
@@ -1,41 +1,76 @@
/**
* Navigation und dynamisches Laden von Einzelseiten (Single Page App Verhalten).
* Dieses Skript reagiert auf Klicks im Menü/Sidebar, lädt die gewünschte HTML-Teilseite
* per Fetch-API nach und führt die jeweilige Seite-Initialisierungsfunktion aus.
*/
document.addEventListener("DOMContentLoaded", () => {
/**
* Setzt die "active"-Klasse im Menü für die ausgewählte Seite,
* damit der Benutzer sieht, in welchem Bereich er sich befindet.
* @param {string} id - Die ID des Menü-Links (z.B. "nav-home").
*/
function setActiveMenu(id) {
//Alle Sidebar-Links zurücksetzen
// Alle Sidebar-Links zurücksetzen
document.querySelectorAll("#sidebar .nav-link").forEach(link => link.classList.remove("active"));
// Alle Navbar-Links zurücksetzen
document.querySelectorAll(".navbar-nav .nav-link").forEach(link => link.classList.remove("active"));
//Aktiven Link setzen
// Aktiven Link anhand seiner ID suchen und hervorheben
const activeLink = document.getElementById(id);
if (activeLink) activeLink.classList.add("active");
}
/**
* Lädt eine Teilseite (.html) dynamisch aus dem "pages/"-Ordner in den Hauptbereich.
* Nach dem Laden werden die DOM-Elemente initialisiert (z.B. Event-Listener gebunden),
* indem die entsprechende globale "init..."-Funktion aufgerufen wird.
* @param {string} page - Der Name der HTML-Datei (ohne Endung, z.B. "play").
* @param {string} menuId - Die ID des zugehörigen Menüpunkts zur visuellen Aktivierung.
*/
window.loadPage = function loadPage(page, menuId) {
fetch("pages/" + page + ".html")
// fetch lädt das HTML-Snippet. cache: "no-store" verhindert veraltete Stände im Browser-Cache.
fetch("pages/" + page + ".html", { cache: "no-store" })
.then(response => {
if (!response.ok) {
throw new Error("HTTP " + response.status);
throw new Error("HTTP-Fehler " + response.status);
}
return response.text();
})
.then(data => {
// Das geladene HTML-Fragment in den Haupt-Container rendern
document.getElementById("main-content").innerHTML = data;
// Aktiven Menüpunkt visuell kennzeichnen
setActiveMenu(menuId);
// Da das DOM nun neu aufgebaut wurde, müssen wir die Event-Handler
// für die jeweilige Seite neu registrieren (Init-Funktionen).
if (page === "login" && typeof window.initLoginPage === "function") {
window.initLoginPage();
}
if (page === "leaderboard" && typeof window.initLeaderboardPage === "function") {
window.initLeaderboardPage();
}
if (page === "scores" && typeof window.initScoresPage === "function") {
window.initScoresPage();
}
if (page === "play" && typeof window.initPlayPage === "function") {
window.initPlayPage();
}
if (page === "messages" && typeof window.initMessagesPage === "function") {
window.initMessagesPage();
}
})
.catch(error => {
console.error("Fehler beim Laden von " + page + ":", error);
// Fehlermeldung für den Benutzer in den Hauptbereich einbetten
document.getElementById("main-content").innerHTML = "<div class='alert alert-danger'>Fehler beim Laden der Seite: " + error.message + "</div>";
});
};
// --- Menü-Verkabelung ---
// Alle Navigations-Elemente aus dem DOM abrufen
const navHome = document.getElementById("nav-home");
const navPlay = document.getElementById("nav-play");
const navMyScores = document.getElementById("nav-my-scores");
@@ -43,6 +78,7 @@ document.addEventListener("DOMContentLoaded", () => {
const navbarLogin = document.getElementById("navbar-login");
const navbarMessages = document.getElementById("navbar-messages");
// Standard-Verhalten der Links (Seiten-Reload) verhindern und loadPage() aufrufen
if (navHome) navHome.onclick = (e) => { e.preventDefault(); loadPage("home", "nav-home"); };
if (navPlay) navPlay.onclick = (e) => { e.preventDefault(); loadPage("play", "nav-play"); };
if (navMyScores) navMyScores.onclick = (e) => { e.preventDefault(); loadPage("scores", "nav-my-scores"); };
@@ -50,6 +86,10 @@ document.addEventListener("DOMContentLoaded", () => {
if (navbarLogin) navbarLogin.onclick = (e) => { e.preventDefault(); loadPage("login", "navbar-login"); };
if (navbarMessages) navbarMessages.onclick = (e) => { e.preventDefault(); loadPage("messages", "navbar-messages"); };
//Startseite laden
// Prüfen, ob neue ungelesene Nachrichten vorliegen, um den Nachrichten-Link rot zu markieren
if (typeof window.updateMessagesNavState === "function") window.updateMessagesNavState();
// Beim allerersten Aufruf der App die Startseite ("home") laden
loadPage("home", "nav-home");
});
+622 -41
View File
@@ -1,8 +1,22 @@
/**
* Spiellogik (Lorem Ipsum Merk- und Schreibspiel).
* Dieses Modul verwaltet die verschiedenen Phasen des Spiels (Startansicht, Einprägen, Eingabe, Auswertung),
* berechnet die Punktzahl durch Wortvergleich und speichert das Ergebnis im Backend.
* Unterstützt auch das Duell-System (Challenges) zwischen zwei Benutzern.
*/
(function () {
// --- Konfiguration ---
// --- Konfiguration & Konstanten ---
// Die Zeit in Sekunden, die der Spieler hat, um sich den Text einzuprägen.
const MEMORIZE_TIME_SECONDS = 15;
// Bausteine fuer den zufaelligen Rundentext. Alles bleibt lokal, damit das Spiel ohne Backend starten kann.
// Storage-Schlüssel, unter dem eine aktive Challenge im SessionStorage zwischengespeichert wird.
const ACTIVE_CHALLENGE_STORAGE_KEY = "loremIpsumActiveChallenge";
// Präfix zur Kennzeichnung von eingebetteten JSON-Challenge-Daten in Textnachrichten.
const CHALLENGE_DATA_PREFIX = "[[loremIpsumChallenge:";
// Bausteine für den zufälligen Rundentext. Alles bleibt lokal, damit das Spiel ohne Backend starten kann.
const TEXT_PARTS = {
subjects: [
"Der flinke Entwickler",
@@ -54,35 +68,48 @@
],
};
let timerInterval;
let currentTime = 0;
// --- Spielstatus Variablen ---
let timerInterval; // Intervall-ID für den Memorize-Timer
let currentTime = 0; // Aktueller Countdown-Stand
let inputStartMs = null; // Zeitstempel (ms), wann der Benutzer mit der Eingabe begonnen hat
// Der aktuell angezeigte Text muss bis zur Auswertung stabil bleiben.
let currentGameText = "";
let lastGeneratedText = "";
let lastGeneratedText = ""; // Verhindert direkt aufeinanderfolgende gleiche Texte
// DOM-Referenzen werden erst gesetzt, nachdem pages/play.html dynamisch geladen wurde.
let phaseStart;
let phaseMemorize;
let phaseInput;
let phaseResult;
let targetTextDisplay;
let timerDisplay;
let userTextInput;
let resultScore;
let resultOriginal;
let resultInput;
let gameStatus;
let scoreSaveFeedback;
let btnSubmitScore;
// DOM-Referenzen (werden in initPlayPage gesucht, da play.html dynamisch nachgeladen wird)
let phaseStart; // Start-Container (mit "Starten"-Button)
let phaseMemorize; // Einpräge-Container (zeigt den Text und Countdown)
let phaseInput; // Eingabe-Container (Textarea)
let phaseResult; // Ergebnis-Container (Vergleich und erreichte Punkte)
// --- Funktionen ---
let targetTextDisplay; // Element zur Anzeige des zu merkenden Textes
let timerDisplay; // Element zur Anzeige des Countdowns
let userTextInput; // Textarea für die Benutzereingabe
let resultScore; // Element zur Anzeige der Punktzahl im Ergebnis
let resultOriginal; // Container für farblich markierten Originaltext
let resultInput; // Container für farblich markierten eingegebenen Text
let gameStatus; // Badge-Element zur Statusanzeige (z.B. "Lernphase", "Eingabe")
let scoreSaveFeedback; // Container für Rückmeldungen beim Speichern
let btnSubmitScore; // Button "Auswerten & Absenden"
let activeChallenge = null; // Enthält geladene Challenge-Daten (falls Spiel aus Inbox gestartet)
// --- Hilfsfunktionen ---
/**
* Wählt ein zufälliges Element aus einem Array aus.
* @param {Array} items - Das Quell-Array.
* @returns {*} Ein zufälliges Element.
*/
function getRandomItem(items) {
return items[Math.floor(Math.random() * items.length)];
}
// Erstellt pro Runde zwei zufaellige Saetze plus Schluss-Satz und vermeidet direkte Wiederholungen.
/**
* Erstellt pro Runde zwei zufällige Hauptsätze plus einen Schlusssatz.
* Stellt sicher, dass sich zwei aufeinanderfolgende Runden-Texte unterscheiden.
* @returns {string} Ein generierter Satz.
*/
function generateGameText() {
let generatedText = "";
@@ -115,13 +142,19 @@
return generatedText;
}
/**
* Startet eine neue Spielrunde. Blendet die Startphase aus und startet den Countdown.
*/
function startGame() {
if (!phaseStart || !phaseMemorize) return;
// Startansicht ausblenden und den neu generierten Text fuer die Lernphase anzeigen.
inputStartMs = null; // Zeitstempel zurücksetzen
// Startansicht ausblenden und den Einpräge-Bildschirm anzeigen
phaseStart.classList.add("d-none");
phaseMemorize.classList.remove("d-none");
// Status-Badge aktualisieren
if (gameStatus) {
gameStatus.textContent = "Lernphase";
gameStatus.className = "badge fs-6 px-3 py-2";
@@ -129,10 +162,11 @@
gameStatus.style.color = "#1b1b2f";
}
currentGameText = generateGameText();
// Text ermitteln (aus Challenge oder neu generiert) und anzeigen
currentGameText = getRoundText();
if (targetTextDisplay) targetTextDisplay.textContent = currentGameText;
// Nach Ablauf des Timers wird automatisch zur Eingabe gewechselt.
// Countdown-Timer starten
currentTime = MEMORIZE_TIME_SECONDS;
if (timerDisplay) timerDisplay.textContent = currentTime;
@@ -140,21 +174,26 @@
currentTime--;
if (timerDisplay) timerDisplay.textContent = currentTime;
// Nach Ablauf des Timers automatisch in die Eingabephase wechseln
if (currentTime <= 0) {
endMemorizePhase();
}
}, 1000);
}
/**
* Beendet die Einprägephase, stoppt den Timer und öffnet das Eingabefeld.
*/
function endMemorizePhase() {
clearInterval(timerInterval);
if (!phaseMemorize || !phaseInput) return;
// Text verschwindet, Eingabefeld erscheint: ab hier zaehlt nur noch das Gedaechtnis.
// Text ausblenden (wichtig gegen Abschreiben!) und Eingabefeld zeigen
phaseMemorize.classList.add("d-none");
phaseInput.classList.remove("d-none");
// Status-Badge anpassen
if (gameStatus) {
gameStatus.textContent = "Eingabe";
gameStatus.className = "badge fs-6 px-3 py-2";
@@ -162,26 +201,54 @@
gameStatus.style.color = "#fff";
}
// Fokus ins Textfeld setzen, damit der Spieler sofort tippen kann
if (userTextInput) {
userTextInput.value = "";
userTextInput.focus();
}
// Zeitmessung für die Eingabedauer starten
inputStartMs = Date.now();
}
// Entfernt alles, was beim Vergleichen nicht zaehlen soll.
/**
* Normalisiert ein einzelnes Wort für den fehlertoleranten Vergleich.
* Konvertiert zu Kleinbuchstaben, löst Umlaute/ß auf und entfernt Satzzeichen.
* @param {string} word - Das zu bereinigende Wort.
* @returns {string} Das normalisierte Wort.
*/
function normalizeWord(word) {
return word.toLowerCase().replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g, "");
return word
.toLowerCase()
.replace(/ä/g, "ae")
.replace(/ö/g, "oe")
.replace(/ü/g, "ue")
.replace(/ß/g, "ss")
// Entfernt Satz- und Sonderzeichen
.replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g, "");
}
// Behält die sichtbaren Woerter separat, damit Satzzeichen in der Ergebnisanzeige erhalten bleiben.
/**
* Zerlegt einen Text anhand von Leerzeichen in ein Array von Wörtern.
* Leere Elemente (z.B. durch mehrfache Leerzeichen) werden ausgefiltert.
* @param {string} text - Der Eingabetext.
* @returns {Array<string>} Liste der Wörter.
*/
function getWords(text) {
return text.split(/\s+/).filter((word) => word.length > 0);
}
/**
* Berechnet die Punktzahl auf Basis der korrekt geschriebenen Wörter.
* Es wird die exakte Position der Wörter verglichen (Wort an Index i).
* @param {string} original - Der vorgegebene Originaltext.
* @param {string} input - Die Eingabe des Spielers.
* @returns {number} Anzahl der übereinstimmenden Wörter.
*/
function calculateScore(original, input) {
if (!original || !input) return 0;
// Score-Regel: gleiche Woerter an gleicher Position, Satzzeichen und Grossschreibung ignoriert.
// Beide Texte in normalisierte Wort-Listen zerlegen
const cleanOriginal = getWords(original)
.map(normalizeWord)
.filter((word) => word.length > 0);
@@ -190,6 +257,7 @@
.filter((word) => word.length > 0);
let correctWords = 0;
// Nur bis zum kürzeren der beiden Texte vergleichen, um Out-of-Bounds zu vermeiden
const limit = Math.min(cleanOriginal.length, cleanInput.length);
for (let i = 0; i < limit; i++) {
@@ -201,7 +269,12 @@
return correctWords;
}
// Baut ein einzelnes farbiges Wort-Label fuer den Ergebnisvergleich.
/**
* Erstellt ein farbiges Badge-Element für die Ergebnisanzeige.
* @param {string} word - Das darzustellende Wort.
* @param {boolean} isCorrect - Bestimmt die Farbe (Grün für korrekt, Rot für falsch).
* @returns {HTMLElement} Das erstellte span-Element.
*/
function createWordBadge(word, isCorrect) {
const badge = document.createElement("span");
badge.className =
@@ -210,7 +283,11 @@
return badge;
}
// Markiert Original und Eingabe nach derselben Positionslogik wie calculateScore().
/**
* Visualisiert den Wortvergleich zwischen Original und Eingabe im Ergebnisbereich.
* @param {string} original - Der Originaltext.
* @param {string} input - Der eingegebene Text.
*/
function renderWordComparison(original, input) {
if (!resultOriginal || !resultInput) return;
@@ -220,14 +297,14 @@
resultOriginal.innerHTML = "";
resultInput.innerHTML = "";
// Original: rot, wenn das eingegebene Wort an dieser Position fehlt oder falsch ist.
// Originaltext-Badges: Rot markieren, wenn an dieser Position das Wort fehlt oder falsch eingegeben wurde
originalWords.forEach((word, index) => {
const isCorrect =
normalizeWord(word) === normalizeWord(inputWords[index] || "");
resultOriginal.appendChild(createWordBadge(word, isCorrect));
});
// Eingabe: rot, wenn das Wort nicht zum Originalwort an derselben Position passt.
// Eingegebene Badges: Rot markieren, wenn das Wort an dieser Stelle nicht zum Original passt
inputWords.forEach((word, index) => {
const isCorrect =
normalizeWord(word) === normalizeWord(originalWords[index] || "");
@@ -235,6 +312,9 @@
});
}
/**
* Holt die aktuellen Authentifizierungsdaten.
*/
function getAuth() {
if (!window.AppAuth || typeof window.AppAuth.getAuth !== "function") {
return null;
@@ -243,6 +323,9 @@
return window.AppAuth.getAuth();
}
/**
* Holt eine Instanz des ScoreService.
*/
function getScoreService() {
if (!window.config || !window.ScoreService) {
return null;
@@ -251,6 +334,112 @@
return new window.ScoreService(window.config);
}
/**
* Holt eine Instanz des ChallengeService.
*/
function getChallengeService() {
if (!window.config || !window.ChallengeService) {
return null;
}
return new window.ChallengeService(window.config);
}
/**
* Holt eine Instanz des MessageService.
*/
function getMessageService() {
if (!window.config || !window.MessageService) {
return null;
}
return new window.MessageService(window.config);
}
/**
* Liest eine im SessionStorage hinterlegte aktive Challenge aus.
* @returns {Object|null} Challenge-Datenobjekt oder null.
*/
function readActiveChallenge() {
// Challenge-Runden werden auf der Nachrichten-Seite gestartet.
// Der gespeicherte Kontext entscheidet über den API-Fluss nach Spielende.
const raw = sessionStorage.getItem(ACTIVE_CHALLENGE_STORAGE_KEY);
if (!raw) {
return null;
}
try {
const challenge = JSON.parse(raw);
if (!challenge || challenge.id === undefined || challenge.id === null || !challenge.opponent) {
return null;
}
return challenge;
} catch {
return null;
}
}
/**
* Prüft, ob aktuell eine aktive Herausforderung vorliegt.
*/
function hasActiveChallenge() {
return Boolean(activeChallenge && activeChallenge.id !== undefined && activeChallenge.id !== null);
}
/**
* Prüft, ob es sich um die zweite Runde einer Challenge handelt.
* In der zweiten Runde spielt der Herausforderer gegen den Score des Gegners.
*/
function isChallengeSecondRound() {
return hasActiveChallenge()
&& activeChallenge.role === "challenger"
&& activeChallenge.opponentScore !== null
&& activeChallenge.opponentScore !== undefined;
}
/**
* Prüft, ob es sich um die erste Runde einer Challenge handelt.
* In der ersten Runde spielt der herausgeforderte User und sendet danach sein Ergebnis.
*/
function isChallengeFirstRound() {
return hasActiveChallenge() && activeChallenge.role === "opponent";
}
/**
* Schreibt den aktuellen Challenge-Kontext in den SessionStorage.
*/
function writeActiveChallenge(challenge) {
sessionStorage.setItem(ACTIVE_CHALLENGE_STORAGE_KEY, JSON.stringify(challenge));
}
/**
* Ermittelt den Text für die Spielrunde.
* Bei Challenges müssen beide Spieler denselben Text erhalten, welcher aus dem Kontext ausgelesen wird.
* @returns {string} Der Rundentext.
*/
function getRoundText() {
if (!activeChallenge) {
return generateGameText();
}
// Wenn ein fester Challenge-Text existiert, wird dieser verwendet
if (typeof activeChallenge.challengeText === "string" && activeChallenge.challengeText.trim()) {
return activeChallenge.challengeText;
}
// Falls bei einer alten Challenge kein Text hinterlegt war, generieren wir einen und speichern ihn im Kontext
const generatedText = generateGameText();
activeChallenge.challengeText = generatedText;
writeActiveChallenge(activeChallenge);
return generatedText;
}
/**
* Zeigt Feedback zum Speicherstatus des Scores (z. B. "Score erfolgreich gespeichert").
* @param {string} message - Der Feedbacktext.
* @param {string} type - Der Bootstrap-Alert-Typ (danger, warning, success, info).
*/
function showScoreSaveFeedback(message, type) {
if (!scoreSaveFeedback) return;
@@ -259,6 +448,10 @@
scoreSaveFeedback.classList.remove("d-none");
}
/**
* Speichert das Ergebnis eines normalen Spiels im Backend.
* @param {Object} scoreData - Das Score-Datenobjekt.
*/
async function saveScore(scoreData) {
const auth = getAuth();
if (!auth || !auth.username || !auth.password) {
@@ -269,7 +462,6 @@
return;
}
// Auth-Daten kommen aus login.js; der ScoreService setzt daraus die Backend-Header.
const scoreService = getScoreService();
if (!scoreService) {
showScoreSaveFeedback(
@@ -316,6 +508,338 @@
);
}
/**
* Zeigt das Endergebnis eines Duells direkt im Browser an (Sieg, Niederlage, Unentschieden).
* Wird nach der finalen Runde einer Challenge ausgeführt.
* @param {number} score - Die eigene Punktzahl.
*/
function renderChallengeResult(score) {
if (!scoreSaveFeedback || !isChallengeSecondRound()) {
return;
}
const opponentScore = Number(activeChallenge.opponentScore);
if (Number.isNaN(opponentScore)) {
return;
}
const auth = getAuth();
const ownName = auth?.username || "Du";
const opponentName = activeChallenge.opponent;
// Sieger ermitteln
const result = score > opponentScore
? "winner"
: score < opponentScore
? "loser"
: "draw";
// Texte und Bilder je nach Ausgang des Spiels konfigurieren
const headline = result === "winner"
? "Du gewinnst die Challenge"
: result === "loser"
? opponentName + " gewinnt die Challenge"
: "Unentschieden";
const outcomeText = result === "winner"
? "Gewonnen"
: result === "loser"
? "Verloren"
: "Unentschieden";
const outcomeImage = result === "winner"
? "image/sieg.png"
: result === "loser"
? "image/verloren.png"
: "image/unentschieden.png";
// Ergebnisgrafik zusammenbauen
const graphic = document.createElement("div");
graphic.className = "play-challenge-result play-challenge-result-" + result;
const outcomeHeader = document.createElement("div");
outcomeHeader.className = "challenge-outcome challenge-outcome-" + (result === "winner" ? "win" : result === "loser" ? "loss" : "draw");
const outcomeImg = document.createElement("img");
outcomeImg.src = outcomeImage;
outcomeImg.alt = outcomeText;
const outcomeLabel = document.createElement("strong");
outcomeLabel.textContent = outcomeText;
outcomeHeader.append(outcomeImg, outcomeLabel);
const title = document.createElement("div");
title.className = "play-challenge-result-title";
title.textContent = headline;
const scores = document.createElement("div");
scores.className = "play-challenge-result-scores";
const ownScore = document.createElement("div");
ownScore.className = "play-challenge-result-score";
ownScore.innerHTML = "<strong></strong><span></span>";
ownScore.querySelector("strong").textContent = ownName;
ownScore.querySelector("span").textContent = score + " Punkte";
const otherScore = document.createElement("div");
otherScore.className = "play-challenge-result-score";
otherScore.innerHTML = "<strong></strong><span></span>";
otherScore.querySelector("strong").textContent = opponentName;
otherScore.querySelector("span").textContent = opponentScore + " Punkte";
scores.append(ownScore, otherScore);
graphic.append(outcomeHeader, title, scores);
// Grafik unter dem Speicher-Feedback einfügen
scoreSaveFeedback.insertAdjacentElement("afterend", graphic);
}
/**
* Sendet den Abschluss einer Challenge an das dafür vorgesehene Challenge-Backend.
* Falls dieser Endpoint nicht existiert (altes Backend), liefert die Funktion false.
* @param {Object} scoreData - Das Score-Datenobjekt.
* @returns {Promise<boolean>} True, falls das Speichern im Challenge-Backend erfolgreich war.
*/
async function completeChallenge(scoreData) {
const auth = getAuth();
if (!auth || !hasActiveChallenge()) {
return;
}
const challengeService = getChallengeService();
if (!challengeService) {
showScoreSaveFeedback(
"Score gespeichert, aber der Challenge-Service konnte nicht geladen werden.",
"warning",
);
return;
}
const result = await challengeService.completeChallenge(
auth.username,
auth.password,
activeChallenge.id,
scoreData.score,
scoreData.time,
scoreData.text,
scoreData.userWrittenText,
);
if (!result.ok) {
console.warn("Challenge-Abschluss über API nicht möglich, nutze Nachrichten-Fallback. Status:", result.status);
return false;
}
// Challenge erfolgreich abgeschlossen
sessionStorage.removeItem(ACTIVE_CHALLENGE_STORAGE_KEY);
activeChallenge = null;
showScoreSaveFeedback(
"Challenge abgeschlossen. Beide User erhalten eine Ergebnisnachricht.",
"success",
);
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
return true;
}
/**
* Ablauf für die ERSTE Runde einer Challenge (der Geforderte hat gespielt).
* Der Score wird normal gespeichert und der Herausforderer wird benachrichtigt.
* @param {Object} scoreData - Die Score-Daten des Geforderten.
*/
async function finishFirstChallengeRound(scoreData) {
// Score im normalen Ranking ablegen
await saveScore(scoreData);
// Dem Herausforderer eine Nachricht schicken mit den erreichten Punkten
await notifyChallenger(scoreData);
sessionStorage.removeItem(ACTIVE_CHALLENGE_STORAGE_KEY);
activeChallenge = null;
showScoreSaveFeedback("Resultat wurde an den Herausforderer gesendet.", "success");
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
}
/**
* Benachrichtigt den Herausforderer per Inbox-Nachricht über das eigene Ergebnis.
* Da der Challenge-Ablauf über Nachrichten läuft, betten wir die Spieldaten
* als JSON-String in die Textnachricht ein.
* @param {Object} scoreData - Die erzielten Spieldaten.
*/
async function notifyChallenger(scoreData) {
const auth = getAuth();
const messageService = getMessageService();
if (!auth || !messageService || !activeChallenge.challenger) {
return;
}
// Zu übermittelnde Spieldaten strukturieren
const challengeData = {
id: activeChallenge.id,
challenger: activeChallenge.challenger,
opponent: auth.username,
opponentScore: scoreData.score,
challengeText: scoreData.text,
};
// Betten das JSON verschlüsselt in das Nachrichtenfeld ein
const messageText =
CHALLENGE_DATA_PREFIX +
JSON.stringify(challengeData) +
"]]" +
"\n" +
auth.username +
" hat gespielt und " +
scoreData.score +
" Punkte erreicht. Jetzt bist du dran.";
const result = await messageService.postMessage(
auth.username,
auth.password,
activeChallenge.challenger,
"challenge",
messageText,
);
if (!result.ok) {
showScoreSaveFeedback(
"Challenge wurde gespeichert, aber die Nachricht an den Herausforderer konnte nicht gesendet werden.",
"warning",
);
}
}
/**
* Ermittelt den Namen des Siegers auf Basis der Punktzahlen.
* @param {number} challengerScore - Punkte des Herausforderers.
* @param {number} opponentScore - Punkte des Gegners.
* @returns {string} Der Gewinnername oder "draw" bei Gleichstand.
*/
function getChallengeWinner(challengerScore, opponentScore) {
if (challengerScore > opponentScore) {
return activeChallenge.challenger || getAuth()?.username || "Herausforderer";
}
if (challengerScore < opponentScore) {
return activeChallenge.opponent || "Gegner";
}
return "draw";
}
/**
* Hilfsfunktion zum Senden der Abschlussnachricht (Challenge-Resultat) an den Gegner.
* @param {string} recipient - Der Empfänger der Nachricht.
* @param {Object} resultData - Das Resultatsobjekt.
* @param {string} text - Der Nachrichtentext.
* @returns {Promise<boolean>} True bei Erfolg.
*/
async function sendChallengeResultMessage(recipient, resultData, text) {
const auth = getAuth();
const messageService = getMessageService();
if (!auth || !messageService || !recipient) {
return false;
}
const messageText =
CHALLENGE_DATA_PREFIX +
JSON.stringify(resultData) +
"]]" +
"\n" +
text;
const result = await messageService.postMessage(
auth.username,
auth.password,
recipient,
"challenge",
messageText,
);
return result.ok;
}
/**
* Fallback-Ablauf für die ZWEITE Runde (Herausforderer beendet das Spiel),
* falls die direkte Complete-API des Backends fehlschlägt.
* Das Ergebnis wird berechnet und per Nachricht an den Gegner gesendet.
* @param {Object} scoreData - Die Spieldaten des Herausforderers.
*/
async function finishFinalChallengeWithMessages(scoreData) {
const auth = getAuth();
if (!auth || !activeChallenge) {
return;
}
// Eigenen Score speichern
await saveScore(scoreData);
const opponentScore = Number(activeChallenge.opponentScore);
const winner = getChallengeWinner(scoreData.score, opponentScore);
// Resultat-JSON zusammenbauen
const resultData = {
id: activeChallenge.id,
challenger: activeChallenge.challenger || auth.username,
opponent: activeChallenge.opponent,
challengerScore: scoreData.score,
opponentScore: opponentScore,
challengeText: scoreData.text,
winner: winner,
};
const winnerText = winner === "draw"
? "Unentschieden"
: "Gewinner: " + winner;
const resultText =
"Challenge abgeschlossen. " +
resultData.challenger +
": " +
resultData.challengerScore +
" Punkte, " +
resultData.opponent +
": " +
resultData.opponentScore +
" Punkte. " +
winnerText +
".";
// Das Ergebnis per Message an den Gegner übermitteln
const opponentMessageSent = await sendChallengeResultMessage(
activeChallenge.opponent,
resultData,
resultText,
);
sessionStorage.removeItem(ACTIVE_CHALLENGE_STORAGE_KEY);
activeChallenge = null;
if (!opponentMessageSent) {
showScoreSaveFeedback(
"Score gespeichert, aber die Ergebnisnachricht an den Gegner konnte nicht gesendet werden.",
"warning",
);
return;
}
showScoreSaveFeedback(
"Challenge abgeschlossen. Ergebnisnachricht wurde an den Gegner gesendet.",
"success",
);
if (typeof window.updateMessagesNavState === "function") {
window.updateMessagesNavState();
}
}
/**
* Beendet die Spielrunde, wertet die Eingabe aus, rendert die Fehler
* und leitet die Speicherung je nach Spielmodus ein.
*/
async function submitScore() {
if (!userTextInput) return;
@@ -325,14 +849,16 @@
return;
}
// Button sperren gegen Doppelklicks
if (btnSubmitScore) {
btnSubmitScore.disabled = true;
btnSubmitScore.textContent = "Wird ausgewertet...";
}
// Punktzahl berechnen
const score = calculateScore(currentGameText, userInput);
// Ergebnis sofort anzeigen; das Speichern im Backend passiert danach asynchron.
// Eingabebereich ausblenden und Ergebnisbereich einblenden
if (phaseInput) phaseInput.classList.add("d-none");
if (phaseResult) phaseResult.classList.remove("d-none");
@@ -343,21 +869,47 @@
gameStatus.style.color = "#fff";
}
// Ergebnis anzeigen
if (resultScore) resultScore.textContent = score;
renderWordComparison(currentGameText, userInput);
renderChallengeResult(score);
// Dauer der Eingabe ermitteln (mindestens 1 Sekunde)
const inputDurationSeconds = inputStartMs
? Math.max(1, Math.round((Date.now() - inputStartMs) / 1000))
: MEMORIZE_TIME_SECONDS;
// Genau dieser Rundentext wird gespeichert, damit Leaderboard/Score-Details nachvollziehbar bleiben.
const scoreData = {
score: score,
time: MEMORIZE_TIME_SECONDS,
time: inputDurationSeconds,
text: currentGameText,
userWrittenText: userInput,
};
console.log("Score bereit zum Senden:", scoreData);
try {
if (isChallengeFirstRound()) {
// Erste Runde des Duells
showScoreSaveFeedback("Resultat wird an den Herausforderer gesendet...", "info");
await finishFirstChallengeRound(scoreData);
} else if (hasActiveChallenge()) {
// Finale Runde des Duells
showScoreSaveFeedback("Challenge-Resultat wird gesendet...", "info");
let completed = false;
try {
// Versuchen über die offizielle API abzuschließen
completed = await completeChallenge(scoreData);
} catch (error) {
console.warn("Challenge-Abschluss fehlgeschlagen, nutze Nachrichten-Fallback.", error);
}
if (!completed) {
// Falls API fehlschlägt, auf den Nachrichten-Ablauf ausweichen
showScoreSaveFeedback("Backend-Abschluss nicht moeglich. Ergebnis wird ueber Nachrichten gesendet...", "info");
await finishFinalChallengeWithMessages(scoreData);
}
} else {
// Normales Spiel ohne Duell
await saveScore(scoreData);
}
} catch (error) {
console.error("Fehler beim Speichern des Scores:", error);
showScoreSaveFeedback(
@@ -372,10 +924,15 @@
}
}
/**
* Globale Initialisierungsfunktion, aufgerufen von navigation.js
* nach dem Laden von play.html.
*/
window.initPlayPage = function initPlayPage() {
clearInterval(timerInterval);
clearInterval(timerInterval); // Bestehende Timer vorsichtshalber stoppen
activeChallenge = readActiveChallenge(); // Prüfen, ob wir aus einer Challenge gestartet wurden
// Die Navigation laedt play.html per fetch; deshalb werden die Elemente erst hier gesucht.
// DOM-Referenzen holen
phaseStart = document.getElementById("phaseStart");
phaseMemorize = document.getElementById("phaseMemorize");
phaseInput = document.getElementById("phaseInput");
@@ -395,6 +952,20 @@
const btnRestart = document.getElementById("btnRestart");
const btnLeaderboard = document.getElementById("btnLeaderboard");
// Falls eine Challenge aktiv ist, Hinweistext über den Gegner und dessen Score einblenden
const challengeHint = document.getElementById("challengeHint");
if (challengeHint && activeChallenge) {
const opponentScore = activeChallenge.opponentScore !== null && activeChallenge.opponentScore !== undefined
? " Score: " + activeChallenge.opponentScore + "."
: "";
const hintPrefix = activeChallenge.role === "opponent"
? "Du spielst zuerst gegen "
: "Finale Runde gegen ";
challengeHint.textContent = hintPrefix + activeChallenge.opponent + "." + opponentScore;
challengeHint.classList.remove("d-none");
}
// Event-Listener binden
if (btnStart) btnStart.addEventListener("click", startGame);
if (btnSubmitScore) btnSubmitScore.addEventListener("click", submitScore);
if (btnRestart)
@@ -411,7 +982,9 @@
}
});
// Anti-Cheating Maßnahmen im Eingabebereich einrichten
if (userTextInput) {
// Kopieren, Einfügen, Ausschneiden und Tastenkombinationen sperren
userTextInput.addEventListener("keydown", (e) => {
const key = e.key.toLowerCase();
if (
@@ -426,8 +999,16 @@
userTextInput.addEventListener("paste", (e) => e.preventDefault());
userTextInput.addEventListener("copy", (e) => e.preventDefault());
userTextInput.addEventListener("cut", (e) => e.preventDefault());
// Sobald getippt wird, startet die Zeitmessung (falls nicht schon geschehen)
userTextInput.addEventListener("input", () => {
if (!inputStartMs) {
inputStartMs = Date.now();
}
});
}
// Textauswahl auf dem zu merkenden Text verhindern, um Kopieren via Maus zu blockieren
if (targetTextDisplay) {
targetTextDisplay.addEventListener("copy", (e) => e.preventDefault());
targetTextDisplay.style.userSelect = "none";
+210
View File
@@ -0,0 +1,210 @@
/**
* Eigene Ergebnisse (Scores) verwalten und anzeigen.
* Dieses Modul lädt nach der Initialisierung die bisherigen Spielergebnisse des
* eingeloggten Benutzers und stellt diese sortiert in einer Tabelle dar.
*/
(function () {
/**
* Formatiert Sekunden in ein lesbares MM:SS Format (z.B. 75 Sekunden -> "1:15").
* @param {number} seconds - Anzahl Sekunden.
* @returns {string} Formatiertes Zeit-String oder "-" bei ungültigem Wert.
*/
function formatTime(seconds) {
if (typeof seconds !== "number" || Number.isNaN(seconds)) {
return "-";
}
const minutes = Math.floor(seconds / 60);
const remainingSeconds = Math.floor(seconds % 60);
// padStart stellt sicher, dass Sekunden immer zweistellig ausgegeben werden (z.B. "05" statt "5")
return `${minutes}:${String(remainingSeconds).padStart(2, "0")}`;
}
/**
* Normalisiert einen Benutzernamen (Trimming und Kleinschreibung) für robuste Vergleiche.
* @param {string} username - Der Benutzername.
* @returns {string} Der bereinigte Benutzername.
*/
function normalizeUsername(username) {
return String(username ?? "").trim().toLowerCase();
}
/**
* Holt die aktuellen Authentifizierungsdaten aus dem globalen Auth-Modul.
* @returns {Object|null} Auth-Objekt (mit username/password) oder null, falls nicht angemeldet.
*/
function getLoggedInAuth() {
if (!window.AppAuth || typeof window.AppAuth.getAuth !== "function") {
return null;
}
const auth = window.AppAuth.getAuth();
if (!auth || !auth.username || !auth.password) {
return null;
}
return auth;
}
/**
* Initialisiert und liefert eine Instanz des ScoreService.
* @returns {ScoreService|null} Eine ScoreService-Instanz oder null, falls Konfiguration fehlt.
*/
function getScoreService() {
if (!window.config || !window.ScoreService) {
return null;
}
return new window.ScoreService(window.config);
}
/**
* Ermittelt den anzuzeigenden Rang eines Score-Eintrags.
* Falls das Backend keinen Platz/Rang liefert, wird die Position in der Liste (+1) als Fallback genutzt.
* @param {Object} entry - Der Score-Eintrag.
* @param {number} index - Der Listenindex des Eintrags.
* @returns {number} Der anzuzeigende Rang (1-basiert).
*/
function getDisplayedRank(entry, index) {
const place = Number(entry?.place);
if (!Number.isNaN(place) && place > 0) {
return place;
}
return index + 1;
}
/**
* Blendet eine Feedback-Nachmeldung (Erfolg/Fehler/Info) auf der Oberfläche ein.
* @param {string} message - Der anzuzeigende Text.
* @param {string} type - Der Bootstrap-Alert-Typ (danger, warning, info, success).
*/
function setFeedback(message, type) {
const feedback = document.getElementById("scores-feedback");
if (!feedback) {
return;
}
feedback.className = "alert alert-" + type + " mb-4";
feedback.textContent = message;
feedback.classList.remove("d-none");
}
/**
* Generiert die HTML-Zeilen für die Score-Tabelle aus den geladenen Einträgen.
* Sortiert die Einträge: 1. nach Platzierung (falls vorhanden), 2. nach Score (absteigend), 3. nach Zeit (aufsteigend).
* @param {Array<Object>} entries - Liste von Score-Einträgen vom Backend.
*/
function renderScores(entries) {
const tableBody = document.getElementById("scores-body");
if (!tableBody) {
return;
}
tableBody.innerHTML = "";
// Falls keine Einträge vorhanden sind, Hinweistext ausgeben
if (!Array.isArray(entries) || entries.length === 0) {
tableBody.innerHTML = '<tr><td colspan="4" class="text-center text-muted py-4">Keine eigenen Scores gefunden.</td></tr>';
return;
}
// Kopie des Arrays anlegen und sortieren
const sortedEntries = entries.slice().sort((a, b) => {
// 1. Priorität: Offizielle Platzierung (falls vorhanden)
const placeA = Number(a?.place);
const placeB = Number(b?.place);
if (!Number.isNaN(placeA) && !Number.isNaN(placeB) && placeA !== placeB) {
return placeA - placeB;
}
// 2. Priorität: Höhere Punktzahl gewinnt
const scoreA = Number(a?.score ?? 0);
const scoreB = Number(b?.score ?? 0);
if (scoreB !== scoreA) {
return scoreB - scoreA;
}
// 3. Priorität: Bei Punktgleichheit gewinnt die schnellere Zeit
const timeA = Number(a?.time ?? Number.MAX_SAFE_INTEGER);
const timeB = Number(b?.time ?? Number.MAX_SAFE_INTEGER);
return timeA - timeB;
});
// Für jeden sortierten Eintrag eine Tabellenzeile erstellen und anhängen
sortedEntries.forEach((entry, index) => {
const row = document.createElement("tr");
row.innerHTML = `
<td>${getDisplayedRank(entry, index)}</td>
<td>${entry.username ?? "-"}</td>
<td>${formatTime(entry.time)} min</td>
<td>${entry.score ?? "-"}</td>
`;
tableBody.appendChild(row);
});
}
/**
* Fordert die Scores des Benutzers vom Backend an und filtert sie.
*/
async function loadMyScores() {
const auth = getLoggedInAuth();
// Prüfen, ob der Benutzer überhaupt eingeloggt ist
if (!auth || !auth.username) {
setFeedback("Bitte logge dich ein, um deine Scores zu sehen.", "warning");
renderScores([]);
return;
}
const scoreService = getScoreService();
if (!scoreService) {
setFeedback("Score-Service konnte nicht geladen werden.", "danger");
renderScores([]);
return;
}
try {
// Scores für diesen Namen vom Backend abrufen
const result = await scoreService.getScoreByName(auth.username);
if (!result.ok || !Array.isArray(result.body)) {
setFeedback("Deine Scores konnten nicht geladen werden.", "danger");
renderScores([]);
return;
}
// Sicherheits-Filterung: Nur Scores behalten, die exakt zum aktuell eingeloggten User passen
const ownScores = result.body.filter((entry) => {
if (!entry || !entry.username) {
return false;
}
return normalizeUsername(entry.username) === normalizeUsername(auth.username);
});
if (ownScores.length === 0) {
setFeedback("Für deinen Account wurden noch keine Scores gefunden.", "info");
}
// Scores rendern
renderScores(ownScores);
} catch (error) {
console.error("Fehler beim Laden der eigenen Scores:", error);
setFeedback("Deine Scores konnten nicht geladen werden.", "danger");
renderScores([]);
}
}
/**
* Globale Initialisierungsfunktion, die von navigation.js aufgerufen wird,
* sobald die scores.html-Teilseite erfolgreich geladen wurde.
*/
window.initScoresPage = function initScoresPage() {
loadMyScores().catch((error) => {
console.error("Fehler beim Initialisieren der Scores-Seite:", error);
setFeedback("Deine Scores konnten nicht geladen werden.", "danger");
renderScores([]);
});
};
})();␍
+13 -6
View File
@@ -1,7 +1,14 @@
<div class="card">
<h4 class="card-title mb-3">Willkommen beim Lorem Ipsum Game</h2>
<p class="card-text text-uted fs-6 mb-4">Teste deine Fähigkeiten im Umgang mit Lorem Ipsum Texten! Je schneller und genauer du bist, desto höher ist dein Score.
Viel Spaß beim Spielen!</p>
<p class="card-text fs-6"> Wähle eine Option aus der Navigation, um zu starten.</p>
<img id="logo_img" src="image/Logo_loremIpsum.png" alt="Lorem Ipsum Game"class="img-fluid mt-3 d-block mx-auto">
<!-- Startseite der Anwendung -->
<div class="card mb-4 text-start">
<!-- Willkommens-Überschrift und Kurzbeschreibung des Spiels -->
<div class="mb-4">
<h2 class="fw-bold mb-1">Willkommen beim Lorem Ipsum Game</h2>
<p class="text-muted mb-0 fs-6">Teste deine Fähigkeiten im Umgang mit Lorem Ipsum Texten! Je schneller und genauer du bist, desto höher ist dein Score.</p>
</div>
<!-- Handlungsaufforderung an den Spieler -->
<p class="card-text fs-6">Wähle eine Option aus der Navigation, um zu starten. Viel Spaß beim Spielen!</p>
<!-- Projekt-Logo zentriert im unteren Bereich -->
<img id="logo_img" src="image/Logo_loremIpsum.png" alt="Lorem Ipsum Game" class="img-fluid mt-3 d-block mx-auto">
</div>
+11 -6
View File
@@ -1,11 +1,15 @@
<!-- Hauptbereich der Rangliste -->
<div class="card">
<h2 class="mb-3">Leaderboard</h2>
<!-- Rangliste (Leaderboard) - Zeigt die globalen Top-10 Spieler an -->
<div class="card mb-4 text-start">
<!-- Header-Bereich mit Titel und Kurzbeschreibung -->
<div class="mb-4">
<h2 class="fw-bold mb-1">Leaderboard</h2>
<p class="text-muted mb-0 fs-6">Hier siehst du ein Leaderboard mit den 10 besten Usern.</p>
</div>
<!-- Tabellarische Darstellung der besten Eintraege -->
<!-- Tabellarische Darstellung der besten Einträge -->
<table class="leaderboard-table">
<thead>
<!-- Spalten fuer Rang, Nutzer, Zeit und Punkte -->
<!-- Spaltenköpfe für Rang, Benutzername, benötigte Zeit und Punktzahl -->
<tr>
<th>Rank</th>
<th>User</th>
@@ -13,7 +17,8 @@
<th>Score</th>
</tr>
</thead>
<!-- Wird zur Laufzeit durch js/leaderboard.js befuellt -->
<!-- Tabellenkörper: Wird dynamisch zur Laufzeit durch js/leaderboard.js mit Zeilen befüllt -->
<tbody id="leaderboard-body"></tbody>
</table>
</div>
+22 -14
View File
@@ -1,30 +1,36 @@
<!-- Login Seite -->
<div class="card">
<h2 class="mb-3">Account</h2>
<!-- Account-Verwaltung (Login, Registrierung, Sitzungsanzeige) -->
<div class="card mb-4 text-start">
<!-- Header-Bereich mit Kurzbeschreibung -->
<div class="mb-4">
<h2 class="fw-bold mb-1">Account</h2>
<p class="text-muted mb-0 fs-6">Verwalte deine Sitzung und Account-Details.</p>
</div>
<!-- Alert-Box für Fehlermeldungen und Erfolgsmeldungen (wird per js/login.js gesteuert) -->
<div id="auth-feedback" class="alert d-none" role="status" aria-live="polite"></div>
<!-- Logout und Account löschen -->
<!-- Aktuelle Sitzung: Zeigt den Login-Status und bietet Buttons für Logout und Account löschen -->
<div class="card bg-light mb-3" id="current-session-box">
<h3 class="h5 mb-2">Aktuelle Sitzung</h3>
<p class="mb-2" id="current-session-text">Nicht eingeloggt.</p>
<h3 class="mb-2">Aktuelle Sitzung</h3>
<p class="h5 mb-2" id="current-session-text">Nicht eingeloggt.</p>
<div class="d-flex gap-2">
<button id="logout-button" type="button" class="btn btn-outline-secondary btn-sm" disabled>Logout</button>
<button id="delete-account-button" type="button" class="btn btn-danger btn-sm" disabled>Account löschen</button>
</div>
</div>
<!-- Login und Account erstellen -->
<!-- Formular-Bereich: Login und Registrierung nebeneinander (auf Desktop) -->
<div class="row g-3" id="auth-forms-row">
<!-- Linke Spalte: Login-Formular -->
<div class="col-12 col-lg-6">
<div class="card h-100">
<h3 class="h5 mb-3">Login</h3>
<h3 class="mb-3">Login</h3>
<form id="login-form">
<div class="mb-3">
<div class="h5 mb-3">
<label for="login-username" class="form-label">Username</label>
<input id="login-username" class="form-control" type="text" required maxlength="40" autocomplete="username" />
</div>
<div class="mb-3">
<div class="h5 mb-3">
<label for="login-password" class="form-label">Passwort</label>
<input id="login-password" class="form-control" type="password" required maxlength="100" autocomplete="current-password" />
</div>
@@ -33,24 +39,25 @@
</div>
</div>
<!-- Rechte Spalte: Registrierungs-Formular -->
<div class="col-12 col-lg-6">
<div class="card h-100">
<h3 class="h5 mb-3">Neuen Account erstellen</h3>
<h3 class="mb-3">Neuen Account erstellen</h3>
<form id="register-form">
<div class="mb-3">
<div class="h5 mb-3">
<label for="register-username" class="form-label">Gewünschter Username</label>
<input id="register-username" class="form-control" type="text" required maxlength="40" autocomplete="username" />
</div>
<button type="submit" class="btn btn-success">Account anlegen</button>
</form>
<p class="small mt-3 mb-0 text-muted">Hinweis: Das Passwort wird vom Backend erstellt und bei Erfolg angezeigt.</p>
<p class="text-muted mb-0 fs-6 mt-2">Hinweis: Das Passwort wird vom Backend erstellt und bei Erfolg angezeigt.</p>
</div>
</div>
</div>
</div>
<!-- Modal für Account-Erstellung -->
<!-- Bootstrap Modal: Zeigt das einmalig generierte Passwort nach erfolgreicher Account-Erstellung an -->
<div class="modal fade" id="password-modal" tabindex="-1" aria-labelledby="password-modal-label" aria-hidden="true">
<div class="modal-dialog modal-dialog-centered">
<div class="modal-content">
@@ -59,6 +66,7 @@
<button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
</div>
<div class="modal-body">
<!-- Anzeige der generierten Zugangsdaten -->
<div class="alert alert-info mb-3">
<strong>Username:</strong> <span id="modal-username"></span><br/>
<strong>Passwort:</strong> <span id="modal-password" style="font-family: monospace; background-color: #f0f0f0; padding: 4px 8px; border-radius: 4px;"></span>
+59 -4
View File
@@ -1,6 +1,61 @@
<div class="card">
<h2 class="mb-3">Nachrichten</h2>
<!-- Nachrichten- und Challenge-Dashboard -->
<div class="card messages-card mb-4 text-start">
<!-- Header-Bereich mit Aktualisierungs-Button -->
<div class="messages-header mb-4">
<div>
<h2 class="fw-bold mb-1">Nachrichten</h2>
<p class="text-muted mb-0 fs-6">Fordere andere User heraus und lies eingehende Antworten.</p>
</div>
<button class="btn btn-sm" id="refresh-messages-button" type="button">Aktualisieren</button>
</div>
<p class="mt-2">Hier kannst du deine Nachrichten ansehen und verwalten.</p>
<!-- Hier könnte eine Nachrichtenliste oder ähnliches eingebunden werden -->
<!-- Platzhalter: Wird angezeigt, wenn der Benutzer nicht angemeldet ist -->
<div id="messages-login-placeholder" class="alert alert-warning mt-3 d-none">
Melde dich zuerst an, bevor du eine Nachricht verschicken kannst.
</div>
<!-- Hauptbereich der Inbox (Sichtbar wenn eingeloggt) -->
<div id="messages-content" class="d-none">
<!-- Status- und Feedbackanzeige -->
<div id="messages-feedback" class="alert d-none mt-3 mb-0" role="alert"></div>
<div class="row g-4 mt-2">
<!-- Linke Spalte: Sidebar mit der Liste aller verfügbaren Benutzer -->
<div class="col-lg-4">
<section class="messages-panel">
<h3>User</h3>
<!-- Wird zur Laufzeit per js/messages.js mit User-Schaltflächen befüllt -->
<div id="messages-user-list" class="messages-user-list"></div>
</section>
</div>
<!-- Rechte Spalte: Formular zum Erstellen von Challenges und die Inbox -->
<div class="col-lg-8">
<!-- Sektion: Challenge senden -->
<section class="messages-panel mb-4">
<h3>Challenge senden</h3>
<form id="challenge-form" class="message-form">
<label for="challenge-recipient" class="form-label">Empfaenger</label>
<select id="challenge-recipient" class="form-select mb-3"></select>
<label for="challenge-text" class="form-label">Nachricht</label>
<textarea id="challenge-text" class="form-control mb-3" rows="3">Kannst du mich schlagen? Spiel eine Runde, dann bin ich dran.</textarea>
<button class="btn" type="submit">Challenge senden</button>
</form>
</section>
<!-- Sektion: Posteingang (Liste der empfangenen/gesendeten Nachrichten) -->
<section class="messages-panel">
<div class="messages-inbox-title">
<h3>Posteingang</h3>
<button class="btn btn-sm" id="mark-read-button" type="button">Als gelesen markieren</button>
</div>
<!-- Wird dynamisch durch js/messages.js gerendert (normale Messages & Challenge-Karten) -->
<div id="message-list" class="message-list"></div>
</section>
</div>
</div>
</div>
</div>
+27 -13
View File
@@ -1,18 +1,21 @@
<!-- Spielseite: Die vier Phasen werden per play.js ein- und ausgeblendet. -->
<div class="game-container">
<!-- Spielseite: Die vier Phasen werden dynamisch per play.js ein- und ausgeblendet. -->
<div class="game-container text-start">
<!-- Status-Badge zeigt die aktuelle Spielphase: Bereit, Lernphase, Eingabe, Abgeschlossen. -->
<div class="d-flex justify-content-between align-items-center mb-4">
<div>
<h2 class="fw-bold mb-0">Lorem Ipsum - Challenge you brain</h2>
<p class="text-muted mb-0">Merken Sie sich den Text so gut wie möglich.</p>
<!-- Status-Header: Zeigt Titel, Challenge-Hinweise und das Status-Badge der aktuellen Spielphase (Bereit, Lernphase, Eingabe, Abgeschlossen) -->
<div class="d-flex justify-content-between align-items-md-center flex-column flex-md-row mb-4">
<div class="mb-3 mb-md-0">
<h2 class="fw-bold mb-1">Lorem Ipsum - Challenge your brain</h2>
<!-- Challenge-Hinweis: Zeigt an, gegen wen und um welchen Score gespielt wird (wird per JS eingeblendet) -->
<div id="challengeHint" class="challenge-hint d-none"></div>
<p class="text-muted mb-0 fs-6">Merken Sie sich den Text so gut wie möglich.</p>
</div>
<div id="gameStatus" class="badge bg-secondary fs-6 px-3 py-2">
<!-- Status-Badge der aktuellen Spielphase -->
<div id="gameStatus" class="badge bg-secondary fs-6 px-3 py-2" style="width: fit-content;">
Bereit
</div>
</div>
<!-- Phase 1: Startbildschirm vor der Textanzeige. -->
<!-- Phase 1: Startbildschirm vor der Textanzeige -->
<div id="phaseStart" class="card">
<div class="card-body text-center py-5">
<h3 class="mb-3">Sind Sie bereit?</h3>
@@ -26,14 +29,16 @@
</div>
</div>
<!-- Phase 2: Merken. Der zufaellige Rundentext wird in #targetTextDisplay eingesetzt. -->
<!-- Phase 2: Lern-/Einprägephase. Der Runden-Text wird per JS in #targetTextDisplay eingefügt. -->
<div id="phaseMemorize" class="d-none">
<div class="card border-warning" style="border-left: 5px solid #ffd166; background-color: #fffbf0;">
<div class="card-body text-center py-4">
<h4 class="text-warning-emphasis mb-3" style="color: #b58900;">Lernphase läuft...</h4>
<!-- Rundentext-Anzeige -->
<p id="targetTextDisplay" class="lead fw-bold mb-4 fst-italic" style="color: #1b1b2f; font-size: 1.4rem; line-height: 1.6;">
<!-- Text wird per JS eingefügt -->
</p>
<!-- Countdown-Anzeige -->
<div class="mt-3">
<span class="badge bg-danger fs-6 px-3 py-2 blink-animation">
Verbleibende Zeit: <span id="timerDisplay">15</span>s
@@ -43,11 +48,12 @@
</div>
</div>
<!-- Phase 3: Eingabe aus dem Gedaechtnis. Der Originaltext ist hier bewusst ausgeblendet. -->
<!-- Phase 3: Eingabephase. Der Originaltext wird ausgeblendet und das Textfeld wird fokussiert. -->
<div id="phaseInput" class="d-none">
<div class="card">
<div class="card-body">
<label for="userTextInput" class="form-label fw-bold mb-2">Geben Sie den Text aus dem Gedächtnis ein:</label>
<!-- Eingabefeld für den gemerkten Text (Cheating-Sperren in play.js verhindern Copy/Paste) -->
<textarea id="userTextInput" class="form-control mb-3" rows="8" placeholder="Tippen Sie hier den gemerkten Text ein..."></textarea>
<div class="d-grid">
<button id="btnSubmitScore" class="btn btn-success btn-lg" style="background-color: #28a745; border: none;">
@@ -58,23 +64,28 @@
</div>
</div>
<!-- Phase 4: Auswertung inklusive Backend-Feedback und Vergleich Original/Eingabe. -->
<!-- Phase 4: Auswertungs- und Ergebnisphase (inklusive API-Feedback und farbigem Wortvergleich) -->
<div id="phaseResult" class="d-none">
<div class="card text-center" style="border-top: 5px solid #28a745;">
<div class="card-body py-5">
<h3 class="text-success mb-2">Ergebnis</h3>
<!-- Erzielte Punktzahl -->
<div class="display-1 fw-bold my-4" id="resultScore" style="color: #4a6fa5;">0</div>
<p class="text-muted mb-5">Punkte (korrekte Wörter an der richtigen Position)</p>
<!-- Wird von saveScore() befuellt: gespeichert, nur lokal berechnet oder Fehler. -->
<!-- Feedback-Box für API-Antworten (wird per JS befüllt) -->
<div id="scoreSaveFeedback" class="alert d-none mb-4" role="alert"></div>
<!-- Wortvergleich: Gegenüberstellung des Originaltexts und der Eingabe -->
<div class="row g-4 text-start mb-5">
<!-- Originaltext mit rot/grünen Wort-Badges -->
<div class="col-md-6">
<div class="p-3 h-100" style="background: #f8f9fa; border-radius: 8px;">
<small class="text-muted d-block mb-2 text-uppercase fw-bold" style="font-size: 0.75rem;">Originaltext</small>
<p class="mb-0 fst-italic" id="resultOriginal" style="font-size: 0.95rem; line-height: 1.5;"></p>
</div>
</div>
<!-- Benutzereingabe mit rot/grünen Wort-Badges -->
<div class="col-md-6">
<div class="p-3 h-100" style="background: #f8f9fa; border-radius: 8px;">
<small class="text-muted d-block mb-2 text-uppercase fw-bold" style="font-size: 0.75rem;">Ihre Eingabe</small>
@@ -83,6 +94,7 @@
</div>
</div>
<!-- Navigation nach dem Spiel -->
<div class="d-flex justify-content-center gap-3">
<button id="btnRestart" class="btn px-4">
Nochmal spielen
@@ -97,3 +109,5 @@
</div>
</div>
+29 -4
View File
@@ -1,6 +1,31 @@
<div class="card">
<h2 class="mb-3">Meine Scores</h2>
<!-- Eigene Scores-Ansicht des angemeldeten Benutzers -->
<div class="card mb-4 text-start">
<!-- Header-Bereich mit Titel und Kurzbeschreibung -->
<div class="mb-4">
<h2 class="fw-bold mb-1">Meine Scores</h2>
<p class="text-muted mb-0 fs-6">Hier siehst du alle gespeicherten Scores deines Accounts.</p>
</div>
<p class="mt-2">Hier kannst du deine bisherigen Scores einsehen.</p>
<!-- Hier könnte eine Score-Tabelle oder ähnliches eingebunden werden -->
<!-- Alert-Box für Rückmeldungen (wird bei Fehlern/Info-Meldungen per js/scores.js eingeblendet) -->
<div id="scores-feedback" class="alert d-none mb-4" role="alert"></div>
<!-- Tabelle zur Auflistung der eigenen Scores -->
<div class="table-responsive">
<table class="table leaderboard-table mb-0">
<thead>
<tr>
<th scope="col">Rang</th>
<th scope="col">User</th>
<th scope="col">time</th>
<th scope="col">Score</th>
</tr>
</thead>
<!-- Tabellenkörper: Wird per js/scores.js mit den eigenen Ergebnissen des Users befüllt -->
<tbody id="scores-body">
<tr>
<td colspan="4" class="text-center text-muted py-4">Lade Scores ...</td>
</tr>
</tbody>
</table>
</div>
</div>