1. Projektstruktur festlegen

- Backend: Enthält die Logik für das Spiel (Regeln, Validierung, etc.)
- Fronted: GUI mit Swing für die Anzeige und Interaktion.
- Datenmanagement: Einlesen, Speichern und Verwalten von Spielfeldern.
- Tests: Unit-Tests und Integrationstests mit JUnit.
- Maven-Setup: Für die Organisation des Projekts.

2. Aufteilung
- Person A: Backend-Logik
    - Implementieren der Spielregeln:
        - Überprüfung, ob keine Zahl in Zeilen/Spalten doppelt vorkommt.
        - Validierung, dass schwarze Felder nicht horizontal/vertikal angrenzen.
        - Sicherstellen, dass weiße Felder zusammenhängend bleiben.
    - Implementieren von Logiken für Rückgängig- und Wiederholen-Funktionen.
    - Speichern des Spielzustands.

- Person B: Fronted (GUI)
    - Aufbau der GUI:
        - Darstellung des Spielfelds mit klickbaren Feldern.
        - Farbliche Markierung von Feldern (grau, weiß, schwarz).
        - Buttons für "Reset", "Undo", "Redo" und Auswahl von Spielfeldern.
    - Zeitmessung und Highscore-Anzeige.
    - Fehlermarkierungen und optional das Stoppen der Uhr, wenn das Fenster verdeckt ist.

3. Gemeinsame Aufgaben
    - Datenmanagement: Einlesen der CSV-Dateien und Konvertieren in Spielfeld-Objekte.
    - Testing: Unit-Tests für die Backend-Logik und Integrationstests für die GUI.
    - Code-Reviews: Regelmäßig Pull Requests überprüfen und besprechen.
    - Dokumentation: README-Datei und Kommentare im Code.

4. Vorgehen:
    Phase 1: Setup
        - Git-Repository erstellen und Maven-Projekt einrichten.
        - Gemeinsame Planung und Aufteilung der ersten Schritte.

    - Phase 2: Grundlegende Funktionen
        - Backend: Basis-Logik für Regeln und Validierung implementieren.
        - Fronted: Einfaches Spielfeld und Interaktion erstellen.

    - Phase 3: Erweiterungen
        - Undo/Redo und Reset.
        - Zeitmessung und Highscore.
        - Testen und Fehlerbehandlung.

    - Phase 4: Tests und Feinschliff
        - Alle Funktionen gründlich testen.
        - GUI und Bedienung optimieren.
        - Projektstruktur überprüfen und dokumentieren.

- Architektur planen
    - Package-Struktur:
        - domain: Spiellogik (z. B. Klassen für Spielfeld, Regeln).
        - ui: GUI (Fenster, Button-Logik).
        - service: Verwalten von Spielfeldern, Highscores.
        - util: Hilfsklassen (z. B. Timer, Dateioperationen).

    - Grundgerüst der Klassen:
        - GameBoard: Repräsentiert das Spielfeld.
            --> speichert eine Matrix für Zahlen  (z. B. int[][] board).
            --> Hat Funktionen, um Felder als schwarz/ weiß zu markieren.

        - GameLogic: Beinhaltet die Spielregeln.
            --> Funktion z. B. Überprüfung, ob in einer Zeile doppelte Zahlen vorkommen.

        - HitoriApp: Hauptklasse, die das Spiel startet.
        - HighscoreManager: Verwalten von Highscores.
        - BoardLoader: ließt eine CSV-Datei eun und erstellt ein GameBoard-Objekt.



Package-Struktur und Klassen:
    1. domain (Spiellogik und Datenmodelle)
        --> Enthält Klassen, die die Kernlogik des Spiels und die Datenstruktur repräsentieren:
            1. GameBoard:
                Aufgabe: Repräsentiert das Spielfeld.
                Attribute:
                    - int[][] board: Das Spielfeld als zweidimensionales Array.
                    - boolean[][] blackCells: Gibt an, ob ein Feld geschwärzt ist.
                    - boolean[][] whiteCells: Gibt an, ob ein Feld weiß markiert ist.

                Methoden:
                    - markCellAsBlack(int row, int col)
                    - markCellAsWhite(int row, int col)
                    - isBlackCellValid(int roe, int col): Überprüfung der Regeln.
                    - resetBoard()

            2. GameLogic:
                Aufgabe: Implementiert die Spielregeln.
                Methoden:
                    - boolean isRowValid(int row)
                    - boolean isColumnValid(int column)
                    - boolean areWhiteCellsConnected()
                    - boolean isBoardSoled(): Prüft, ob das Spiel korrekt gelöst ist.

            3. HighscoreEntry:
                Aufgabe: Speichert die Daten eines Highscore-Eintrags.
                Attribute:
                    - String playerName
                    - long time
                    - int mistakes

            4. HighscoreManager:
                Aufgabe: Verwalten der Highscore-Daten.
                Methoden:
                    - addHighscore(GameBoard board, String playerName, long time, int mistakes)
                    - List<HighscoreEntry> getHighscores(GameBoard board)


2. ui (Benutzeroberfläche)
    --> Enthält Klassen für die GUI mit Swing.
        1. HitoriApp
            Aufgabe: Einstiegspunkt des Programms.
            Methoden:
                ...