Struktur nochmal verbessert

Hitori/Files/ProjektStruktur

@@ -0,0 +1,126 @@
+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:
+                ...
+
+
+
+
+
+
+
+
+
+
+

Hitori/src/main/java/PR2/HitoriSpiel/Domain/DomainTest.java

@@ -0,0 +1,4 @@
+package PR2.HitoriSpiel.Domain;
+
+public class DomainTest {
+}

Hitori/src/main/java/PR2/HitoriSpiel/Fassade/FassadeTest.java

@@ -0,0 +1,4 @@
+package PR2.HitoriSpiel.Fassade;
+
+public class FassadeTest {
+}

Hitori/src/main/java/PR2/HitoriSpiel/GUI/GameBoardView.java

@@ -0,0 +1,51 @@
+package PR2.HitoriSpiel.GUI;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class GameBoardView extends JPanel {
+    private final JButton[][] cells; // Spielfeld als Buttons
+
+    public GameBoardView(int rows, int cols) {
+        this.setLayout(new GridLayout(rows, cols)); // Grid-Layout für das Spielfeld
+        cells = new JButton[rows][cols];
+
+        // Spielfeld-Buttons initialisieren
+        for (int row = 0; row < rows; row++) {
+            for (int col = 0; col < cols; col++) {
+                cells[row][col] = new JButton();
+                cells[row][col].setBackground(Color.LIGHT_GRAY);
+                int finalRow = row;
+                int finalCol = col;
+
+                // ActionListener für Button-Klick
+                cells[row][col].addActionListener(e -> toggleCellColor(finalRow, finalCol));
+                this.add(cells[row][col]);
+            }
+        }
+    }
+
+    // Methode zum Umschalten der Zellenfarbe
+    private void toggleCellColor(int row, int col) {
+        JButton button = cells[row][col];
+        if (button.getBackground() == Color.LIGHT_GRAY) {
+            button.setBackground(Color.BLACK);
+        } else if (button.getBackground() == Color.BLACK) {
+            button.setBackground(Color.WHITE);
+        } else {
+            button.setBackground(Color.LIGHT_GRAY);
+        }
+    }
+
+    // Methode zum Aktualisieren des Spielfelds (optional)
+    public void render(int[][] board) {
+        for (int row = 0; row < board.length; row++) {
+            for (int col = 0; col < board[row].length; col++) {
+                cells[row][col].setText(String.valueOf(board[row][col]));
+            }
+        }
+    }
+}
+

Hitori/src/main/java/PR2/HitoriSpiel/GUI/HitoriApp.java

@@ -0,0 +1,21 @@
+package PR2.HitoriSpiel.GUI;
+
+import javax.swing.*;
+
+public class HitoriApp {
+    public static void start() {
+        SwingUtilities.invokeLater(() -> {
+            // Hauptfenster erstellen
+            JFrame frame = new JFrame("Hitori - Das Spiel");
+            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+            frame.setSize(400, 400);
+
+            // Startmenü hinzufügen
+            StartMenu startMenu = new StartMenu(frame);
+            frame.add(startMenu);
+
+            frame.setVisible(true);
+            frame.setLocationRelativeTo(null);
+        });
+    }
+}

Hitori/src/main/java/PR2/HitoriSpiel/GUI/StartMenu.java

@@ -0,0 +1,45 @@
+package PR2.HitoriSpiel.GUI;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class StartMenu extends JPanel {
+
+    public StartMenu(JFrame parentFrame) {
+        // Layout auf FlowLayout setzen
+        this.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10)); // Zentriert mit Abständen
+
+        // Buttons erstellen
+        JButton continueButton = createButton("Spiel fortsetzen", 200, 30);
+        JButton selectBoardButton = createButton("Spielfeld aussuchen", 200, 30);
+        JButton randomBoardButton = createButton("Zufälliges Spielfeld", 200, 30);
+        JButton highscoreButton = createButton("Highscore anzeigen", 200, 30);
+        JButton exitButton = createButton("Spiel beenden", 200, 30);
+
+        // ActionListener hinzufügen
+        continueButton.addActionListener(e -> showMessage("Spiel fortsetzen wird implementiert."));
+        selectBoardButton.addActionListener(e -> showMessage("Spielfeld auswählen wird implementiert."));
+        randomBoardButton.addActionListener(e -> showMessage("Zufälliges Spielfeld wird gestartet."));
+        highscoreButton.addActionListener(e -> showMessage("Highscore-Liste wird angezeigt."));
+        exitButton.addActionListener(e -> System.exit(0));
+
+        // Buttons zum Panel hinzufügen
+        this.add(continueButton);
+        this.add(selectBoardButton);
+        this.add(randomBoardButton);
+        this.add(highscoreButton);
+        this.add(exitButton);
+    }
+
+    // Methode zum Anzeigen von Nachrichten
+    private void showMessage(String message) {
+        JOptionPane.showMessageDialog(this, message, "Info", JOptionPane.INFORMATION_MESSAGE);
+    }
+
+    // Methode zum Erstellen von Buttons mit fester Größe
+    private JButton createButton(String text, int width, int height) {
+        JButton button = new JButton(text);
+        button.setPreferredSize(new Dimension(width, height)); // Feste Größe setzen
+        return button;
+    }
+}

Hitori/src/main/java/PR2/HitoriSpiel/Main/Main.java

@@ -0,0 +1,10 @@
+package PR2.HitoriSpiel.Main;
+
+import PR2.HitoriSpiel.GUI.HitoriApp;
+
+public class Main {
+    public static void main(String[] args) {
+
+        HitoriApp.start();
+    }
+}

Hitori/src/main/java/de/hs_mannheim/informatik/HitoriSpiel/Main.java

@@ -1,9 +0,0 @@
-package de.hs_mannheim.informatik.HitoriSpiel;
-
-public class Main {
-    public static void main(String[] args) {
-
-        System.out.println("Hiii");
-        System.out.println("Hello world!");
-    }
-}