# Software-Engineering-Projekt „Drinkabell": Schritt-für-Schritt-Anleitung

## Schritt 1 — Kick-off-Meeting (einmalig, 90 Minuten)

**Wann:** so schnell wie möglich. **Wer:** das ganze Team. **Braucht:** Laptop, diese Anleitung, `Drinkabell_Konzept.md`.

Kopiert diese Agenda:

```
KICK-OFF (90 min)
1. Rollen verteilen ......................... 15 min
2. Tools einrichten (live am Beamer) ........ 30 min
3. Vorgehensmodell beschließen .............. 15 min
4. Aufgaben ins Board + nächste Termine ..... 30 min
```

### 1a) Rollen verteilen (15 min)

Geht die Liste durch und nennt pro Rolle eine Hauptperson + eine Vertretung (bei 4–5 Leuten trägt jeder 1–2 Hüte, das ist normal und erlaubt):

| Rolle | Was diese Person im Projekt tut |
|---|---|
| **Projektmanager:in** | Leitet Meetings, achtet auf Termine, aktualisiert Plan & Risiken, Ansprechpartner:in für den Dozenten |
| **Software-Architekt:in** | Entscheidet Technik (Engine, Sprache), entwirft Code-Struktur, macht die Architektur-Diagramme |
| **Software-Entwickler:in** | Programmiert Features, macht Code-Reviews |
| **Tester:in** | Schreibt Testfälle, testet Builds, dokumentiert Fehler als Tickets |
| **Gamedesigner:in** | Balanciert Mechaniken (Sichtkreis, Alkohol-Druck), designt Level (Wald → Vulkan → Indien), hütet die Spielvision |

**Ergebnis:** Eine Tabelle `Rolle | Name | Vertretung` → speichert als `docs/team.md` im Repo.

### 1b) Tools einrichten (30 min)

Eine Person macht das live vor, alle anderen schauen zu und machen mit:

1. **Git-Repo anlegen** (z. B. GitHub, privat, alle als Collaborators). Das ist gleichzeitig eure Dokumentenablage: Ordner `docs/` anlegen.
2. **Projektverwaltungstool**: Bei GitHub direkt **Projects** nutzen → Board mit 5 Spalten: `Backlog` → `Diese Woche` → `In Arbeit` → `Review` → `Fertig`.
3. **Kommunikation**: Discord-Server oder WhatsApp-Gruppe.
4. **Feste Termine**: 1× pro Woche Team-Meeting (60–90 min), zusätzlich kurz Daily (10 min, kann auch async in Discord sein).

**Warum das so wichtig ist:** Die Unit-0-Folien sagen wörtlich „Kontinuierliche Pflege des Projektverwaltungstools" ist ein Bewertungskriterium. Ein leeres Board am Präsentationstag = Punkte weg.

**Regel für die Zukunft:** Jede Aufgabe, die jemand tut, wird ein Ticket auf dem Board. Keine Arbeit ohne Ticket.

### 1c) Vorgehensmodell beschließen (15 min)

Ihr müsst nur EINE Entscheidung treffen und aufschreiben. Die Vorlesung empfiehlt für Spielprojekte eh schon: **Scrum + V-Modell-Elemente fürs Testen**. Nehmt das, begründet es – fertig.

Kopiert das nach `docs/vorgehensmodell.md` und passt es an:

```markdown
# Vorgehensmodell

Wir arbeiten mit **Scrum** in 3-Wochen-Sprints, abgestimmt auf die
Präsentationstermine (05.11., 26.11., 15.12., 19.01.).
Jeder Sprint endet mit einer Präsentation (Sprint Review).

**Begründung:**
- Die Anforderungen ändern sich während der Entwicklung (typisch für
  Spiele: Mechaniken werden ausprobiert und verworfen – bei Drinkabell
  z. B. die Frage taktbasierte Steuerung vs. Betrunkenheits-Steuerung) →
  ein sequentielles Modell wie Wasserfall wäre zu unflexibel.
- Wir sind ein kleines Team (4–5 Personen) → agil machbar.
- Die festen Präsentationstermine geben uns von außen vorgegebene
  Sprintgrenzen mit regelmäßigem Feedback.

**Anpassungen (Hybrid mit V-Modell-Gedanken):**
- Zu jeder Entwicklungsphase planen wir die passende Testaktivität
  (V-Modell-Prinzip): zu Anforderungen → Abnahmekriterien,
  zu Architektur → Integrationstests, zu Implementierung → Modultests.
- Kein vollständiges Scrum-Zeremoniell: Product Owner und Scrum Master
  Rollen übernehmen Teammitglieder nebenher.

**Artefakte:** Product Backlog (GitHub Projects), Sprint Backlog,
Risikoregister, Lastenheft.
```

**Ergebnis:** Ein Dokument, das die Frage „Welches Vorgehensmodell und warum?" endgültig beantwortet. Nie wieder drüber diskutieren.

### 1d) Aufgaben ins Board (30 min)

Legt für jeden offenen Punkt dieser Anleitung ein Ticket an. Zuweisen, Frist = nächster Präsentationstermin.

---

## Schritt 2 — Anforderungs-Workshop (90 Minuten)

**Wann:** noch vor dem 05.11. **Wer:** ganzes Team. **Das Ergebnis:** eine Anforderungstabelle. Das ist der Kern eures späteren Lastenhefts.

Kopiert diese Agenda:

```
ANFORDERUNGS-WORKSHOP (90 min)
1. Stilles Brainstorming .................... 10 min
2. Vorlesen + Clustern ...................... 20 min
3. Funktional / nicht-funktional markieren .. 15 min
4. Priorisieren (MoSCoW) .................... 20 min
5. In Tabelle überführen .................... 25 min
```

### 2a) Stilles Brainstorming (10 min)

Jeder allein, auf Zettel oder in ein geteiltes Dokument: Sätze der Form **„Der Spieler kann …"** und **„Das Spiel soll …"** schreiben. Ziel: 20–30 Rohideen. Quelle ist euer Drinkabell-Konzept – die Mechaniken stehen dort schon halb fertig (Sichtkreis, Alkohol-Mechanik, Begleiter, Arenen …).

### 2b) Vorlesen + clustern (20 min)

Reihum vorlesen, Duplikate streichen, auf ein Whiteboard/Miro gruppieren:

`Kern-Gameplay (Sichtkreis & Angriff)` · `Alkohol-/Druck-Mechanik` · `Begleiter & Münzen` · `Level & Arenen` · `UI & Menüs` · `Audio` · `Speichern/Laden`

### 2c) Funktional vs. nicht-funktional (15 min)

Die Unterscheidung aus der Vorlesung, praktisch angewendet:

- **Funktional** = WAS das System tut → beschreibt ein **Verhalten**. („Die Fee erleidet Schaden, wenn sie Kobolde ignoriert")
- **Nicht-funktional** = WIE gut das System etwas tut → eine **Qualität/Eigenschaft**. („Levelstart < 3 s", „stabile 60 FPS", „Kernmechanik in 5 Minuten verstanden")

**Merkhilfe:** Funktional könnte man in einer Demo *vorführen*. Nicht-funktional misst oder empfindet man.

### 2d) Priorisieren mit MoSCoW (20 min)

Geht die Liste durch und vergibt:

- **M**ust – ohne das ist Drinkabell kein Drinkabell (Sichtkreis, Alkohol-Druck, Grundbewegung)
- **S**hould – wichtig, aber ein Release auch ohne denkbar (Begleiter-System, Ameisen-Polizei, Arenen)
- **C**ould – nettes Extra, wenn Zeit übrig ist (Marienkäfer-Taxi, zweiter Begleiter)
- **W**on't – bewusst NICHT in diesem Projekt (auch aufschreiben! Das zeigt Abgrenzung und schützt vor Scope Creep)

**Streit-Regel:** Wenn zwei Ideen kämpfen, gewinnt die, die näher an der Spielvision liegt („Spieler ist die Antagonistin"). Bei Gleichstand entscheidet die Rolle Projektmanager:in.

### 2e) In Tabelle überführen (25 min)

→ `docs/anforderungen.md`. Hier ein *(Beispiel)*, wie das für Drinkabell aussehen könnte – nehmt es als Startpunkt und ergänzt eure eigenen Punkte:

```markdown
# Anforderungen – Drinkabell

## Funktionale Anforderungen
| ID    | Anforderung                                                              | MoSCoW |
|-------|--------------------------------------------------------------------------|--------|
| FA-01 | Die Fee bewegt sich per taktbasierter Steuerung durch das Level          | Must   |
| FA-02 | Die kurzsichtige Fee hat einen sichtbaren Sichtkreis um sich             | Must   |
| FA-03 | Kobolde außerhalb des Sichtkreises können nicht angegriffen werden       | Must   |
| FA-04 | Kobolde erleiden psychischen Schaden, wenn die Fee sie NICHT angreift    | Must   |
| FA-05 | Die Level folgen dem Weg: Wald → Vulkan → Indien                         | Must   |
| FA-06 | Hauptmenü mit Start, Optionen, Beenden                                   | Must   |
| FA-07 | Arenen werden als Pilzkreise dargestellt                                 | Should |
| FA-08 | Mit gesammelten Münzen kann man sich einen Begleiter kaufen              | Should |
| FA-09 | Ameisen-Polizei verfolgt die Fee ab und zu                               | Should |
| FA-10 | Marienkäfer-Taxi für schnelles Reisen                                    | Could  |

## Nicht-funktionale Anforderungen
| ID     | Anforderung                                              | MoSCoW |
|--------|----------------------------------------------------------|--------|
| NFA-01 | Levelstart bis spielbar dauert < 3 Sekunden              | Must   |
| NFA-02 | Stabile 60 FPS auf den Rechnern der Teammitglieder       | Should |
| NFA-03 | Komplett per Tastatur spielbar (keine Maus nötig)        | Must   |
| NFA-04 | Kernmechanik (Sichtkreis + Druck) ist nach 5 Min verstanden | Should |

## Won't (dieses Projekt bewusst NICHT)
- Online-Multiplayer
- Prozedural generierte Level (statt dessen: feste Level)
- Eigener Soundtrack (freie Assets werden verwendet)
```

**Qualitätsregeln aus der Vorlesung (beim Schreiben beachten):**
- Eindeutig formulieren: kein „könnte", „vielleicht", „möglichst"
- Testbar: man muss hinterher sagen können, ob es erfüllt ist oder nicht
- Versionieren: deshalb liegt das im Git-Repo und nicht auf einem USB-Stick

---

## Schritt 3 — User Stories & Use Cases erstellen

**Wann:** direkt nach dem Workshop oder im nächsten Meeting.

### User Stories (fürs Backlog / Board)

Nimm die **Must**-Anforderungen und mach daraus Stories. Format:

```markdown
# US-02: Alkohol-Druck
**Als** Spielerin **möchte ich** unter steigendem Druck stehen, wenn ich
Kobolde ignoriere, **um** das Spannungsfeld zwischen Schleichen und
Angreifen zu spüren.

**Akzeptanzkriterien:**
- Kobolde im Sichtkreis erzeugen pro Sekunde Druckpunkte (Startwert: 5)
- Ab 100 Druckpunkten erleidet die Fee Schaden
- Druck steigt nur, solange Kobolde im Sichtkreis sind *(Beispielwerte – mit eurem Gamedesigner abstimmen)*
```

Akzeptanzkriterien = die Checkliste, die der Tester später abhakt. Pro Story 2–4 Kriterien.

**INVEST-Check** (aus der Vorlesung, kurz übersetzt): die Story soll **u**nabhängig von anderen Stories sein, **v**erhandelbar im Detail, **w**ertvoll für den Spieler, **s**chätzbar, **k**lein (in 1–2 Tagen machbar), **t**estbar. Ist eine Story zu groß (z. B. „Als Spieler möchte ich kämpfen können") → in mehrere kleine schneiden.

### Use Cases (nur für die 3–4 Kernabläufe des Spiels)

Ein Use Case beschreibt einen kompletten Ablauf Schritt für Schritt. Ihr braucht nicht für alles einen – für die Hauptspielabläufe reicht. *(Beispiel)*:

```markdown
# Use Case: Fee betritt eine Arena (Pilzkreis)

**Akteur:** Spielerin (Fee)
**Vorbedingung:** Fee bewegt sich im Level, Sichtkreis aktiv

**Hauptszenario:**
1. Fee betritt den Pilzkreis
2. System sperrt den Ausgang der Arena
3. System platziert 3 Kobolde im Arenabereich
4. Spielerin entscheidet pro Zug: angreifen oder Position halten
5. Nicht angegriffene Kobolde erzeugen steigenden Druck
6. Alle Kobolde besiegt → System öffnet den Ausgang, vergibt Münzen

**Alternativszenarien:**
- 5a. Druck erreicht 100 → Fee erleidet Schaden
- 6a. Fee verliert alle Lebenspunkte → Game-Over-Bildschirm, Rückkehr zum Levelstart
- 1a. Begleiter (Kakerlake) im Besitz → dieser kämpft mit, Druck steigt langsamer

**Nachbedingung:** Arena abgeschlossen, Fee steht am Ausgang, Münzguthaben aktualisiert.
```

**Faustregel, wann was:** Kleines Feature → User Story. Kompletter Ablauf mit Verzweigungen/Fehlerfällen → Use Case.

---

## Schritt 4 — Schätzen (Planning Poker, 60 min im Team)

**Wann:** wenn das Backlog erste Stories hat (vor dem 26.11.). **Braucht:** Story-Liste, Karten mit 1, 2, 3, 5, 8, 13, 21 (Papier reicht, oder planningpokeronline.com in einem kleinen Fenster).

**Ablauf pro Story (2–4 min):**
1. Eine Person liest die Story vor.
2. Alle dürfen kurz Rückfragen stellen.
3. **Jeder** wählt heimlich eine Karte.
4. Auf Kommando zeigen alle gleichzeitig.
5. Zeigt jemand „13" und alle anderen „2" → die 13-Person erklärt, was sie fürchtet (oft entdeckt sie einen Fall, den keiner bedacht hat!) → kurz diskutieren → **erneut schätzen**.
6. Ergebnis notieren.

**Story Points verstehen:** Das ist kein Zeitwert, sondern **relativer Aufwand**. Trick zum Start: Sucht die kleinste, langweiligste Story und sagt „das sind 2 SP". Alles andere wird relativ dazu geschätzt. Zum Planen übersetzt ihr grob: als Startannahme gilt **1 SP ≈ 2–3 Stunden Arbeit pro Person** – nach Sprint 1 wisst ihr besser und kalibriert neu.

**Für die 3–5 riskantesten Aufgaben zusätzlich PERT** (Dreipunktschätzung aus der Vorlesung). *(Beispiel)*:

```
Story "Taktbasierte Steuerung der Fee":
O (optimistisch)  = 6 h
M (realistisch)   = 10 h
P (pessimistisch) = 24 h
Erwartungswert = (6 + 4×10 + 24) / 6 = 11,7 h
```

**Und dann der Puffer:** Addiert auf euren Gesamtaufwand **20 %** Puffer (Vorlesung: 15–25 %). Das ist keine Konservenschwindelei, sondern einkalkulierte Krankheit, Prüfungsphasen und kaputte Builds. Kommuniziert den Aufwand als **Range** („ca. X ± 20 %"), nicht als fixen Termin – das steht so in der Vorlesung.

**Ergebnis:** Tabelle `Story | SP | (für große Items: O/M/P/E) | Verantwortlich`.

---

## Schritt 5 — Risikoregister anlegen (45 min im Team)

**Was ein Risiko hier ist:** alles, was euren Plan zerschießen könnte. Nicht abstrakt denken, sondern konkret bei Drinkabell.

Ablauf:
1. **Brainstorming (10 min):** „Was könnte uns den Plan sprengen?" – Ideen-Sparks: Ausfall eines Teammitglieds, Scope Creep („könnten wir nicht noch …"), Engine-Lernkurve, Performance-Probleme, Merge-Konflikte, zu optimistische Schätzungen, ungelöste Design-Fragen.
2. **Bewerten (15 min):** Wahrscheinlichkeit (1–5) × Auswirkung (1–5) = Score.
3. **Maßnahmen (20 min)** für alles mit Score ≥ 6. Je Strategie aus der Vorlesung: *vermeiden / reduzieren / transferieren / akzeptieren* – und immer einen **Risk Owner** nennen (eine Person, die dranbleibt).

→ `docs/risiken.md`. *(Beispiel)* für Drinkabell – beachtet R-02, das steht wirklich so offen in eurem Konzept:

```markdown
# Risikoregister – Drinkabell (Stand: 23.10.2026, wöchentlich zu aktualisieren)

| ID  | Risiko                                      | W | A | Score | Maßnahme                                                      | Owner        | Status |
|-----|---------------------------------------------|---|---|-------|----------------------------------------------------------------|--------------|--------|
| R-01| Kernsteuerung ungeklärt: taktbasiert ODER Betrunkenheits-Steuerung – Konzept lässt beides offen | 4 | 5 | 20 🔴 | Beide Varianten als Mini-Prototyp an 1 Wochenende testen, dann decision (Design-Freeze) | Gamedesigner | Offen |
| R-02| Scope Creep (neue Feature-Ideen)            | 4 | 4 | 16 🔴 | Neue Ideen nur über Change-Request-Prozess + MoSCoW-Won't-Liste | Gamedesigner | Offen |
| R-03| Alkohol-Mechanik frustrierend/unfair balanciert | 3 | 4 | 12 🟡 | Frühe Playtests mit Kommilitonen ab Sprint 2, Druckwerte als Parameter konfigurierbar bauen | Tester | Offen |
| R-04| Teammitglied fällt längere Zeit aus         | 3 | 5 | 15 🔴 | Paar-Programmierung, keine Person ist alleiniger Besitzer eines Moduls | PM | Offen |
| R-05| Zu optimistische Schätzungen                | 4 | 3 | 12 🟡 | Planning Poker statt Bauchgefühl, 20 % Puffer, PERT bei großen Items | PM | Offen |
| R-06| Engine-Lernkurve frisst Zeit                | 3 | 3 | 9  🟡 | Gemeinsames Tutorial-Wochenende vor Sprint 1 | Architekt | Offen |
| R-07| Merge-Konflikte im Code                     | 3 | 2 | 6  🟡 | Kleine Branches, täglich mergen, Code-Review | Architekt | Überwacht |

Score-Farben (Vorlesung): 1–5 grün = akzeptieren · 6–12 gelb = überwachen · 13–25 rot = sofort handeln
```

**Pflege:** Jedes Wochen-Meeting 5 Minuten: Status updaten, neue Risiken ergänzen, erledigte schließen. Das „wöchentlich aktualisieren" steht explizit in den Folien.

---

## Schritt 6 — Plan & Struktur sichtbar machen (für den 26.11.)

Das sind drei kleine Tabellen, die ihr einmal erstellt und dann nur noch pflegt:

### Meilensteinplan (an die Präsentationstermine gehängt)

| Meilenstein | Datum | Erreicht, wenn … |
|---|---|---|
| Projektstart / Setup fertig | 31.10. | Repo, Board, Rollen, Modell stehen |
| Anforderungen abgeschlossen | **05.11.** | Anforderungstabelle v1 + erste Stories fertig |
| Lastenheft & Schätzung fertig | **26.11.** | Lastenheft komplett, Gesamtschätzung + Puffer |
| Alpha (Kernmechanik spielbar) | **15.12.** | Fee fliegt taktbasiert, Sichtkreis sichtbar, Kobolde reagieren, Druck-Mechanik wirkt |
| Release-Kandidat | **19.01.** | Spiel komplett, getestet, Abgabe ready |

### RACI-Matrix (wer macht was – kopiert die Vorlesungsvorlage, setzt eure Namen ein)

| Aufgabe | PM | Dev | Tester | Gamedesigner |
|---|---|---|---|---|
| Requirements | A | C | I | R |
| Code | I | R | C | I |
| Testing | C | I | R | I |
| Release | R | C | C | A |

**Legende:** R = macht es · A = trägt die Verantwortung (immer genau 1 pro Zeile!) · C = wird konsultiert · I = wird informiert

### Kommunikationsplan

| Wer | Was | Wie oft | Wo | Verantwortlich |
|---|---|---|---|---|
| Team | Status & Blocker | 2×/Woche kurz | Discord-Daily | PM |
| Team | Planung + Risiken | 1×/Woche 90 min | Meeting | PM |
| Dozent | Fortschritt | alle 3 Wochen | Präsentation | PM |

---

## Notizen für unterwegs

- **Qualität > Umfang** (steht explizit in den Folien). Ein sauberes kleines Lastenheft schlägt 30 Seiten Geschwurbel.
- **Sichtbarkeit schlägt Vollkommenheit:** Ein gepflegtes Board mit 20 kleinen Tickets sieht besser aus als 3 Riesen-Tickets.
- **Wenn etwas schiefläuft** (Termin gerissen, Risiko eingetreten): ins Risikoregister/Review schreiben, nicht verstecken. Projektmanagement heißt, mit Störungen umzugehen, nicht sie zu leugnen.
- **Nächste Themen** (Systementwurf, Tests, Versionsverwaltung im Detail) haben eigene Vorlesungseinheiten – sobald die Folien da sind, kann diese Anleitung erweitert werden.

### Einsatz von KI: 
**Prompt:** So geh mal die Dokumente durch und erkläre mir mal, oder schreib mal eine ToDo, was wir für unser Projekt bis jetzt geschafft haben müssen. Erkläre es außerdem ausführlich. 

**Erklärung der durchgeführten Aktionen von KI:**
Es wurde ein Detaillierter Plan erstellt, den ich mir zu meinen Gunsten dann selber Umformuliert habe. 