# yungztrunks/club-manager architecture

> Architecture diagram of the GitHub repository yungztrunks/club-manager, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-03-08). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/yungztrunks/club-manager
- Repository: https://github.com/yungztrunks/club-manager

## Overview

##### Projektart & Zweck (aus File-Tree + README abgeleitet)
Das Projekt ist eine **Java-Konsolenanwendung** (kein Web-Stack), die als **Football Club Manager** dient:
- Verwaltung eines Clubs/Teams inkl. Spielern/Mitgliedern
- **RNG-simulierte Spiele (Matches)** gegen andere Teams
- Persistenz scheint **dateibasiert (TXT)** zu sein (z. B. `BVB.txt`, `MUN.txt`, `*_Spieler.txt`, `Match ... .txt`)
- Menügesteuerte Interaktion (`MatchMenu`, `TrainingMenu`) über CLI

Für ein Systemdiagramm heißt das: Fokus auf **Runtime-Komponenten innerhalb einer JVM**, **Datenflüsse zwischen Menüs/Domain-Objekten/Persistenz**, sowie die **TXT-Dateien als “Database”**.

##### Struktur/Architektur aus dem File Tree herauslesen
Wichtige Ordner/Dateien:
- `src/fussball/*.java` → kompletter Quellcode in einem Package `fussball`
- `bin/fussball` → kompilierte Klassen (für Diagramm i. d. R. irrelevant, aber zeigt: klassisches Java-Projekt)
- TXT-Dateien im Root:
- `BVB.txt`, `MUN.txt` → vermutlich Team-/Club-Daten
- `BVB_Spieler.txt`, `MUN_Spieler.txt` → Spielerlisten pro Team
- `Match BVB-MUN ... .txt` → gespeicherte Match-Ergebnisse (README: aktuell leer durch Bug)

Wichtige Klassen (als Kandidaten für Komponenten/Boxen):
- **Entry Point / Orchestrierung**
- `MainMethode.java` (Startpunkt)
- **Domain/Model**
- `Mannschaft.java` (Team)
- `Spieler.java` (Player)
- `Mitglieder.java` (Members – evtl. Basisklasse/Abstraktion für Spieler?)
- `Match.java` (Match/Simulation)
- `Training.java` (Trainingseinheit)
- `Spielfeld.java`, `Stadion.java`, `Trainingsplatz.java` (Orte/Facilities; je nach Nutzung “nice to have” im Diagramm)
- **UI / Menüs (CLI Controller-Schicht)**
- `MatchMenu.java`
- `TrainingMenu.java`
- **Persistenz / Datenzugriff**
- `MannschaftDatabase.java` (trotz Namen sehr wahrscheinlich: File-IO, Laden/Speichern aus TXT)

=> Architekturmuster wirkt wie eine **einfache Schichtenstruktur** (auch wenn nicht in Packages getrennt):
**CLI/UI → Application Logic/Domain → File Persistence (TXT)**

##### README-Insights, die du explizit im Diagramm berücksichtigen solltest
Aus README:
- “manage a football clubs players” → CRUD/Verwaltungsfluss (Team/Spieler)
- “play RNG simulated games” → Simulation als eigener Prozess/Komponente (Match Engine)
- bekannte Issues:
- Team-Selektion über “first letters” → Input Parsing/Lookup in Menu/DB

Diese Punkte sind gute “Hot paths”, die ein präzises Diagramm zeigen muss.

##### 4a) Hauptkomponenten identifizieren (Boxen)
Ich würde mindestens diese Komponenten trennen (so granular wie möglich, ohne zu übertheoretisieren):

##### Domain Model
- `Mannschaft` (enthält Roster/Spieler, Teamdaten)
- `Spieler` (Stats)
- `Mitglieder` (falls Basisklasse/Interface: als “Model Base” darstellen)
- `Match` (Simulation / Ergebnis)
- `Training` (Training Logik / Statänderungen)
- Facilities: `Stadion`, `Spielfeld`, `Trainingsplatz` (nur wenn wirklich in Flows genutzt)
##### Persistence Layer
- `MannschaftDatabase` als “Repository/DAO”
##### Data Store (File System / TXT)
- Team-Dateien: `BVB.txt`, `MUN.txt`
- Spieler-Dateien: `BVB_Spieler.txt`, `MUN_Spieler.txt`
- Match-Result-Dateien: `Match ... .txt`

Optional (wenn du es sauberer willst): Splitte `MannschaftDatabase` logisch im Diagramm in
- “TeamReader/Writer”
- “PlayerReader/Writer”
- “MatchResultWriter”
auch wenn es im Code eine Datei ist. (Das entspricht dem Wunsch: “so viele Komponenten wie möglich”.)

##### 4b) Beziehungen/Interaktionen bestimmen (Pfeile)
Zeichne Pfeile als **Datenfluss** und/oder **Abhängigkeitsrichtung**. Für dieses Projekt sind die wichtigsten Flows:

**Programmstart**
- User → `MainMethode`
- `MainMethode` → `MatchMenu` / `TrainingMenu` (je nach Auswahl)

**Match Flow (Haupt-Use-Case)**
- User → `MatchMenu` (Eingaben: Team-Auswahl, Start)
- `MatchMenu` → `MannschaftDatabase` (Load Teams + Spieler)
- `MannschaftDatabase` → `TXT Files` (read: `*.txt`, `*_Spieler.txt`)
- `MatchMenu` → `Match` (start simulation; RNG)
- `Match` → `Mannschaft` / `Spieler` (liest Stats, erzeugt Result/ändert ggf. Werte)
- `MatchMenu` → `MannschaftDatabase` (Save match result)
- `MannschaftDatabase` → `Match ... .txt` (write)

**Training Flow**
- User → `TrainingMenu`
- `TrainingMenu` → `MannschaftDatabase` (Load roster)
- `TrainingMenu` → `Training` (apply training effects)
- `Training` → `Spieler` (mutiert Stats)
- `TrainingMenu` → `MannschaftDatabase` (Save updated roster)
- `MannschaftDatabase` → `*_Spieler.txt` (write)

**Wichtig:** Markiere am Pfeil “Match result write” einen Hinweis/Badge “BUG: empty file” – das ist architektonisch genau die Stelle, wo das Problem sitzt.

##### 4c) Architekturmuster/Prinzipien hervorheben (was man im Diagramm “lesen” soll)
- **Single-process, single-JVM**: alles läuft lokal in einem Prozess
- **CLI Menu = Controller/Use-case orchestration**
- **Domain Model** kapselt Spiel-/Trainingslogik
- **File-based persistence** statt DBMS
- Keine externen Services (keine HTTP APIs, keine Cloud) → Diagramm bleibt “lokal”

##### 4d) Technologien/Frameworks im Diagramm
- Sprache/Runtime: **Java (JDK), Console I/O**
- Persistenz: **Plain Text Files (File I/O)**

Keine Notwendigkeit, Build/Dependency Tools zu zeigen (kein Maven/Gradle im Tree).

##### “Nicht überdenken, lieber mehr Komponenten trennen” – wie du das hier konkret umsetzt
Zusätzlich zu den “großen Boxen” kannst du in einer zweiten Diagramm-Variante (oder als Zoom-In) weiter aufsplitten:
- `MatchMenu`:
- Team-Auswahl/Parsing (zeigt auch den Bug “first letters only”)
- Match-Start
- Result-Save
- `MannschaftDatabase`:
- Team Loader
- Player Loader
- Match Result Writer

Auch wenn es in Code nur eine Klasse ist, ist diese Trennung im Diagramm hilfreich, um Verantwortlichkeiten + Fehlerstellen zu isolieren.

##### System Context / Container
- Extern: “User”
- Extern: “Local File System (TXT)”
- Pfeile: User ↔ App, App ↔ File System

- `MainMethode` → `MatchMenu`, `TrainingMenu`
- `MatchMenu` → `MannschaftDatabase`, `Match`
- `TrainingMenu` → `MannschaftDatabase`, `Training`
- `MannschaftDatabase` ↔ “Team TXT”, “Player TXT”, “Match TXT”
- `Match` ↔ `Mannschaft` ↔ `Spieler`
- `Training` ↔ `Spieler`
- Optional: `Match` → `Stadion/Spielfeld` (nur wenn wirklich genutzt)

Damit hast du ein Diagramm, das sowohl “architecturally correct” als auch sehr detailliert ist und genau die Projektstruktur widerspiegelt.

## Diagram (Mermaid)

```mermaid
flowchart TD
    %% ========= System Context =========
    User(["User (CLI)"]):::actor

    subgraph "club-manager (Java Console App • Single JVM Process)"
        MainMethode("MainMethode\n(App Entry / Router)"):::ui

        subgraph "CLI Controller Layer (Menus)"
            MatchMenu("MatchMenu\n(Team selection • Match start • Save result)"):::ui
            TrainingMenu("TrainingMenu\n(Load roster • Apply training • Save roster)"):::ui
        end

        subgraph "Domain Layer (Model + Logic)"
            Mitglieder("Mitglieder\n(Base / Abstraction)"):::domain
            Spieler("Spieler\n(Stats)"):::domain
            Mannschaft("Mannschaft\n(Team + Roster)"):::domain

            subgraph "Use Case Logic"
                Match("Match\n(RNG Simulation)"):::domain
                Training("Training\n(Stat changes)"):::domain
            end

            subgraph "Facilities / Places"
                Stadion("Stadion"):::facility
                Spielfeld("Spielfeld"):::facility
                Trainingsplatz("Trainingsplatz"):::facility
            end
        end

        subgraph "Persistence Layer (File I/O)"
            MannschaftDatabase("MannschaftDatabase\n(Repository / TXT File-IO)"):::persistence

            subgraph "Logical Responsibilities (inside MannschaftDatabase)"
                TeamReaderWriter("TeamReader/Writer"):::persistenceLite
                PlayerReaderWriter("PlayerReader/Writer"):::persistenceLite
                MatchResultWriter("MatchResultWriter\n(Known issue: empty file bug)"):::persistenceBug
            end
        end
    end

    subgraph "Local File System (TXT 'Database')"
        BVB("BVB.txt\n(Team data)"):::datastore
        MUN("MUN.txt\n(Team data)"):::datastore
        BVB_Spieler("BVB_Spieler.txt\n(Player roster)"):::datastore
        MUN_Spieler("MUN_Spieler.txt\n(Player roster)"):::datastore
        MatchFile("Match BVB-MUN (01.08 23.02.2022).txt\n(Match result)"):::datastore
    end

    %% ========= Primary Flows =========
    User -->|"input/choices"| MainMethode
    MainMethode -->|"routeToMatch()"| MatchMenu
    MainMethode -->|"routeToTraining()"| TrainingMenu

    %% Match flow
    User -->|"teamSelection(firstLetters)"| MatchMenu
    MatchMenu -->|"loadTeamsAndPlayers()"| MannschaftDatabase
    MatchMenu -->|"simulateMatch()"| Match
    MatchMenu -->|"saveMatchResult()"| MannschaftDatabase

    Match -->|"usesTeamStats"| Mannschaft
    Mannschaft -->|"hasRoster"| Spieler
    Spieler -.->|"inherits/implements"| Mitglieder

    Match -->|"playedIn(optional)"| Stadion
    Match -->|"usesField(optional)"| Spielfeld

    %% Training flow
    User -->|"trainingChoice"| TrainingMenu
    TrainingMenu -->|"loadRoster()"| MannschaftDatabase
    TrainingMenu -->|"applyTraining()"| Training
    TrainingMenu -->|"saveUpdatedRoster()"| MannschaftDatabase

    Training -->|"mutatesStats"| Spieler
    Training -->|"usesPlace(optional)"| Trainingsplatz

    %% ========= Persistence (split responsibilities) =========
    MannschaftDatabase -->|"teamIO"| TeamReaderWriter
    MannschaftDatabase -->|"playerIO"| PlayerReaderWriter
    MannschaftDatabase -->|"matchIO"| MatchResultWriter

    %% Reads/Writes to files (dashed)
    TeamReaderWriter -.->|"read/write"| BVB
    TeamReaderWriter -.->|"read/write"| MUN
    PlayerReaderWriter -.->|"read/write"| BVB_Spieler
    PlayerReaderWriter -.->|"read/write"| MUN_Spieler
    MatchResultWriter -.->|"write (BUG: empty file)"| MatchFile

    %% ========= Click Events =========
    click MainMethode "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/MainMethode.java"
    click MatchMenu "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/MatchMenu.java"
    click TrainingMenu "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/TrainingMenu.java"
    click MannschaftDatabase "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/MannschaftDatabase.java"
    click Mannschaft "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/Mannschaft.java"
    click Spieler "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/Spieler.java"
    click Mitglieder "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/Mitglieder.java"
    click Match "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/Match.java"
    click Training "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/Training.java"
    click Stadion "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/Stadion.java"
    click Spielfeld "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/Spielfeld.java"
    click Trainingsplatz "https://github.com/yungztrunks/club-manager/blob/main/src/fussball/Trainingsplatz.java"
    click BVB "https://github.com/yungztrunks/club-manager/blob/main/BVB.txt"
    click MUN "https://github.com/yungztrunks/club-manager/blob/main/MUN.txt"
    click BVB_Spieler "https://github.com/yungztrunks/club-manager/blob/main/BVB_Spieler.txt"
    click MUN_Spieler "https://github.com/yungztrunks/club-manager/blob/main/MUN_Spieler.txt"
    click MatchFile "https://github.com/yungztrunks/club-manager/blob/main/Match BVB-MUN (01.08 23.02.2022).txt"

    %% ========= Styles =========
    classDef actor fill:#ffffff,stroke:#111827,stroke-width:2,color:#111827
    classDef ui fill:#dbeafe,stroke:#1d4ed8,stroke-width:2,color:#0f172a
    classDef domain fill:#dcfce7,stroke:#16a34a,stroke-width:2,color:#052e16
    classDef facility fill:#e0f2fe,stroke:#0284c7,stroke-width:2,color:#082f49
    classDef persistence fill:#ffedd5,stroke:#ea580c,stroke-width:2,color:#431407
    classDef persistenceLite fill:#fff7ed,stroke:#f97316,stroke-width:1.5,color:#431407
    classDef persistenceBug fill:#ffe4e6,stroke:#e11d48,stroke-width:2,color:#4c0519
    classDef datastore fill:#e5e7eb,stroke:#374151,stroke-width:2,color:#111827,stroke-dasharray:4 3
```
