src/main/java/domain/GameSolver.java

@@ -8,7 +8,6 @@ public class GameSolver extends HitoriGameMoves {
         super(initialBoard);
     }
 
-    // Überprüft, ob das Spiel gelöst wurde
     public boolean isSolved() {
         // First check if all cells are marked (either black or white)
         for (int i = 0; i < board.length; i++) {
@@ -56,7 +55,6 @@ public class GameSolver extends HitoriGameMoves {
         return isOrthogonallyConnected();
     }
 
-    // Überprüft, ob die schwarze Markierung gültig ist
     private boolean isValidBlackMark(int row, int col) {
         if (row > 0 && blackCells[row-1][col] ||
                 row < board.length-1 && blackCells[row+1][col] ||
@@ -67,7 +65,6 @@ public class GameSolver extends HitoriGameMoves {
         return true;
     }
 
-    // Überprüft, ob weiße Zellen orthogonal verbunden sind
     private boolean isOrthogonallyConnected() {
         if (board.length == 0) return true;
 
@@ -87,7 +84,6 @@ public class GameSolver extends HitoriGameMoves {
         return true;
     }
 
-    // Findet die erste weiße Zelle
     private int[] findFirstWhiteCell() {
         for (int i = 0; i < board.length; i++) {
             for (int j = 0; j < board[0].length; j++) {
@@ -99,7 +95,6 @@ public class GameSolver extends HitoriGameMoves {
         return null;
     }
 
-    // Tiefensuche, um verbundene weiße Zellen zu finden
     private void dfs(int row, int col, boolean[][] visited) {
         if (row < 0 || row >= board.length || col < 0 || col >= board[0].length ||
                 visited[row][col] || blackCells[row][col]) {
@@ -114,7 +109,6 @@ public class GameSolver extends HitoriGameMoves {
         dfs(row, col + 1, visited);
     }
 
-    // Findet fehlerhafte schwarze Markierungen
     public List<int[]> findIncorrectBlackMarks() {
         List<int[]> incorrectMarks = new ArrayList<>();
         for (int i = 0; i < board.length; i++) {

src/main/java/domain/HitoriBoardLoader.java

@@ -11,12 +11,12 @@ public class HitoriBoardLoader {
     public HitoriBoardLoader() {
         availableBoards = new HashMap<>();
         solutions = new HashMap<>();
-        loadAllBoards(); // Lädt alle verfügbaren Boards
+        loadAllBoards();
     }
 
     private void loadAllBoards() {
         try {
-            // Definiere die Board-Dateinamen
+            // Define all board file names
             String[] boardFiles = {
                     "Hitori4x4_leicht.csv",
                     "Hitori5x5leicht.csv",
@@ -26,12 +26,16 @@ public class HitoriBoardLoader {
                     "Hitori15x15_medium.csv"
             };
 
-            // Versuche, jedes Board zu laden
+            // Try to load each board
             for (String fileName : boardFiles) {
                 try {
                     InputStream is = getClass().getResourceAsStream("/" + fileName);
+                    if (is == null) {
+                        is = getClass().getResourceAsStream("/" + fileName);
+                    }
+
                     if (is != null) {
-                        loadBoard(fileName, is); // Lade das Board
+                        loadBoard(fileName, is);
                     }
                 } catch (Exception e) {
                     System.out.println("Failed to load board: " + fileName);
@@ -39,7 +43,6 @@ public class HitoriBoardLoader {
                 }
             }
 
-            // Überprüfe, ob Boards geladen wurden
             if (availableBoards.isEmpty()) {
                 System.out.println("No board files found. Please ensure .csv files are in the resources folder.");
             } else {
@@ -50,16 +53,15 @@ public class HitoriBoardLoader {
         }
     }
 
-    // Lädt ein einzelnes Board und seine Lösung
     private void loadBoard(String fileName, InputStream inputStream) throws IOException {
         try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
             List<String> lines = new ArrayList<>();
             String line;
             while ((line = reader.readLine()) != null) {
-                lines.add(line); // Liest jede Zeile der Datei
+                lines.add(line);
             }
 
-            // Finde den Startpunkt der Lösung
+            // Find where the solution starts
             int solutionIndex = -1;
             for (int i = 0; i < lines.size(); i++) {
                 if (lines.get(i).contains("//")) {
@@ -68,12 +70,12 @@ public class HitoriBoardLoader {
                 }
             }
 
-            // Parsen des Boards
+            // Parse the board
             List<String[]> boardRows = new ArrayList<>();
             for (int i = 0; i < (solutionIndex == -1 ? lines.size() : solutionIndex); i++) {
                 line = lines.get(i).trim();
                 if (!line.isEmpty()) {
-                    boardRows.add(line.split(",")); // Trenne die Zeilen in Spalten
+                    boardRows.add(line.split(","));
                 }
             }
 
@@ -84,12 +86,12 @@ public class HitoriBoardLoader {
 
                 for (int i = 0; i < rows; i++) {
                     for (int j = 0; j < cols; j++) {
-                        board[i][j] = Integer.parseInt(boardRows.get(i)[j].trim()); // Konvertiere die Strings in Integers
+                        board[i][j] = Integer.parseInt(boardRows.get(i)[j].trim());
                     }
                 }
-                availableBoards.put(fileName, board); // Speichere das Board
+                availableBoards.put(fileName, board);
 
-                // Wenn eine Lösung vorhanden ist, speichere sie
+                // Parse the solution if available
                 List<int[]> solutionCoordinates = new ArrayList<>();
                 if (solutionIndex != -1) {
                     for (int i = solutionIndex + 1; i < lines.size(); i++) {
@@ -102,23 +104,20 @@ public class HitoriBoardLoader {
                             });
                         }
                     }
-                    solutions.put(fileName, solutionCoordinates); // Speichere die Lösung
+                    solutions.put(fileName, solutionCoordinates);
                 }
             }
         }
     }
 
-    // Gibt die Namen der verfügbaren Boards zurück
     public Set<String> getAvailableBoardNames() {
         return availableBoards.keySet();
     }
 
-    // Gibt ein Board anhand des Namens zurück
     public int[][] getBoard(String boardName) {
         return availableBoards.get(boardName);
     }
 
-    // Gibt die Lösung für ein Board zurück
     public List<int[]> getSolution(String boardName) {
         return solutions.get(boardName);
     }

src/main/java/domain/HitoriGameMain.java

@@ -5,9 +5,9 @@ import java.io.*;
 public class HitoriGameMain extends GameSolver {
     private static final long serialVersionUID = 1L;
 
-    private final HitoriGameTimer timer; // Timer für das Spiel
+    private final HitoriGameTimer timer;
-    private final HitoriGameScores scores; // Highscore-Verwaltung
+    private final HitoriGameScores scores;
-    private long savedTime; // Gespeicherte Zeit für den Timer
+    private long savedTime;
 
     public HitoriGameMain(int[][] initialBoard) {
         super(initialBoard);
@@ -24,26 +24,28 @@ public class HitoriGameMain extends GameSolver {
         return scores;
     }
 
-    // Speichert den aktuellen Zustand des Spiels
+    // Update serialization to handle full game state
     private void writeObject(ObjectOutputStream out) throws IOException {
         out.defaultWriteObject();
+        // Save current state
         out.writeLong(getElapsedTimeInSeconds());
         out.writeInt(mistakeCount);
         out.writeObject(blackCells);
         out.writeObject(whiteCells);
     }
 
-    // Stellt den gespeicherten Zustand des Spiels wieder her
     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
         in.defaultReadObject();
+        // Restore state
         long savedTime = in.readLong();
         this.mistakeCount = in.readInt();
         this.blackCells = (boolean[][]) in.readObject();
         this.whiteCells = (boolean[][]) in.readObject();
+        // Initialize timer with saved time
         this.timer.setElapsedTime(savedTime);
     }
 
-    // Steuerung des Timers
+    // Timer delegation methods
     public void startTimer() {
         timer.startTimer();
     }
@@ -60,12 +62,11 @@ public class HitoriGameMain extends GameSolver {
         timer.resetTimer();
     }
 
-    // Gibt die verstrichene Zeit zurück
     public long getElapsedTimeInSeconds() {
         return savedTime > 0 ? savedTime : timer.getElapsedTimeInSeconds();
     }
 
-    // Highscore-Verwaltung
+    // High score delegation methods
     public void addHighScore(String playerName, long timeInSeconds) {
         scores.addHighScore(playerName, timeInSeconds, getMistakeCount());
     }
@@ -86,7 +87,7 @@ public class HitoriGameMain extends GameSolver {
         scores.saveHighScoresToFile();
     }
 
-    // Setzt den Spielzustand
+    // Game state persistence
     public void setGameState(boolean[][] blackCells, boolean[][] whiteCells, int mistakeCount, long elapsedTime) {
         this.blackCells = new boolean[blackCells.length][blackCells[0].length];
         this.whiteCells = new boolean[whiteCells.length][whiteCells[0].length];
@@ -100,7 +101,6 @@ public class HitoriGameMain extends GameSolver {
         this.savedTime = elapsedTime;
     }
 
-    // Speichert das Spiel in einer Datei
     public void saveGameState() {
         try (ObjectOutputStream oos = new ObjectOutputStream(
                 new FileOutputStream("gamestate.dat"))) {
@@ -110,11 +110,11 @@ public class HitoriGameMain extends GameSolver {
         }
     }
 
-    // Lädt das Spiel aus einer Datei
     public static HitoriGameMain loadGameState() {
         try (ObjectInputStream ois = new ObjectInputStream(
                 new FileInputStream("gamestate.dat"))) {
             HitoriGameMain loadedGame = (HitoriGameMain) ois.readObject();
+            // Initialize transient fields
             loadedGame.timer.resetTimer();
             return loadedGame;
         } catch (IOException | ClassNotFoundException e) {
@@ -122,7 +122,6 @@ public class HitoriGameMain extends GameSolver {
         }
     }
 
-    // Stellt den gespeicherten Zustand des Spiels wieder her
     public void restoreGameState(HitoriGameMain savedGame) {
         if (savedGame != null) {
             this.setGameState(savedGame.blackCells, savedGame.whiteCells,
@@ -133,6 +132,7 @@ public class HitoriGameMain extends GameSolver {
     @Override
     public void reset() {
         super.reset();
-        savedTime = 0; // Timer wird nicht zurückgesetzt
+        // Don't reset timer anymore
+        savedTime = 0;
     }
 }

src/main/java/domain/HitoriGameMoves.java

@@ -0,0 +1,96 @@
+package domain;
+
+import java.io.Serializable;
+import java.util.*;
+
+public class HitoriGameMoves extends GameBase {
+    private List<GameState> history;
+    private int historyPointer;
+
+    private static class GameState implements Serializable {
+        boolean[][] blackCells;
+        boolean[][] whiteCells;
+
+        GameState(boolean[][] blackCells, boolean[][] whiteCells) {
+            this.blackCells = new boolean[blackCells.length][blackCells[0].length];
+            this.whiteCells = new boolean[whiteCells.length][whiteCells[0].length];
+            for (int i = 0; i < blackCells.length; i++) {
+                this.blackCells[i] = Arrays.copyOf(blackCells[i], blackCells[i].length);
+                this.whiteCells[i] = Arrays.copyOf(whiteCells[i], whiteCells[i].length);
+            }
+        }
+    }
+
+    public HitoriGameMoves(int[][] initialBoard) {
+        super(initialBoard);
+        this.history = new ArrayList<>();
+        this.historyPointer = -1;
+        saveState();
+    }
+
+    public void markCellAsBlack(int row, int col) {
+        blackCells[row][col] = true;
+        whiteCells[row][col] = false;
+        saveState();
+    }
+
+    public void markCellAsWhite(int row, int col) {
+        whiteCells[row][col] = true;
+        blackCells[row][col] = false;
+        saveState();
+    }
+
+    protected void saveState() {
+        while (history.size() > historyPointer + 1) {
+            history.remove(history.size() - 1);
+        }
+        history.add(new GameState(blackCells, whiteCells));
+        historyPointer++;
+    }
+
+    public boolean undo() {
+        if (historyPointer > 0) {
+            historyPointer--;
+            GameState state = history.get(historyPointer);
+            restoreState(state);
+            return true;
+        }
+        return false;
+    }
+
+    public boolean redo() {
+        if (historyPointer < history.size() - 1) {
+            historyPointer++;
+            GameState state = history.get(historyPointer);
+            restoreState(state);
+            return true;
+        }
+        return false;
+    }
+
+    private void restoreState(GameState state) {
+        for (int i = 0; i < board.length; i++) {
+            blackCells[i] = Arrays.copyOf(state.blackCells[i], state.blackCells[i].length);
+            whiteCells[i] = Arrays.copyOf(state.whiteCells[i], state.whiteCells[i].length);
+        }
+    }
+
+    @Override
+    public void reset() {
+        // Save mistake count before reset
+        int currentMistakes = mistakeCount;
+
+        // Call parent reset which resets the board state
+        super.reset();
+
+        // Clear history
+        history.clear();
+        historyPointer = -1;
+
+        // Restore mistake count
+        mistakeCount = currentMistakes;
+
+        // Save initial state
+        saveState();
+    }
+}

src/main/java/domain/HitoriGameScores.java

@@ -8,7 +8,6 @@ public class HitoriGameScores implements Serializable {
 
     private Map<String, List<HighScoreEntry>> highScores;
 
-    // Speichert einzelne Highscore-Einträge
     private static class HighScoreEntry implements Serializable {
         String playerName;
         long time;
@@ -25,20 +24,17 @@ public class HitoriGameScores implements Serializable {
         this.highScores = new HashMap<>();
     }
 
-    // Fügt einen neuen Highscore hinzu
     public void addHighScore(String playerName, long timeInSeconds, int mistakes) {
         highScores.putIfAbsent(playerName, new ArrayList<>());
         highScores.get(playerName).add(new HighScoreEntry(playerName, timeInSeconds, mistakes));
         saveHighScoresToFile();
     }
 
-    // Löscht alle Highscores
     public void deleteHighScores() {
         highScores.clear();
         saveHighScoresToFile();
     }
 
-    // Gibt die besten Highscores mit Durchschnittszeit zurück
     public List<String> getHighScoresWithAverage() {
         List<String> result = new ArrayList<>();
         List<HighScoreEntry> allEntries = new ArrayList<>();
@@ -47,27 +43,24 @@ public class HitoriGameScores implements Serializable {
             allEntries.addAll(entries);
         }
 
-        allEntries.sort((a, b) -> Long.compare(a.time, b.time)); // Sortiert nach Zeit
+        allEntries.sort((a, b) -> Long.compare(a.time, b.time));
 
-        // Berechnet den Durchschnitt
         double avgTime = allEntries.stream()
                 .mapToLong(e -> e.time)
                 .average()
                 .orElse(0);
 
-        // Fügt die besten 10 Einträge hinzu
         for (int i = 0; i < Math.min(10, allEntries.size()); i++) {
             HighScoreEntry entry = allEntries.get(i);
             result.add(String.format("%s - Time: %ds - Mistakes: %d",
                     entry.playerName, entry.time, entry.mistakes));
         }
 
-        result.add(String.format("Average Time: %.1fs", avgTime)); // Durchschnittszeit hinzufügen
+        result.add(String.format("Average Time: %.1fs", avgTime));
 
         return result;
     }
 
-    // Speichert die Highscores in einer Datei
     public void saveHighScoresToFile() {
         try (ObjectOutputStream oos = new ObjectOutputStream(
                 new FileOutputStream("highscores.dat"))) {
@@ -77,14 +70,13 @@ public class HitoriGameScores implements Serializable {
         }
     }
 
-    // Lädt die Highscores aus einer Datei
     @SuppressWarnings("unchecked")
     public void loadHighScoresFromFile() {
         try (ObjectInputStream ois = new ObjectInputStream(
                 new FileInputStream("highscores.dat"))) {
             highScores = (Map<String, List<HighScoreEntry>>) ois.readObject();
         } catch (IOException | ClassNotFoundException e) {
-            highScores = new HashMap<>(); // Leert die Highscores bei Fehler
+            highScores = new HashMap<>();
         }
     }
 }

src/main/java/domain/HitoriGameTimer.java

@@ -8,31 +8,29 @@ import java.io.Serializable;
 public class HitoriGameTimer implements Serializable {
     private static final long serialVersionUID = 1L;
 
-    private transient long startTime;
+    private transient long startTime;  // Time when timer was last started
-    private long elapsedTime;
+    private long elapsedTime;          // Total accumulated time
-    private boolean isPaused;
+    private boolean isPaused;          // Current pause state
-    private long lastPauseTime;
+    private long lastPauseTime;        // When the timer was last paused
 
     public HitoriGameTimer() {
         this.startTime = 0;
         this.elapsedTime = 0;
-        this.isPaused = true;  // Timer beginnt pausiert
+        this.isPaused = true;  // Start paused
         this.lastPauseTime = 0;
     }
 
-    // Timer starten
     public void startTimer() {
         if (isPaused) {
             startTime = System.currentTimeMillis();
             isPaused = false;
-
+            // If this is a resume after pause, handle accumulated time
             if (lastPauseTime > 0) {
                 startTime = System.currentTimeMillis();
             }
         }
     }
 
-    // Timer pausieren
     public void pauseTimer() {
         if (!isPaused && startTime > 0) {
             lastPauseTime = System.currentTimeMillis();
@@ -42,7 +40,6 @@ public class HitoriGameTimer implements Serializable {
         }
     }
 
-    // Timer stoppen
     public void stopTimer() {
         if (!isPaused && startTime > 0) {
             long stopTime = System.currentTimeMillis();
@@ -53,7 +50,6 @@ public class HitoriGameTimer implements Serializable {
         }
     }
 
-    // Timer zurücksetzen
     public void resetTimer() {
         startTime = 0;
         elapsedTime = 0;
@@ -61,13 +57,11 @@ public class HitoriGameTimer implements Serializable {
         lastPauseTime = 0;
     }
 
-    // Setzt die vergangene Zeit manuell
     public void setElapsedTime(long timeInSeconds) {
-        this.elapsedTime = timeInSeconds * 1000; // Umrechnung in Millisekunden
+        this.elapsedTime = timeInSeconds * 1000; // Convert to milliseconds
         this.lastPauseTime = System.currentTimeMillis();
     }
 
-    // Gibt die vergangene Zeit in Sekunden zurück
     public long getElapsedTimeInSeconds() {
         if (isPaused) {
             return elapsedTime / 1000;
@@ -76,25 +70,23 @@ public class HitoriGameTimer implements Serializable {
         return (elapsedTime + (currentTime - startTime)) / 1000;
     }
 
-    // Gibt zurück, ob der Timer pausiert ist
     public boolean isPaused() {
         return isPaused;
     }
 
-    // Für die Serialisierung: Speichert den aktuellen Zustand
+    // For serialization
     private void writeObject(ObjectOutputStream out) throws IOException {
         out.defaultWriteObject();
-
+        // Save current elapsed time if timer is running
         if (!isPaused && startTime > 0) {
             elapsedTime += System.currentTimeMillis() - startTime;
         }
     }
 
-
     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
         in.defaultReadObject();
-
+        // Initialize transient fields
         startTime = 0;
-        isPaused = true;
+        isPaused = true;  // Start paused when restored
     }
 }

src/test/java/GameBaseTest.java

@@ -24,14 +24,14 @@ class GameBaseTest {
 
     @Test
     void testReset() {
-        // Setzt automatisch schwarze Zellen
+        // Directly set some cells (since we can't use markCell methods in base class)
         game.blackCells[0][0] = true;
         game.whiteCells[1][1] = true;
 
         // Reset game
         game.reset();
 
-        // Verifiziert, ob alle schwarzen Zellen gelöscht wurden
+        // Verify all cells are reset
         boolean[][] blackCells = game.getBlackCells();
         boolean[][] whiteCells = game.getWhiteCells();
 

src/test/java/GameUIControllerTest.java

@@ -32,7 +32,6 @@ class GameUIControllerTest {
 
 
     @Test
-    // Checkt ob alle Elemente initialisiert wurden
     void testInitialization() {
         assertNotNull(controller);
         assertNotNull(controller.getBoardPanel());
@@ -66,12 +65,12 @@ class GameUIControllerTest {
 
     @Test
     void testResetGame() {
-        // Feldermarkierungen
+        // Make some moves first
         controller.handleLeftClick(0, 0);
         controller.handleRightClick(1, 1);
 
         controller.resetGame();
-        // Verifiziert Boardlöschung
+        // Verify the board is reset
         var boardPanel = controller.getBoardPanel();
         assertEquals(9, boardPanel.getChildren().size()); // 3x3 board
     }
@@ -81,13 +80,13 @@ class GameUIControllerTest {
         controller.handleLeftClick(0, 0);
         controller.undo();
         controller.redo();
-        // Verifiziert den Board Status
+        // Verify the board state
         assertTrue(controller.getBoardPanel().getChildren().size() > 0);
     }
 
     @Test
     void testShowErrors() {
-        // Fehler werden kreiert
+        // Create some errors first
         controller.handleLeftClick(0, 0);
         controller.handleLeftClick(0, 1);
 
@@ -111,7 +110,6 @@ class GameUIControllerTest {
 
 
     @Test
-    // Fehlerspeicherung
     void testConvertErrorsToSet() {
         List<int[]> errors = List.of(
                 new int[]{0, 0},
@@ -128,9 +126,10 @@ class GameUIControllerTest {
         assertFalse(controller.isPaused());
     }
 
-    // Hilfsmethode
+    // Helper method to simulate winning moves
     private void makeWinningMoves() {
-        // Win
+        // This would need to be implemented according to your winning condition
+        // For test purposes, we'll just make some moves
         controller.handleLeftClick(0, 2);
         controller.handleRightClick(0, 0);
         controller.handleRightClick(0, 1);

src/test/java/HitoriBoardPanelTest.java

@@ -31,14 +31,12 @@ class HitoriBoardPanelTest {
         boardPanel = new HitoriBoardPanel(gameMoves, gameSolver, controller);
     }
 
-    // Testet, ob das Board korrekt initialisiert wurde
     @Test
     void testInitialization() {
         assertNotNull(boardPanel);
         assertEquals(9, boardPanel.getChildren().size()); // 3x3 board = 9 buttons
     }
 
-    // Testet, ob die Buttons korrekt erstellt wurden
     @Test
     void testCellCreation() {
         var children = boardPanel.getChildren();
@@ -46,7 +44,6 @@ class HitoriBoardPanelTest {
         assertEquals("1", firstButton.getText());
     }
 
-    // Testet das Styling der Buttons
     @Test
     void testButtonStyling() {
         var children = boardPanel.getChildren();
@@ -54,23 +51,21 @@ class HitoriBoardPanelTest {
         assertEquals("-fx-background-color: lightgray; -fx-text-fill: black;", button.getStyle());
     }
 
-    // Testet das Aktualisieren des Boards
     @Test
     void testUpdateBoard() {
         boardPanel.updateBoard();
         assertEquals(9, boardPanel.getChildren().size());
     }
 
-    // Testet die Anzeige von Fehlern auf dem Board
     @Test
     void testShowErrors() {
-
+        // Mark some cells as black to create errors
         gameMoves.markCellAsBlack(0, 0);
         gameMoves.markCellAsBlack(0, 1);
 
         boardPanel.showErrors();
 
-        // Verifiziere, dass fehlerhafte Zellen rot markiert werden
+        // Verify that error cells are marked red
         var children = boardPanel.getChildren();
         for (var child : children) {
             Button button = (Button) child;

src/test/java/HitoriControlPanelTest.java

@@ -19,22 +19,19 @@ class HitoriControlPanelTest {
         controlPanel = new HitoriControlPanel(controller);
     }
 
-    // Testet, ob das Control-Panel korrekt initialisiert wurde
     @Test
     void testInitialization() {
         assertNotNull(controlPanel);
         assertTrue(controlPanel.getChildren().size() > 0);
     }
 
-    // Testet das Aktualisieren des Timer-Labels
     @Test
     void testUpdateTimerLabel() {
         controlPanel.updateTimerLabel(42);
         var timerLabel = findLabelByText(controlPanel, "Time: 42s");
-        assertNotNull(42);
+        assertNotNull(5);
     }
 
-    // Testet das Aktualisieren des Fehler-Labels
     @Test
     void testUpdateMistakeLabel() {
         controlPanel.updateMistakeLabel(5);
@@ -42,7 +39,6 @@ class HitoriControlPanelTest {
         assertNotNull(5);
     }
 
-    // Testet das Setzen des Textes für den Pause-Button
     @Test
     void testSetPauseButtonText() {
         controlPanel.setPauseButtonText("Test");
@@ -50,7 +46,6 @@ class HitoriControlPanelTest {
         assertNotNull(pauseButton);
     }
 
-    // Testet die Aktion des Pause-Buttons
     @Test
     void testPauseButtonAction() {
         var pauseButton = findButtonByText(controlPanel, "Pause");
@@ -60,7 +55,6 @@ class HitoriControlPanelTest {
         verify(controller, times(1)).togglePause();
     }
 
-    // Testet die Aktion des Reset-Buttons
     @Test
     void testResetButtonAction() {
         var resetButton = findButtonByText(controlPanel, "Reset");
@@ -70,7 +64,6 @@ class HitoriControlPanelTest {
         verify(controller, times(1)).resetGame();
     }
 
-    // Testet die Aktion des Undo-Buttons
     @Test
     void testUndoButtonAction() {
         var undoButton = findButtonByText(controlPanel, "Undo");
@@ -80,7 +73,6 @@ class HitoriControlPanelTest {
         verify(controller, times(1)).undo();
     }
 
-    // Testet die Aktion des Redo-Buttons
     @Test
     void testRedoButtonAction() {
         var redoButton = findButtonByText(controlPanel, "Redo");
@@ -90,7 +82,6 @@ class HitoriControlPanelTest {
         verify(controller, times(1)).redo();
     }
 
-    // Testet die Aktion des Check-Solution-Buttons
     @Test
     void testCheckSolutionButtonAction() {
         var checkButton = findButtonByText(controlPanel, "Check Solution");
@@ -100,7 +91,6 @@ class HitoriControlPanelTest {
         verify(controller, times(1)).checkSolution();
     }
 
-    // Testet die Aktion des New-Game-Buttons
     @Test
     void testNewGameButtonAction() {
         var newGameButton = findButtonByText(controlPanel, "New Game");
@@ -110,7 +100,6 @@ class HitoriControlPanelTest {
         verify(controller, times(1)).newGame();
     }
 
-    // Testet die Aktion des Show-Errors-Buttons
     @Test
     void testShowErrorsButtonAction() {
         var showErrorsButton = findButtonByText(controlPanel, "Show Errors");
@@ -120,7 +109,6 @@ class HitoriControlPanelTest {
         verify(controller, times(1)).showErrors();
     }
 
-    // Hilfsmethode: Sucht ein Label mit einem bestimmten Text im Panel
     private Label findLabelByText(HitoriControlPanel panel, String text) {
         return (Label) panel.getChildren().stream()
                 .filter(node -> node instanceof Label && ((Label) node).getText().equals(text))
@@ -128,7 +116,6 @@ class HitoriControlPanelTest {
                 .orElse(null);
     }
 
-    // Hilfsmethode: Sucht einen Button mit einem bestimmten Text im Panel
     private Button findButtonByText(HitoriControlPanel panel, String text) {
         return (Button) panel.getChildren().stream()
                 .flatMap(node -> node.lookupAll("Button").stream())

src/test/java/HitoriDialogManagerTest.java

@@ -0,0 +1,63 @@
+import domain.HitoriBoardLoader;
+import GUI.HitoriDialogManager;
+import javafx.stage.Stage;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.testfx.framework.junit5.ApplicationExtension;
+import org.testfx.framework.junit5.Start;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(ApplicationExtension.class)
+class HitoriDialogManagerTest {
+    private HitoriDialogManager dialogManager;
+    private Stage stage;
+    private HitoriBoardLoader boardLoader;
+
+    @Start
+    private void start(Stage stage) {
+        this.stage = stage;
+    }
+
+    @BeforeEach
+    void setUp() {
+        boardLoader = mock(HitoriBoardLoader.class);
+        dialogManager = new HitoriDialogManager(stage);
+    }
+
+    @Test
+    void testShowAlert() {
+        // Cannot directly test Alert dialogs in headless mode
+        assertDoesNotThrow(() ->
+                dialogManager.showAlert("Test", "Test Message")
+        );
+    }
+
+    @Test
+    void testConfirmDeleteHighScores() {
+        // Cannot directly test confirmation dialogs in headless mode
+        assertDoesNotThrow(() ->
+                dialogManager.confirmDeleteHighScores()
+        );
+    }
+
+    @Test
+    void testConfirmNewGame() {
+        // Cannot directly test confirmation dialogs in headless mode
+        assertDoesNotThrow(() ->
+                dialogManager.confirmNewGame()
+        );
+    }
+
+
+    @Test
+    void testConfirmLoadSavedGame() {
+        // Cannot directly test confirmation dialogs in headless mode
+        assertDoesNotThrow(() ->
+                dialogManager.confirmLoadSavedGame()
+        );
+    }
+
+
+
+}

src/test/java/HitoriGameMovesTest.java

@@ -19,12 +19,12 @@ class HitoriGameMovesTest {
 
     @Test
     void testMarkCellAsBlack() {
-        // Testet schwarze Markierung
+        // Test valid black marking
         game.markCellAsBlack(0, 1);
         assertFalse(game.getBlackCells()[0][2]);
         assertFalse(game.getWhiteCells()[0][2]);
 
-
+        // Test invalid black marking (adjacent to existing black cell)
 
 
     }
@@ -42,49 +42,50 @@ class HitoriGameMovesTest {
         game.markCellAsWhite(0, 0);
         game.markCellAsBlack(1, 1);
 
-        // Löscht letzten Schritt
+        // Undo last move
         assertTrue(game.undo());
 
-        // Verified das der letzte Schritt gelöscht wurde
+        // Verify the last move was undone
         assertFalse(game.getBlackCells()[1][1]);
 
-        // Verifiziert, dass der vorherige Move gespeichert wurde
+        // Verify previous move remains
         assertTrue(game.getWhiteCells()[0][0]);
     }
 
     @Test
     void testRedo() {
-        // Wiederholt den Test
+        // Make moves and undo
         game.markCellAsWhite(0, 0);
         game.markCellAsBlack(1, 1);
         game.undo();
 
-
+        // Redo last move
         assertTrue(game.redo());
 
-
+        // Verify move was redone
         assertTrue(game.getBlackCells()[1][1]);
     }
 
     @Test
     void testUndoLimit() {
-        // Undo ohne vorherigen Move
+        // Test undo when no moves made
         assertFalse(game.undo());
     }
 
     @Test
     void testRedoLimit() {
-        // Undo und dann ein Move
+        // Make and undo a move
         game.markCellAsWhite(0, 0);
         game.undo();
         assertTrue(game.redo());
 
+        // Try to redo when at latest state
         assertFalse(game.redo());
     }
 
     @Test
     void testMoveHistory() {
-
+        // Make several moves
         game.markCellAsWhite(0, 0);
         game.markCellAsBlack(1, 1);
         game.markCellAsWhite(2, 2);
@@ -102,13 +103,14 @@ class HitoriGameMovesTest {
 
     @Test
     void testReset() {
+        // Make some moves
         game.markCellAsWhite(0, 0);
         game.markCellAsBlack(1, 1);
 
         // Reset game
         game.reset();
 
-        // Verifiziert den Reset
+        // Verify all cells are reset
         boolean[][] blackCells = game.getBlackCells();
         boolean[][] whiteCells = game.getWhiteCells();
 
@@ -119,7 +121,7 @@ class HitoriGameMovesTest {
             }
         }
 
-        // Verified undo/redo history ist closed
+        // Verify undo/redo history is cleared
         assertFalse(game.undo());
         assertFalse(game.redo());
     }

src/test/java/HitoriGameSolverTest.java

@@ -16,16 +16,14 @@ class HitoriGameSolverTest {
         game = new GameSolver(TEST_BOARD);
     }
 
-    // Testet den Anfangszustand: Das Puzzle sollte nicht gelöst sein
     @Test
     void testUnsolvedInitialState() {
         assertFalse(game.isSolved());
     }
 
-    // Testet das Lösen des Puzzles mit einer bekannten Lösung
     @Test
     void testSolvingPuzzle() {
-
+        // Apply known solution
         game.markCellAsBlack(0, 2);
         game.markCellAsWhite(0, 0);
         game.markCellAsWhite(0, 1);
@@ -39,21 +37,19 @@ class HitoriGameSolverTest {
         assertFalse(game.isSolved());
     }
 
-    // Testet eine falsche Lösung, bei der alle Zellen weiß markiert sind
     @Test
     void testIncorrectSolution() {
-
+        // Mark all cells white
         for (int i = 0; i < TEST_BOARD.length; i++) {
             for (int j = 0; j < TEST_BOARD[0].length; j++) {
                 game.markCellAsWhite(i, j);
             }
         }
 
-
+        // Should not be solved due to duplicate numbers
         assertFalse(game.isSolved());
     }
 
-    // Testet, ob das Puzzle nicht gelöst ist, wenn weiße Zellen nicht verbunden sind
     @Test
     void testDisconnectedWhiteCells() {
         // Create a solution with disconnected white cells
@@ -63,22 +59,21 @@ class HitoriGameSolverTest {
         game.markCellAsBlack(1, 1);
         game.markCellAsWhite(2, 2);
 
-
+        // Should not be solved due to disconnected white cells
         assertFalse(game.isSolved());
     }
 
-    // Testet die Erkennung von ungültigen schwarzen Markierungen (benachbarte schwarze Zellen)
     @Test
     void testFindIncorrectBlackMarks() {
-
+        // Create adjacent black cells
         game.markCellAsBlack(0, 0);
-        game.markCellAsBlack(0, 1);
+        game.markCellAsBlack(0, 1);  // This creates an invalid situation
 
         List<int[]> errors = game.findIncorrectBlackMarks();
         assertFalse(errors.isEmpty());
-        assertEquals(2, errors.size());
+        assertEquals(2, errors.size());  // Both cells should be reported
-
 
+        // Verify error coordinates
         boolean foundFirst = false;
         boolean foundSecond = false;
         for (int[] error : errors) {
@@ -88,10 +83,9 @@ class HitoriGameSolverTest {
         assertTrue(foundFirst && foundSecond);
     }
 
-    // Testet den Fall, dass es keine ungültigen schwarzen Markierungen gibt
     @Test
     void testNoIncorrectBlackMarks() {
-
+        // Make valid black marks
         game.markCellAsBlack(0, 0);
         game.markCellAsBlack(2, 2);
 
@@ -99,37 +93,34 @@ class HitoriGameSolverTest {
         assertTrue(errors.isEmpty());
     }
 
-    // Testet, ob das Puzzle nicht gelöst ist, wenn einige Zellen unmarkiert bleiben
     @Test
     void testUnmarkedCellsNotSolved() {
-
+        // Leave some cells unmarked
         game.markCellAsWhite(0, 0);
         game.markCellAsBlack(0, 1);
-
+        // Don't mark other cells
 
         assertFalse(game.isSolved());
     }
 
-    // Testet den Fall von doppelten Zahlen in einer Zeile
     @Test
     void testDuplicateNumbersInRows() {
-
+        // Mark cells to create duplicate numbers in a row
         game.markCellAsWhite(0, 0);
         game.markCellAsWhite(0, 1);
         game.markCellAsWhite(0, 2);
-
+        // Row now has duplicate numbers
 
         assertFalse(game.isSolved());
     }
 
-    // Testet den Fall von doppelten Zahlen in einer Spalte
     @Test
     void testDuplicateNumbersInColumns() {
-
+        // Mark cells to create duplicate numbers in a column
         game.markCellAsWhite(0, 0);
         game.markCellAsWhite(1, 0);
         game.markCellAsWhite(2, 0);
-
+        // Column now has duplicate numbers
 
         assertFalse(game.isSolved());
     }

src/test/java/HitoriGameTest.java

@@ -14,24 +14,19 @@ class HitoriGameTest {
     @BeforeEach
     void setUp() {
         game = new HitoriGameMain(TEST_BOARD);
-
-        // Löscht alte Spielstand- und Highscore-Dateien (falls vorhanden)
         new File("gamestate.dat").delete();
         new File("highscores.dat").delete();
     }
 
     @AfterEach
     void tearDown() {
-        // Löscht nach jedem Test die erstellten Dateien
         new File("gamestate.dat").delete();
         new File("highscores.dat").delete();
     }
 
     @Test
     void testGameIntegration() {
-        // Testet die Integration verschiedener Spielfunktionen
+        // Test timer functionality
-
-        // Timer starten und prüfen, ob Zeit gezählt wird
         game.startTimer();
         try {
             Thread.sleep(1100);
@@ -40,33 +35,31 @@ class HitoriGameTest {
         }
         assertTrue(game.getElapsedTimeInSeconds() >= 1);
 
-        // Testet das Markieren von Zellen
+        // Test game moves
         game.markCellAsBlack(0, 2);
         assertTrue(game.getBlackCells()[0][2]);
 
-        // Testet das Hinzufügen von Highscores
+        // Test scoring
         game.addHighScore("TestPlayer", 100);
         assertFalse(game.getHighScoresWithAverage().isEmpty());
     }
 
     @Test
     void testSaveAndLoadGameState() {
-        // Testet das Speichern und Laden des Spielstands
+        // Make some moves
-
-        // Einige Zellen markieren und Timer starten
         game.markCellAsWhite(0, 0);
         game.markCellAsBlack(1, 1);
         game.startTimer();
         try {
-            Thread.sleep(1000); // 1 Sekunde warten
+            Thread.sleep(1000);
         } catch (InterruptedException e) {
             fail("Timer test interrupted");
         }
 
-
+        // Save game state
         game.saveGameState();
 
-        // Spielstand laden und prüfen
+        // Load game state
         HitoriGameMain loadedGame = HitoriGameMain.loadGameState();
         assertNotNull(loadedGame);
         assertTrue(loadedGame.getWhiteCells()[0][0]);
@@ -76,17 +69,15 @@ class HitoriGameTest {
 
     @Test
     void testResetAll() {
-        // Testet das vollständige Zurücksetzen des Spiels
+        // Setup some game state
-
-        // Spielzustand einrichten
         game.markCellAsBlack(0, 0);
         game.startTimer();
         game.addHighScore("TestPlayer", 100);
 
-
+        // Reset everything
         game.reset();
 
-        // Prüfen, ob das Spiel zurückgesetzt wurde
+        // Verify reset
         assertFalse(game.getBlackCells()[0][0]);
         assertEquals(0, game.getElapsedTimeInSeconds());
         assertEquals(0, game.getMistakeCount());
@@ -94,11 +85,10 @@ class HitoriGameTest {
 
     @Test
     void testCompleteGameFlow() {
-        // Testet einen kompletten Spielablauf
+        // Start game
-
         game.startTimer();
 
-        // Zellen markieren, um das Spiel zu lösen
+        // Make some moves towards solution
         game.markCellAsBlack(0, 2);
         game.markCellAsWhite(0, 0);
         game.markCellAsWhite(0, 1);
@@ -109,14 +99,14 @@ class HitoriGameTest {
         game.markCellAsWhite(2, 1);
         game.markCellAsBlack(2, 2);
 
-
+        // Verify solution
         assertFalse(game.isSolved());
 
-
+        // Add score
         game.stopTimer();
         game.addHighScore("Winner", game.getElapsedTimeInSeconds());
 
-        // Prüfen, ob der Highscore gespeichert wurde
+        // Verify score was recorded
         boolean found = false;
         for (String score : game.getHighScoresWithAverage()) {
             if (score.contains("Winner")) {
@@ -129,9 +119,6 @@ class HitoriGameTest {
 
     @Test
     void testTimerPauseResume() {
-        // Testet das Pausieren und Fortsetzen des Timers
-
-
         game.startTimer();
         try {
             Thread.sleep(1000);
@@ -139,7 +126,6 @@ class HitoriGameTest {
             fail("Timer test interrupted");
         }
 
-        // Timer pausieren und aktuelle Zeit speichern
         game.pauseTimer();
         long pausedTime = game.getElapsedTimeInSeconds();
 
@@ -149,18 +135,17 @@ class HitoriGameTest {
             fail("Timer test interrupted");
         }
 
-        // Zeit sollte während der Pause nicht weiterlaufen
+        // Time should not increase while paused
         assertEquals(pausedTime, game.getElapsedTimeInSeconds());
 
-        // Timer fortsetzen und prüfen, ob Zeit weiterläuft
+        game.startTimer(); // Resume
-        game.startTimer();
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             fail("Timer test interrupted");
         }
 
-
+        // Time should increase after resume
         assertTrue(game.getElapsedTimeInSeconds() > pausedTime);
     }
 }

src/test/java/HitoriGameTimerTest.java

@@ -10,19 +10,17 @@ class HitoriGameTimerTest {
         timer = new HitoriGameTimer();
     }
 
-    // Testet den Anfangszustand des Timers
     @Test
     void testInitialState() {
         assertEquals(0, timer.getElapsedTimeInSeconds());
-        assertTrue(timer.isPaused());
+        assertFalse(timer.isPaused());
     }
 
-    // Testet das Starten des Timers
     @Test
     void testStartTimer() {
         timer.startTimer();
         try {
-            Thread.sleep(1100);
+            Thread.sleep(1100); // Wait a bit more than 1 second
         } catch (InterruptedException e) {
             fail("Timer test interrupted");
         }
@@ -31,7 +29,6 @@ class HitoriGameTimerTest {
         assertFalse(timer.isPaused());
     }
 
-    // Testet das Pausieren des Timers
     @Test
     void testPauseTimer() {
         timer.startTimer();
@@ -51,11 +48,10 @@ class HitoriGameTimerTest {
             fail("Timer test interrupted");
         }
 
-
+        // Time should not have increased while paused
         assertEquals(pausedTime, timer.getElapsedTimeInSeconds());
     }
 
-    // Testet das Fortsetzen des Timers nach einer Pause
     @Test
     void testResumeTimer() {
         timer.startTimer();
@@ -68,7 +64,7 @@ class HitoriGameTimerTest {
         timer.pauseTimer();
         long pausedTime = timer.getElapsedTimeInSeconds();
 
-        timer.startTimer();
+        timer.startTimer(); // Resume
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
@@ -78,7 +74,6 @@ class HitoriGameTimerTest {
         assertTrue(timer.getElapsedTimeInSeconds() > pausedTime);
     }
 
-    // Testet das Stoppen des Timers
     @Test
     void testStopTimer() {
         timer.startTimer();
@@ -100,7 +95,6 @@ class HitoriGameTimerTest {
         assertEquals(stoppedTime, timer.getElapsedTimeInSeconds());
     }
 
-    // Testet das Zurücksetzen des Timers
     @Test
     void testResetTimer() {
         timer.startTimer();
@@ -112,10 +106,9 @@ class HitoriGameTimerTest {
 
         timer.resetTimer();
         assertEquals(0, timer.getElapsedTimeInSeconds());
-        assertTrue(timer.isPaused());
+        assertFalse(timer.isPaused());
     }
 
-    // Testet das mehrfache Pausieren und Fortsetzen des Timers
     @Test
     void testMultiplePauseResume() {
         timer.startTimer();