Add comprehensive German project README and AI documentation briefing

This commit is contained in:
Jonas
2026-03-13 00:16:52 +01:00
parent 7a073b6fff
commit d9cecb27fa
2 changed files with 320 additions and 1 deletions
+227
View File
@@ -0,0 +1,227 @@
# AI-Briefing: Vollständige Projektdokumentation für **4Gewinnt**
> Zweck dieses Dokuments: Du kannst diese Datei direkt an ein anderes KI-System geben, damit daraus alle geforderten Artefakte erstellt werden:
>
> - **Pflichtenheft**
> - **Meilensteinplanung**
> - **Klassendiagramm**
> - **Ablaufplan / Flowchart**
> - **Benutzerdokumentation / Anleitung**
---
## 1) Kurzbeschreibung des Projekts
**4Gewinnt** ist ein Multiplayer-Spielprojekt mit zwei Hauptteilen:
1. **Backend (API)**: ASP.NET Core Web API mit SignalR für Echtzeitkommunikation.
2. **Frontend (GUI)**: Vue 3 + TypeScript + Vite für die Benutzeroberfläche.
Das System ermöglicht die Erstellung und den Beitritt zu Spielrunden über einen **6-stelligen Spielcode**. Züge werden in Echtzeit verarbeitet und an alle Spieler verteilt.
---
## 2) Technologiestack
### Backend
- .NET 9
- ASP.NET Core Web API
- SignalR
- Swashbuckle/OpenAPI (Swagger in Development)
### Frontend
- Vue 3
- TypeScript
- Vite
- SignalR JavaScript Client
- Vuetify
---
## 3) Verzeichnisstruktur (relevant für Doku und Diagramme)
```text
4Gewinnt/
├── API/
│ ├── Controllers/
│ │ ├── GameHubSocket.cs
│ │ └── StatusController.cs
│ ├── Models/
│ │ ├── DataClasses/
│ │ └── Game/
│ ├── Repository/GameRepo/
│ │ ├── IGameRepository.cs
│ │ └── GameRepository.cs
│ ├── Services/GameManager/
│ │ ├── IGameManager.cs
│ │ └── GameManager.cs
│ └── Program.cs
├── GUI/
│ ├── src/components/
│ ├── src/routes/
│ ├── src/scripts/logic/
│ ├── src/scripts/signalR/
│ └── src/scripts/interfaces/
└── 4Gewinnt.sln
```
---
## 4) Systemverhalten (fachlich)
### Kern-Use-Cases
1. Spieler erstellt ein Spiel mit Name + Spielfeldgröße.
2. Backend erzeugt neue Spielinstanz + 6-stelligen Spielcode.
3. Zweiter Spieler tritt mit Spielcode bei.
4. Bei zwei Spielern startet das Spiel automatisch.
5. Spieler setzen abwechselnd Steine in Spalten.
6. Backend prüft Gewinnbedingung oder Unentschieden.
7. Bei Spielende wird Ergebnis an beide Clients gesendet.
8. Bei Disconnect eines Spielers wird das Spiel beendet.
### Spielzustände
- `Lobby`
- `Running`
- `Ended`
---
## 5) Backend-Architektur (für Klassendiagramm & Ablaufdiagramm)
### Schichten
- **Controller/Hub-Schicht**: Eingangspunkte via REST (`StatusController`) und SignalR (`GameHubSocket`).
- **Service-Schicht**: `GameManager` orchestriert Spielablauf und Regeln.
- **Repository-Schicht**: `GameRepository` hält Spiele im Speicher.
- **Domänenmodell**: `Game`, `GameField`, `Player`, DTOs, Value Objects.
### Wichtige Domänenobjekte
- `Game`: Id, GameCode, Players, CurrentTurn, State, Field
- `GameField`: Spielfeldmatrix, Drop-Operation, Gewinnprüfung
- `Player`: Name, ConnectionId, PlayerTag
- `GameInformationDto`: serialisierte Spielinformationen für Clients
- `SixDigitInt`: Repräsentation/Validierung eines 6-stelligen Codes
### SignalR-Hub Methoden
- `CreateGame(playerName, gFs)`
- `JoinGame(playerName, gameCode)`
- `RequestGameInformation(gameId)`
- `Drop(gameId, column)`
- `OnDisconnectedAsync(exception)`
### Wichtige SignalR-Events an Clients
- Fehler: `Error`
- Erfolg: `GameCreated`, `GameJoined`, `GameStarted`
- Spielupdates: `GameInformation`, `FieldUpdated`
- Spielende: `GameEnded`
- Aufräumen: `GameDestroyed`
---
## 6) Frontend-Architektur (für Benutzerdoku)
### Seiten / Routen
- Startseite (`Home.vue`)
- Online-Modus (`OnlineMode.vue`)
- Lokaler Modus (`LocalMode.vue`)
### Relevante Komponenten
- `CreateOrJoinMenu.vue`
- `GameCreationMenu.vue`
- `GameJoinMenu.vue`
- `Field.vue` (Spielbrett)
- `InfoField.vue` (Statusanzeige)
- `GameEndedMenu.vue`
### Logikmodule
- Online-Logik: `OnlineGame.ts`
- Lokal-Logik: `LocalGame.ts`
- SignalR-Verbindung: `GameConnection.ts`
---
## 7) Build-, Run- und Übergabeanleitung (technisch)
## Voraussetzungen
- .NET SDK 9
- Node.js 20+ (oder >=22.12)
- npm
### Lokale Entwicklung
#### Backend starten
```bash
cd API
dotnet run
```
#### Frontend starten
```bash
cd GUI
npm install
npm run dev
```
### Produktionsnahe Builds
#### Frontend Build
```bash
cd GUI
npm install
npm run build
```
#### Backend Build
```bash
cd API
dotnet build
```
### Optional: Gesamtlösung bauen
```bash
dotnet build 4Gewinnt.sln
```
---
## 8) Konkrete Arbeitsaufträge an die AI (Copy/Paste-Prompts)
Nutze die folgenden Prompts 1:1 oder angepasst.
### A) Prompt: Pflichtenheft
> Erstelle ein vollständiges Pflichtenheft auf Deutsch für das Softwareprojekt „4Gewinnt“ (Web-App mit ASP.NET Core + SignalR + Vue 3). Struktur: Zielbestimmung, Produkteinsatz, funktionale Anforderungen (mit Muss/Soll/Kann), nicht-funktionale Anforderungen, Systemgrenzen, Datenmodell, Akzeptanzkriterien, Risiken, Annahmen, Glossar. Berücksichtige Multiplayer über Spielcode, Echtzeit-Züge, Spielzustände Lobby/Running/Ended, Fehlerfälle (ungültiger Zug, volles Spiel, Disconnect), sowie Bedienbarkeit für Endnutzer.
### B) Prompt: Meilensteinplanung
> Erstelle eine realistische Meilensteinplanung (Deutsch) für ein studentisches/prototypisches 4Gewinnt-Projekt mit Backend, Frontend und Dokumentation. Liefere: Zeitachse (Wochen), Milestones, Deliverables pro Meilenstein, Abhängigkeiten, Risiken, Puffer, Definition of Done pro Meilenstein und eine Tabelle für Projekttracking.
### C) Prompt: Klassendiagramm
> Erstelle ein UML-Klassendiagramm in PlantUML für die Kernklassen des Projekts „4Gewinnt“ basierend auf folgender Architektur: GameHubSocket (SignalR Hub), GameManager (Service), IGameRepository/GameRepository, Game, GameField, Player, GameInformationDto, SixDigitInt. Zeige Attribute, zentrale Methoden und Relationen (Assoziation, Abhängigkeit, Interface-Implementierung). Ergänze kurze Erläuterungen.
### D) Prompt: Ablaufplan / Flowchart
> Erstelle ein detailliertes Flowchart (Mermaid) für den Online-Spielablauf von „4Gewinnt“: Spiel erstellen → Spiel beitreten → Spielstart → Zug senden → Validierung → Feldupdate → Gewinn-/Unentschiedenprüfung → Spielende → optionales Rematch/Neues Spiel. Berücksichtige Fehlerpfade (Spiel nicht gefunden, Spiel voll, ungültiger Zug, Spieler disconnected).
### E) Prompt: Benutzerdokumentation
> Erstelle eine benutzerfreundliche Anleitung auf Deutsch für Endanwender von „4Gewinnt“ (Weboberfläche): Spiel erstellen, Spiel beitreten, Spielfeld bedienen, Bedeutung von Farben/Symbolen, Fehlermeldungen, Spielende, Neustart. Füge zusätzlich einen Troubleshooting-Abschnitt und FAQ hinzu.
---
## 9) Qualitätskriterien für die von AI erzeugten Dokumente
Die Ergebnisse sollten:
- vollständig strukturiert und in sauberem Fachdeutsch sein,
- klare Überschriftenebenen besitzen,
- Tabellen dort nutzen, wo Vergleich/Planung sinnvoll ist,
- konkrete, überprüfbare Kriterien enthalten (insb. Akzeptanzkriterien),
- direkt für Abgabe/Projektmappe weiterverwendbar sein.
---
## 10) Optional: Zusatzauftrag für AI
> Erzeuge aus allen Ergebnissen ein einheitliches Doku-Paket mit konsistenten Begriffen (z. B. Spiel, Runde, Match, Lobby), einheitlichem Glossar und identischen Rollenbezeichnungen.
+93 -1
View File
@@ -1 +1,93 @@
# 4Gewinnt
# 4Gewinnt 🎮
Ein modernes **Vier-Gewinnt**-Projekt mit:
- **ASP.NET Core Web API + SignalR** (Backend)
- **Vue 3 + TypeScript + Vite** (Frontend)
Ziel ist ein flüssiges Online-Spielerlebnis mit Lobby/Spiel-Code, Echtzeit-Zügen und sauberer Trennung zwischen UI und Spiellogik.
## Features
- Online-Multiplayer über SignalR-Hub (`/api/gamehub`)
- Spielfelder mit variabler Größe
- Lobby-System mit 6-stelligem Spielcode
- Spielstatus-Events in Echtzeit (`GameStarted`, `FieldUpdated`, `GameEnded`)
- Lokaler Modus im Frontend
## Projektstruktur
```text
4Gewinnt/
├── API/ # .NET 9 Backend (REST + SignalR)
│ ├── Controllers/ # HTTP- und Hub-Endpunkte
│ ├── Models/ # Domänenmodelle (Game, Player, Field, DTOs)
│ ├── Repository/ # In-Memory Datenhaltung
│ └── Services/ # GameManager mit Spielregeln/Use-Cases
├── GUI/ # Vue 3 Frontend
│ ├── src/components/ # UI-Komponenten
│ ├── src/routes/ # Seiten (Local/Online)
│ └── src/scripts/ # Spiel- und SignalR-Logik
└── 4Gewinnt.sln
```
## Voraussetzungen
- **.NET SDK 9**
- **Node.js 20+** (laut `package.json`: `^20.19.0 || >=22.12.0`)
- npm
## Schnellstart (Entwicklung)
### 1) Backend starten
```bash
cd API
dotnet run
```
Backend läuft standardmäßig auf einem lokalen ASP.NET-Port (siehe Terminalausgabe).
### 2) Frontend starten
```bash
cd GUI
npm install
npm run dev
```
Danach Vite-URL im Browser öffnen (z. B. `http://localhost:5173`).
## Build für Produktion
### Frontend bauen
```bash
cd GUI
npm install
npm run build
```
### Backend bauen
```bash
cd API
dotnet build
```
## API/Hub-Überblick
- Healthcheck: `GET /api/status`
- SignalR Hub: `/api/gamehub`
- `CreateGame(playerName, gFs)`
- `JoinGame(playerName, gameCode)`
- `RequestGameInformation(gameId)`
- `Drop(gameId, column)`
## Hinweise
- Das Spiel verwendet derzeit eine In-Memory-Repository-Implementierung (kein persistenter Speicher).
- Bei Disconnects oder Spielende werden Spiele zeitgesteuert entfernt.
---
Wenn du möchtest, kann ich im nächsten Schritt noch eine **Architektur-Grafik** (Mermaid) direkt ins README ergänzen.