Thomas sources for project

schach/Ressources/Library.txt

@@ -0,0 +1,259 @@
+1. Methode toPGN ist vorhanden in Klasse Game.java!!! Mit MoveGenerator werden schon alle legalen züge angezeigt!!!
+
+2. Klassen von GPT zusammengefasst:
+https://chatgpt.com/share/684326dc-4ea0-8012-8c10-8b34993140b7
+
+Event:
+
+Die Klasse Event beschreibt ein Schachturnier oder -ereignis mit Name, Ort, Datum, Zeitkontrollen, Rundenstruktur und referenzierten PGN-Daten.
+
+
+EventType:
+
+EventType beschreibt den strukturellen Typ eines Schachturniers (z. B. KO-System, Rundenturnier oder Analyseveranstaltung).
+
+
+Game:
+
+Die Klasse Game speichert und verwaltet alle Informationen einer Schachpartie – wie Züge, Spieler, Kommentare und Metadaten – und erlaubt deren Analyse, Bearbeitung und Ausgabe im PGN-Format.
+
+
+GameContext: 
+
+Die Klasse GameContext stellt alle benötigten Informationen und Methoden bereit, um Rochaden und Schachvarianten (z. B. Chess960) regelkonform zu verwalten und korrekt zu validieren.
+
+
+GameFactory:
+
+GameFactory stellt statische Hilfsmethoden bereit, um neue Schachobjekte (Spiel, Spieler, Runde, Event) schnell und einheitlich zu erzeugen.
+
+
+GameMode:
+
+GameMode legt fest, ob eine Partie zwischen Menschen, Maschinen oder gemischt (z. B. Engine vs Mensch) gespielt wird.
+
+
+GameResult:
+
+GameResult beschreibt, wie eine Schachpartie geendet hat (Sieg, Remis oder noch laufend) und verknüpft dies mit der entsprechenden PGN-Notation.
+
+
+MoveGeneratorException
+
+MoveGeneratorException signalisiert Fehler beim Generieren von Schachzügen und erlaubt dabei flexible Fehlerbeschreibungen.
+
+
+MoveList
+
+MoveList verwaltet eine Folge von Schachzügen und erlaubt deren Umwandlung, Validierung und Darstellung in verschiedenen Notationen basierend auf einer Ausgangsstellung.
+
+
+GameLoader:
+
+Die Klasse GameLoader lädt eine vollständige Schachpartie inklusive aller Metadaten und Züge aus einem PGN-Dateiiterator und wandelt sie in ein Game-Objekt um.
+
+
+
+GenericPlayer:
+
+Die Klasse GenericPlayer implementiert das Player-Interface und speichert die wichtigsten Eigenschaften eines Schachspielers wie Name, Elo, Typ (Mensch/Maschine) und Beschreibung.
+
+
+Mode:
+
+Mode beschreibt den Austragungsort einer Partie: entweder als Präsenzspiel am Brett (OTB) oder über einen Online-Server (ICS).
+
+
+MovePerTime:
+
+MovePerTime beschreibt eine Zeitkontrolle, bei der eine bestimmte Anzahl an Zügen in einer definierten Zeit (in Millisekunden) gespielt werden muss, z. B. 40/5400 (40 Züge in 90 Minuten).
+
+
+Player:
+
+Player ist ein Interface, das die grundlegenden Eigenschaften und Methoden eines Schachspielers festlegt, darunter ID, Name, Elo, Typ und eine ausführliche Beschreibung.
+
+
+PlayerType:
+
+PlayerType unterscheidet, ob ein Spieler ein Mensch (HUMAN) oder eine Engine (ENGINE) ist.
+
+
+Round:
+
+Round speichert eine bestimmte Runde eines Schachturniers und enthält eine Liste aller Partien (Game), die in dieser Runde gespielt werden.
+
+
+Termination:
+
+Termination gibt an, warum eine Partie beendet wurde, z. B. regulär, durch Zeitüberschreitung, Regelverstoß oder Abbruch.
+
+
+TimeControl:
+
+TimeControl speichert verschiedene Zeitregelungen für eine Partie – etwa klassische Zeitkontrollen, Bonuszeiten (Inkrement), feste Zugvorgaben, Knoten-/Tiefenlimits (für Engines) und gibt sie als PGN-kompatible Zeichenkette zurück.
+
+
+TimeControlType:
+
+TimeControlType gibt an, in welchem Modus eine Zeitkontrolle funktioniert, z. B. klassisches Zeitlimit mit Inkrement, Zeit pro Zug, feste Tiefe oder Knotenzahl (für Engines).
+
+
+VariationType:
+
+VariationType gibt an, welche Schachvariante gespielt wird – z. B. Standard-Schach, Chess960 oder Varianten mit speziellen Rochaderegeln oder Figurenmechaniken.
+
+
+Move:
+
+Move repräsentiert einen einzelnen Schachzug mit Start- und Zielfeld, optionaler Bauernumwandlung sowie SAN-Notation, und kann als Ereignis (BoardEvent) weiterverarbeitet werden.
+
+
+MoveConversionException:
+
+MoveConversionException signalisiert, dass ein Zug nicht korrekt aus einem Text (z. B. "e2e99" oder "z9z8Q") in ein gültiges Move-Objekt umgewandelt werden konnte.
+
+
+
+MoveException:
+
+MoveException signalisiert, dass ein Zug nicht auf dem aktuellen Spielstand ausgeführt werden kann – typischerweise, weil er regelwidrig, unmöglich oder logisch inkonsistent ist.
+
+
+MoveGenerator:
+
+MoveGenerator stellt statische Hilfsmethoden bereit, um aus einem gegebenen Schachbrettzustand alle möglichen Züge (pseudo-legal oder legal) zu erzeugen, einschließlich Spezialzüge wie Rochade oder Bauernumwandlungen.
+
+
+
+PgnException
+
+Die Klasse PgnException signalisiert Laufzeitfehler beim Parsen oder Einlesen von PGN-Schachpartien.
+
+
+PgnHolder
+
+Die Klasse PgnHolder verwaltet das Einlesen, Speichern und Abrufen von Schachpartien aus PGN-Dateien und organisiert dabei Spieler, Events und Spiele zentral in einer leicht zugänglichen Struktur.
+
+
+PgnIterator
+
+Die Klasse PgnIterator ermöglicht das speicherschonende Durchiterieren von Schachpartien in einer PGN-Datei, indem sie zeilenweise liest und jede Partie einzeln verarbeitet.
+
+
+PgnLoadListener
+
+Die Schnittstelle PgnLoadListener erlaubt es, auf Fortschritte beim Laden von PGN-Partien zu reagieren, indem sie bei jedem Ladefortschritt benachrichtigt wird.
+
+
+PgnProperty 
+
+
+Die Klasse PgnProperty modelliert eine einzelne PGN-Eigenschaft (Tag) und stellt Hilfsmethoden bereit, um sie aus einer Textzeile zu erkennen und zu extrahieren.
+
+
+UnicodePrinter
+
+
+Die Klasse UnicodePrinter druckt ein Schachbrett-Objekt (Board) als ASCII-Art mit Unicode-Schachsymbolen zeilenweise in die Konsole oder in einen beliebigen Ausgabestrom.
+
+
+LargeFile
+
+
+Die Klasse LargeFile erlaubt das effiziente und speicherschonende zeilenweise Lesen großer Textdateien oder Eingabeströme durch Bereitstellung eines einfachen Java-Iterators.
+
+
+StringUtil 
+
+
+Die Klasse StringUtil stellt nützliche Methoden zur Verfügung, um Zeichenketten effizient zu analysieren, zu verändern und zu übersetzen – insbesondere bei der Verarbeitung von Schach-PGN-Daten.
+
+
+XorShiftRandom 
+
+Die Klasse XorShiftRandom implementiert einen leistungsfähigen, einfachen Pseudozufallszahlengenerator auf Basis des Xorshift-Verfahrens, der deterministische long-Werte durch Bitoperationen erzeugt.
+
+
+Bitboard
+
+Die Klasse Bitboard stellt für jedes Schachfeld und diverse Feldergruppen (Reihen, Linien, Diagonalen) Bitmasken bereit, um Schachpositionen effizient mit Bitoperationen zu verarbeiten.
+
+
+Board 
+
+Die Klasse Board modelliert ein vollständiges Schachbrett inklusive Spielregeln, Figurenpositionen, Zugverlauf und ermöglicht die Validierung, Durchführung und Rücknahme von Schachzügen.
+
+
+BoardEvent 
+
+Das Interface BoardEvent definiert die Struktur für Ereignisse, die beim Ändern des Schachbretts ausgelöst und an Listener weitergegeben werden können.
+
+
+
+BoardEventListener 
+
+Das Interface BoardEventListener erlaubt es, auf Ereignisse wie Züge oder Statusänderungen des Schachbretts zu reagieren, indem es über die Methode onEvent() benachrichtigt wird.
+
+
+
+BoardEventType 
+
+Das Enum BoardEventType definiert die Arten von Ereignissen, die auf einem Schachbrett ausgelöst und über Event-Listener verarbeitet werden können – etwa beim Ziehen, Zurücknehmen oder Laden.
+
+
+CastleRight 
+
+Das Enum CastleRight beschreibt, ob eine Seite im Schach kurz, lang, beides oder gar nicht rochieren darf.
+
+
+Constants 
+
+Die Klasse Constants bündelt feste, zentrale Informationen und Züge wie die Start-FEN, Rochadepfade und Figur-Notation, um typische Schachsituationen schnell und konsistent abrufen zu können.
+
+
+DiagonalA1H8 
+
+Die Enum DiagonalA1H8 listet alle rechtsschiefen (↘️) Diagonalen des Schachbretts als konstante Werte mit eindeutiger Namensgebung der Begrenzungsfelder auf.
+
+
+DiagonalH1A8 
+
+Die Enum DiagonalH1A8 listet alle linksschiefen (↙️) Diagonalen des Schachbretts auf, wobei jede Diagonale durch ihre Randfelder eindeutig benannt ist.
+
+
+File 
+
+Das Enum File beschreibt die Spalten (A–H) des Schachbretts samt zugehöriger Notation und ermöglicht deren einfache Nutzung in Code und Notationen.
+
+
+MoveBackup 
+
+Die Klasse MoveBackup speichert alle relevanten Zustandsinformationen eines Schachbretts vor einem Zug, um diesen später vollständig rückgängig machen zu können.
+
+
+Piece 
+
+Die Klasse Piece repräsentiert jede konkrete Schachfigur mit Farbe und Typ und bietet Methoden zur Erstellung und Notation dieser Figuren.
+
+
+PieceType 
+
+PieceType beschreibt die Typen von Schachfiguren (z. B. Turm, König) und verknüpft sie mit ihrer algebraischen Notation für einfache Identifikation und Verarbeitung.
+
+
+Rank 
+
+Rank beschreibt die horizontalen Reihen des Schachbretts und stellt deren numerische Notation zur Verfügung, um Positionen eindeutig identifizieren zu können.
+
+
+Side
+
+Side repräsentiert eine der beiden Spielerparteien im Schach – Weiß oder Schwarz – und ermöglicht den einfachen Wechsel der Seite mit der Methode flip().
+
+
+Square 
+
+Square ist ein mächtiges enum, das jedes Schachfeld eindeutig repräsentiert und dabei zahlreiche Hilfsmethoden zur Brettlogik und Bitboard-Darstellung bereitstellt. Es ist eine der Grundpfeiler des gesamten Schachsystems.
+
+

schach/Ressources/Quellen.txt

@@ -0,0 +1,21 @@
+Quellen
+
+Thomas Müller | 3021788
+Timer    https://chatgpt.com/c/6857ff1e-7ff4-8006-aba3-60d3a2dd59b4
+
+Valentin Weller | 3019075
+
+Junit: 	   https://chatgpt.com/share/6859a713-4b98-8012-8cb2-a9f3c7fb37c8
+QuickSave: https://chatgpt.com/share/6859a73f-e750-8012-a168-f9fa7c5487bd
+PGNs:	   https://chatgpt.com/share/6859a8f1-d3c4-8012-98f4-6ae4b057be73   
+	   https://chatgpt.com/share/6859a95a-cca8-8012-bbbe-4e4b4517d5d9
+
+Eröffnungserkennung: https://github.com/hell-sh/CompactChessOpenings/blob/master/src/sh/hell/compactchess/game/Opening.java
+
+Quellen
+
+Justin Muravjev  3014931
+
+ChatGPT:
+https://chatgpt.com/share/685a60b4-dad0-8012-86a8-ca9a7e6eb76b
+

schach/pom.xml

@@ -10,13 +10,12 @@
   <version>0.0.1-SNAPSHOT</version>
 
   <name>schach</name>
-  <description>A simple schach.</description>
+  <description>A simple schach project</description>
   <url>http://www.example.com</url>
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <maven.compiler.source>21</maven.compiler.source>
-    <maven.compiler.target>21</maven.compiler.target>
+    <maven.compiler.release>17</maven.compiler.release>
   </properties>
 
   <repositories>
@@ -27,29 +26,31 @@
   </repositories>
 
   <dependencies>
-    <!-- Schachlib (bhlangonijr) -->
+    <!-- Schachlib -->
     <dependency>
       <groupId>com.github.bhlangonijr</groupId>
       <artifactId>chesslib</artifactId>
       <version>1.3.4</version>
     </dependency>
-   <dependency>
-    <groupId>org.junit.jupiter</groupId>
-    <artifactId>junit-jupiter</artifactId>
-    <version>5.10.2</version>
-    <scope>test</scope>
-</dependency>
-    <!-- Mockito damit man Controller und Gui besser testen kann-->
+
     <dependency>
-    	<groupId>org.mockito</groupId>
-    	<artifactId>mockito-core</artifactId>
-    	<version>5.11.0</version>
-    	<scope>test</scope>
+	    <groupId>org.junit.jupiter</groupId>
+	    <artifactId>junit-jupiter</artifactId>
+	    <version>5.10.2</version>
+	    <scope>test</scope>
 	</dependency>
 
-  </dependencies>
+    <!-- Mockito -->
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <version>5.11.0</version>
+      <scope>test</scope>
+    </dependency>
+ </dependencies>
 
   <build>
+
     <pluginManagement>
       <plugins>
         <plugin>
@@ -89,14 +90,60 @@
           <version>3.1.2</version>
         </plugin>
       </plugins>
-    </pluginManagement> 
+    </pluginManagement>
+    <plugins>
+      <!-- Java Compiler Plugin -->
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.13.0</version>
+        <configuration>
+          <release>17</release>
+        </configuration>
+      </plugin>
+
+      <!-- PMD Plugin -->
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-pmd-plugin</artifactId>
+        <version>3.21.0</version>
+        <configuration>
+          <!-- Set to 17 until PMD supports 21 -->
+          <targetJdk>17</targetJdk>
+          <failOnViolation>false</failOnViolation>
+          <printFailingErrors>true</printFailingErrors>
+          <linkXRef>false</linkXRef>
+          <rulesets>
+            <ruleset>rulesets/java/quickstart.xml</ruleset>
+            <ruleset>rulesets/java/basic.xml</ruleset>
+            <ruleset>rulesets/java/braces.xml</ruleset>
+            <ruleset>rulesets/java/unusedcode.xml</ruleset>
+            <ruleset>rulesets/java/imports.xml</ruleset>
+          </rulesets>
+        </configuration>
+        <executions>
+          <execution>
+            <phase>verify</phase>
+            <goals>
+              <goal>check</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+
+      <!-- Surefire Plugin for tests -->
+      <plugin>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>3.3.0</version>
+      </plugin>
+	</plugins>
   </build>
 
   <reporting>
     <plugins>
       <plugin>
         <artifactId>maven-project-info-reports-plugin</artifactId>
+        <version>3.6.1</version>
       </plugin>
     </plugins>
   </reporting>
-</project>
+</project>

schach/src/main/java/de/hs_mannheim/informatik/chess/controller/CreativeController.java

@@ -29,7 +29,7 @@ public class CreativeController {
         map.put("WHITE_ROOK",   'R');
         map.put("WHITE_BISHOP", 'B');
         map.put("WHITE_KNIGHT", 'N');
-        map.put("WHITE_PAWN",   'P');
+        map.put("WHITE_PAWN",   'P'); 
         return map;
     }
 

schach/src/main/java/de/hs_mannheim/informatik/chess/controller/GameController.java

@@ -7,15 +7,17 @@ import java.util.ArrayList;
 import java.util.List;
 
 import javax.swing.BorderFactory;
+import javax.swing.JOptionPane;
 
 import com.github.bhlangonijr.chesslib.game.Game;
 
 import de.hs_mannheim.informatik.chess.model.ChessEngine;
+import de.hs_mannheim.informatik.chess.model.GameMode;
 import de.hs_mannheim.informatik.chess.model.MoveDTO;
 import de.hs_mannheim.informatik.chess.model.PieceDTO;
+import de.hs_mannheim.informatik.chess.model.Timer;
 import de.hs_mannheim.informatik.chess.model.BoardDTO;
 import de.hs_mannheim.informatik.chess.view.GameGui;
-import de.hs_mannheim.informatik.chess.view.MainGui;
 
 public class GameController {
     GameGui gui;
@@ -23,25 +25,58 @@ public class GameController {
     GameEndCallback callback;
     
     private boolean gameOver = false;
-    private int selectedRow = -1, selectedCol = -1;
+    private int selectedRow = -1;
+    private int selectedCol = -1;
     private List<int[]> highlightedFields = new ArrayList<>();
+    private boolean gameWasResignedOrDrawn = false;
+    private GameMode gameMode;
     
+    public GameController(GameGui gui, ChessEngine engine, GameEndCallback callback, GameMode gameMode) {
+        this(gui, engine, callback); // ruft anderen Konstruktor auf
+        this.gameMode = gameMode;
+        if (gameMode != null) {
+            engine.initTimers(gameMode.minutes, gameMode.incrementSeconds);
+            setupAndStartTimers();
+        }
+        addWindowCloseListener();
+    }
+
+    // Für Creative/PGN-Mode (ohne Zeit)
     public GameController(GameGui gui, ChessEngine engine, GameEndCallback callback) {
         this.gui = gui;
         this.engine = engine;
         this.callback = callback;
-        engine.initTimers(3, 0); 
-        time();
+        this.gameMode = null;
+        addWindowCloseListener();
+        // KEINE Timer initialisieren
         initListeners();
         updateGuiBoard();
     }
-    private void time() {
-    	engine.getWhiteTimer().setOnTick(secs -> gui.updateWhiteTimerLabel(secs));
-        engine.getBlackTimer().setOnTick(secs -> gui.updateBlackTimerLabel(secs));
-        engine.getWhiteTimer().setOnTimeout(() -> onTimeout("WHITE"));
-        engine.getBlackTimer().setOnTimeout(() -> onTimeout("BLACK"));
-        engine.getWhiteTimer().start();
+    
+    private void setupAndStartTimers() {
+        if (engine.getWhiteTimer() != null) {
+            engine.getWhiteTimer().setOnTick(secs -> gui.updateWhiteTimerLabel(secs));
+            engine.getWhiteTimer().setOnTimeout(() -> onTimeout("WHITE"));
+            engine.getWhiteTimer().stop(); // <-- WICHTIG!
+        }
+        if (engine.getBlackTimer() != null) {
+            engine.getBlackTimer().setOnTick(secs -> gui.updateBlackTimerLabel(secs));
+            engine.getBlackTimer().setOnTimeout(() -> onTimeout("BLACK"));
+            engine.getBlackTimer().stop(); // <-- WICHTIG!
+        }
+        // Timer-Labels initial setzen
+        if (engine.getWhiteTimer() != null) gui.updateWhiteTimerLabel(engine.getWhiteTimer().getSecondsLeft());
+        if (engine.getBlackTimer() != null) gui.updateBlackTimerLabel(engine.getBlackTimer().getSecondsLeft());
+
+        // Aktuellen Spieler-Timer starten:
+        if (engine.getCurrentPlayer().equals("WHITE")) {
+            engine.getWhiteTimer().start();
+        } else {
+            engine.getBlackTimer().start();
+        }
     }
+
+
     private int flipRow(int row) {
         return gui.isFlipped() ? 7 - row : row;
     }
@@ -49,6 +84,20 @@ public class GameController {
         return gui.isFlipped() ? 7 - col : col;
     }
     
+    private void addWindowCloseListener() {
+        if (gui.getFrame() != null) {
+            gui.getFrame().addWindowListener(new java.awt.event.WindowAdapter() {
+                @Override
+                public void windowClosing(java.awt.event.WindowEvent e) {
+                    if (!gameOver) {
+                        engine.quicksave();
+                        MainController.engineRAM = engine;
+                    }
+                    new MainController();
+                }
+            });
+        }
+    }
     private void initListeners() {
         for (int row = 0; row < 8; row++) {
             for (int col = 0; col < 8; col++) {
@@ -126,41 +175,41 @@ public class GameController {
      // --- AUFGEBEN-BUTTON ---
         gui.getResignButton().addActionListener(e -> {
             if (gameOver) return;
-
-            int answer = javax.swing.JOptionPane.showConfirmDialog(
+            int answer = JOptionPane.showConfirmDialog(
                 null,
                 "Willst du wirklich aufgeben?",
                 "Aufgeben",
-                javax.swing.JOptionPane.YES_NO_OPTION
+                JOptionPane.YES_NO_OPTION
             );
-            if (answer == javax.swing.JOptionPane.YES_OPTION) {
+            if (answer == JOptionPane.YES_OPTION) {
                 gameOver = true;
+                gameWasResignedOrDrawn = true; // <<<<<<
                 String winner = engine.getCurrentPlayer().equals("WHITE") ? "SCHWARZ" : "WEIß";
                 gui.displayMessage(winner + " gewinnt durch Aufgabe!");
-                engine.getWhiteTimer().stop();
-                engine.getBlackTimer().stop();
+                if (engine.getWhiteTimer() != null) engine.getWhiteTimer().stop();
+                if (engine.getBlackTimer() != null) engine.getBlackTimer().stop();
                 askForRestart();
             }
         });
 
-        // --- PATT-/REMIS-BUTTON ---
         gui.getDrawButton().addActionListener(e -> {
             if (gameOver) return;
-
-            int answer = javax.swing.JOptionPane.showConfirmDialog(
+            int answer = JOptionPane.showConfirmDialog(
                 null,
                 "Remis anbieten? (Das Spiel endet sofort unentschieden)",
                 "Remis",
-                javax.swing.JOptionPane.YES_NO_OPTION
+                JOptionPane.YES_NO_OPTION
             );
-            if (answer == javax.swing.JOptionPane.YES_OPTION) {
+            if (answer == JOptionPane.YES_OPTION) {
                 gameOver = true;
+                gameWasResignedOrDrawn = true; // <<<<<<
                 gui.displayMessage("Remis! (durch Einigung)");
-                engine.getWhiteTimer().stop();
-                engine.getBlackTimer().stop();
+                if (engine.getWhiteTimer() != null) engine.getWhiteTimer().stop();
+                if (engine.getBlackTimer() != null) engine.getBlackTimer().stop();
                 askForRestart();
             }
         });
+
         
         gui.getUndoButton().addActionListener(e -> {
             // Wer ist am Zug? (Das ist der, der gefragt wird)
@@ -279,6 +328,8 @@ public class GameController {
 
         updateGuiBoard();
         gui.updateMoveList(engine.getMoveListStringsGrouped());
+        
+        
 
         // ---- HIER ist die Matt/Patt/Remis-Prüfung ----
         if (engine.isMated()) {
@@ -305,12 +356,25 @@ public class GameController {
     }
     
     private void switchTimers() {
+        GameMode mode = engine.getGameMode();
+        Timer whiteTimer = engine.getWhiteTimer();
+        Timer blackTimer = engine.getBlackTimer();
+
+        // Wenn KEIN Modus (also kein Timer): NICHTS machen!
+        if (mode == null || whiteTimer == null || blackTimer == null) return;
+
         if (engine.getCurrentPlayer().equals("WHITE")) {
-            engine.getBlackTimer().stop();
-            engine.getWhiteTimer().start();
+            if (mode.incrementSeconds > 0) {
+                blackTimer.addSeconds(mode.incrementSeconds);
+            }
+            blackTimer.stop();
+            whiteTimer.start();
         } else {
-            engine.getWhiteTimer().stop();
-            engine.getBlackTimer().start();
+            if (mode.incrementSeconds > 0) {
+                whiteTimer.addSeconds(mode.incrementSeconds);
+            }
+            whiteTimer.stop();
+            blackTimer.start();
         }
     }
 
@@ -322,7 +386,7 @@ public class GameController {
         return "" + file + rank;
     }
     
-
+    
 	 // Timeout-Methode
     private void onTimeout(String color) {
         if (gameOver) return; // Doppelt hält besser
@@ -335,19 +399,31 @@ public class GameController {
     }
     
     private void askForRestart() {
-        int answer = javax.swing.JOptionPane.showConfirmDialog(
+        int answer = JOptionPane.showConfirmDialog(
             null,
             "Neue Partie starten?",
             "Spiel beendet",
-            javax.swing.JOptionPane.YES_NO_OPTION
+            JOptionPane.YES_NO_OPTION
         );
         javax.swing.SwingUtilities.getWindowAncestor(gui.getField(0, 0)).dispose();
-        if (answer == javax.swing.JOptionPane.YES_OPTION) {
+        if (answer == JOptionPane.YES_OPTION) {
+            engine.clearQuicksave();
+            MainController.engineRAM = null;
             callback.onNewGameRequested();
         } else {
+            // HIER: QuickSave **NUR** falls das Spiel NICHT durch Aufgabe/Remis/Patt beendet wurde!
+            if (!gameWasResignedOrDrawn) {
+                engine.quicksave();
+                MainController.engineRAM = engine;
+            } else {
+                engine.clearQuicksave();
+                MainController.engineRAM = null;
+            }
             callback.onReturnToMenu();
         }
+        gameWasResignedOrDrawn = false; // Reset für nächstes Spiel
     }
+
     
     private void resetFieldBackground(int row, int col) {
         Color LIGHT = new Color(0xe0e1dd);

schach/src/main/java/de/hs_mannheim/informatik/chess/controller/MainController.java

@@ -5,6 +5,7 @@ import de.hs_mannheim.informatik.chess.view.PgnGui;
 import de.hs_mannheim.informatik.chess.view.PgnSelectionGui;
 import de.hs_mannheim.informatik.chess.view.CreativeGui;
 import de.hs_mannheim.informatik.chess.view.GameGui;
+import de.hs_mannheim.informatik.chess.view.GameModeSelector;
 
 import java.io.IOException;
 import java.util.List;
@@ -15,9 +16,11 @@ import javax.swing.JOptionPane;
 import com.github.bhlangonijr.chesslib.game.Game;
 
 import de.hs_mannheim.informatik.chess.model.ChessEngine;
+import de.hs_mannheim.informatik.chess.model.GameMode;
 
 public class MainController {
     private MainGui mainGui;
+    static ChessEngine engineRAM = null;
 
     public MainController() {
         mainGui = new MainGui();
@@ -28,18 +31,54 @@ public class MainController {
     }
 
     private void startNormalMode() {
+        // Prüfe, ob es im RAM ein Quicksave gibt:
+    	if (engineRAM != null && engineRAM.quickload()) {
+    	    int choice = JOptionPane.showConfirmDialog(
+    	        null,
+    	        "Letzte Partie fortsetzen?",
+    	        "Quicksave gefunden",
+    	        JOptionPane.YES_NO_OPTION
+    	    );
+    	    if (choice == JOptionPane.YES_OPTION) {
+    	        GameGui gameGui = new GameGui();
+    	        GameEndCallback callback = new GameEndCallback() {
+    	            public void onNewGameRequested() { startNormalMode(); }
+    	            public void onReturnToMenu() { new MainController(); }
+    	        };
+    	        new GameController(gameGui, engineRAM, callback); // KEIN initTimers, KEIN neuer Engine!
+    	        // --- Timerlabels aktualisieren
+    	        gameGui.updateWhiteTimerLabel(engineRAM.getWhiteTimer().getSecondsLeft());
+    	        gameGui.updateBlackTimerLabel(engineRAM.getBlackTimer().getSecondsLeft());
+    	        // --- Timer des aktuellen Spielers starten
+    	        if (engineRAM.getCurrentPlayer().equals("WHITE")) {
+    	            engineRAM.getWhiteTimer().start();
+    	        } else {
+    	            engineRAM.getBlackTimer().start();
+    	        }
+    	        mainGui.close();
+    	        return; // Fertig!
+    	    } else {
+    	        engineRAM.clearQuicksave();
+    	        engineRAM = null;
+    	    }
+    	}
+
+        // Neues Spiel normal starten:
+        GameMode mode = GameModeSelector.selectGameMode();
+        if (mode == null) return;
         mainGui.close();
+        ChessEngine engine = new ChessEngine(mode);
+        engineRAM = engine; // Für spätere Quicksaves merken!
         GameGui gameGui = new GameGui();
-        ChessEngine engine = new ChessEngine();
         GameEndCallback callback = new GameEndCallback() {
             public void onNewGameRequested() {
                 startNormalMode();
             }
             public void onReturnToMenu() {
-            	new MainController();
+                new MainController();
             }
         };
-        new GameController(gameGui, engine, callback);
+        new GameController(gameGui, engine, callback, mode);
     }
 
     private void startCreativeMode() {
@@ -49,21 +88,22 @@ public class MainController {
         new CreativeController(creativegui, engine);
 
         creativegui.setStartGameCallback(fen -> {
+            // 1. Modus-Auswahl-Dialog zeigen!
+            GameMode mode = GameModeSelector.selectGameMode(); // (Dialog, wie beim Normal Mode)
 
-            ChessEngine newEngine = new ChessEngine();
+            if (mode == null) return; // User hat abgebrochen → nichts machen
+            
+
+            ChessEngine newEngine = new ChessEngine(mode); // Engine mit Modus (Timer)
             newEngine.setPositionFromFEN(fen);
 
             GameGui gameGui = new GameGui();
-
             GameEndCallback callback = new GameEndCallback() {
-                public void onNewGameRequested() {
-                    startCreativeMode(); 
-                }
-                public void onReturnToMenu() {
-                    new MainController();
-                }
+                public void onNewGameRequested() { startCreativeMode(); }
+                public void onReturnToMenu() { new MainController(); }
             };
-            new GameController(gameGui, newEngine, callback);
+            new GameController(gameGui, newEngine, callback, mode); // mit Timer/ohne je nach Modus
+            creativegui.close();
         });
     }
     
@@ -86,5 +126,6 @@ public class MainController {
                 JOptionPane.showMessageDialog(null, "Fehler beim Laden der PGN-Datei:\n" + ex.getMessage());
             }
         }
+        mainGui.close();
     }
 }

schach/src/main/java/de/hs_mannheim/informatik/chess/model/ChessEngine.java

@@ -1,8 +1,10 @@
 package de.hs_mannheim.informatik.chess.model;
+
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.logging.ConsoleHandler;
@@ -18,400 +20,505 @@ import com.github.bhlangonijr.chesslib.move.Move;
 import com.github.bhlangonijr.chesslib.pgn.PgnHolder;
 import com.github.bhlangonijr.chesslib.game.*;
 import com.github.bhlangonijr.chesslib.move.MoveList;
-import java.time.LocalDate;
 import com.github.bhlangonijr.chesslib.Side;
 
-
 public class ChessEngine {
 	private Board board;
 	private List<Move> moves = new ArrayList<>();
 	private String initialFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 	private static final Logger logger = Logger.getLogger(ChessEngine.class.getName());
-	
+	private int quicksaveWhiteTimeLeft = -1;
+	private int quicksaveBlackTimeLeft = -1;
 	private int currentMoveIndex = 0;
 	private Timer whiteTimer;
 	private Timer blackTimer;
-	
+	private final GameMode mode;
+	private String quicksaveFen = null;
+	private List<Move> quicksaveMoves = null;
+	private int quicksaveMoveIndex = 0;
 	private Opening detectedOpening = null;
-	
-    public ChessEngine() {
-    	logging();
-        board = new Board();
-    }
-    public boolean move(MoveDTO move) {
-        String from = "" + (char)('A' + move.getFromCol()) + (8 - move.getFromRow());
-        String to = "" + (char)('A' + move.getToCol()) + (8 - move.getToRow());
-        Move libMove = new Move(Square.valueOf(from), Square.valueOf(to));
-        if (board.legalMoves().contains(libMove)) {
-            board.doMove(libMove);
 
-            // Replay? Dann abschneiden
-            if (currentMoveIndex < moves.size()) {
-                logger.info("Replay-Modus: Züge nach " + currentMoveIndex + " werden entfernt.");
-                moves = new ArrayList<>(moves.subList(0, currentMoveIndex));
-            }
-            moves.add(libMove);
-            currentMoveIndex++;
-            logger.info("Zug erfolgreich durchgeführt: " + libMove);
+	public ChessEngine() {
+		this.mode = null;
+		logging();
+		board = new Board();
+	}
 
-            // Opening-Erkennung nach jedem erfolgreichen Zug
-            String playedMovesUci = movesToUciString(moves);
-            detectedOpening = Opening.detect(playedMovesUci);
+	public ChessEngine(GameMode mode) {
+		this.mode = mode;
+		whiteTimer = new Timer(mode.minutes, mode.seconds);
+		blackTimer = new Timer(mode.minutes, mode.seconds);
+		logging();
+		board = new Board();
+	}
 
-            if (detectedOpening != null) {
-                logger.info("Aktuelles Opening erkannt: " + detectedOpening.getEco() + " - " + detectedOpening.getName());
-                // Optional: Speichere das Opening in ein Feld, falls benötigt
-            }
-            return true;
-        }
-        logger.warning("Ungültiger Zug: " + libMove);
-        return false;
-    }
+	public boolean move(MoveDTO move) {
+		String from = "" + (char) ('A' + move.getFromCol()) + (8 - move.getFromRow());
+		String to = "" + (char) ('A' + move.getToCol()) + (8 - move.getToRow());
+		Move libMove = new Move(Square.valueOf(from), Square.valueOf(to));
+		if (board.legalMoves().contains(libMove)) {
+			board.doMove(libMove);
 
-    public String getOpeningName() {
-        if (detectedOpening != null) {
-            return detectedOpening.getEco() + " - " + detectedOpening.getName();
-        } else {
-            return "unbekannt";
-        }
-    }
-    
-    private String movesToUciString(List<Move> moves) {
-        StringBuilder sb = new StringBuilder();
-        for (Move m : moves) {
-            sb.append(m.toString()).append(" ");
-        }
-        return sb.toString().trim();
-    }
-    
-    public List<MoveDTO> getLegalDestinations(String from) {
-        logger.info("Hole legale Züge von: " + from);
-        List<MoveDTO> destinations = new ArrayList<>();
-        try {
-            Square fromSq = Square.valueOf(from.toUpperCase());
-            for (Move move : board.legalMoves()) {
-                if (move.getFrom().equals(fromSq)) {
-                    int fromRow = 8 - fromSq.getRank().ordinal() - 1;
-                    int fromCol = fromSq.getFile().ordinal();
-                    int toRow = 8 - move.getTo().getRank().ordinal() - 1;
-                    int toCol = move.getTo().getFile().ordinal();
-                    destinations.add(new MoveDTO(fromRow, fromCol, toRow, toCol));
-                }
-            }
-            logger.info("Es wurden " + destinations.size() + " Ziele gefunden.");
-        } catch (Exception e) {
-            logger.severe("Fehler beim Holen der legalen Ziele: " + e.getMessage());
-        }
-        return destinations;
-    }
-    
-    public List<String> getMoveListStringsGrouped() {
-        logger.info("Gruppiere Züge für Anzeige.");
-        List<String> result = new ArrayList<>();
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < moves.size(); i++) {
-            if (i % 2 == 0) sb.append((i/2 + 1) + ". ");
-            sb.append(moves.get(i).toString()).append(" ");
-            if (i % 2 == 1 || i == moves.size() - 1) {
-                result.add(sb.toString().trim());
-                sb = new StringBuilder();
-            }
-        }
-        return result;
-    }
-    
-    public PieceDTO getPieceAt(String square) {
-    	logger.info("Hole Figur an Feld: " + square);
-        Piece piece = board.getPiece(Square.valueOf(square.toUpperCase()));
-        return convertPieceToDTO(piece);
-    }
-    
-    public boolean moveWithPromotion(MoveDTO move, String promotionPiece) {
-        String from = "" + (char)('A' + move.getFromCol()) + (8 - move.getFromRow());
-        String to   = "" + (char)('A' + move.getToCol())   + (8 - move.getToRow());
+			if (currentMoveIndex < moves.size()) {
+				if (logger.isLoggable(Level.INFO)) {
+					logger.info("Replay-Modus: Züge nach " + currentMoveIndex + " werden entfernt.");
+				}
+				moves = new ArrayList<>(moves.subList(0, currentMoveIndex));
+			}
+			moves.add(libMove);
+			currentMoveIndex++;
+			if (logger.isLoggable(Level.INFO)) {
+				logger.info("Zug erfolgreich durchgeführt: " + libMove);
+			}
 
-        // Die Farbe bestimmen!
-        boolean isWhite = (8 - move.getFromRow()) < (8 - move.getToRow());
-        Piece promotion;
-        switch (promotionPiece) {
-            case "ROOK":   promotion = isWhite ? Piece.WHITE_ROOK   : Piece.BLACK_ROOK; break;
-            case "KNIGHT": promotion = isWhite ? Piece.WHITE_KNIGHT : Piece.BLACK_KNIGHT; break;
-            case "BISHOP": promotion = isWhite ? Piece.WHITE_BISHOP : Piece.BLACK_BISHOP; break;
-            default:       promotion = isWhite ? Piece.WHITE_QUEEN  : Piece.BLACK_QUEEN;
-        }
+			String playedMovesUci = movesToUciString(moves);
+			detectedOpening = Opening.detect(playedMovesUci);
 
-        Move libMove = new Move(Square.valueOf(from), Square.valueOf(to), promotion);
+			if (detectedOpening != null && logger.isLoggable(Level.INFO)) {
+				logger.info("Aktuelles Opening erkannt: " + detectedOpening.getEco() + " - " + detectedOpening.getName());
+			}
+			return true;
+		}
+		if (logger.isLoggable(Level.WARNING)) {
+			logger.warning("Ungültiger Zug: " + libMove);
+		}
+		return false;
+	}
 
-        if (board.legalMoves().contains(libMove)) {
-            board.doMove(libMove);
+	public String getOpeningName() {
+		if (detectedOpening != null) {
+			return detectedOpening.getEco() + " - " + detectedOpening.getName();
+		} else {
+			return "unbekannt";
+		}
+	}
 
-            if (currentMoveIndex < moves.size()) {
-                moves = new ArrayList<>(moves.subList(0, currentMoveIndex));
-            }
-            moves.add(libMove);
-            currentMoveIndex++;
-            logger.info("Promotionszug durchgeführt: " + libMove);
-            return true;
-        }
-        logger.warning("Ungültiger Promotionszug: " + libMove);
-        return false;
-    }
-    
-    public BoardDTO getBoardAsDTO() {
-    	logger.info("Erstelle DTO-Abbild des Boards");
-        PieceDTO[][] dtoBoard = new PieceDTO[8][8];
-        for (int rank = 8; rank >= 1; rank--) {
-            for (int file = 0; file < 8; file++) {
-                Square square = Square.valueOf("" + (char)('A' + file) + rank);
-                Piece piece = board.getPiece(square);
-                dtoBoard[8-rank][file] = convertPieceToDTO(piece);
-            }
-        }
-        return new BoardDTO(dtoBoard);
-    }
-    
-    private String pieceToUnicode(Piece piece) {
-        switch (piece) {
-            case WHITE_KING: return "♔";
-            case WHITE_QUEEN: return "♕";
-            case WHITE_ROOK: return "♖";
-            case WHITE_BISHOP: return "♗";
-            case WHITE_KNIGHT: return "♘";
-            case WHITE_PAWN: return "♙";
-            case BLACK_KING: return "♚";
-            case BLACK_QUEEN: return "♛";
-            case BLACK_ROOK: return "♜";
-            case BLACK_BISHOP: return "♝";
-            case BLACK_KNIGHT: return "♞";
-            case BLACK_PAWN: return "♟";
-            default: return " ";
-        }
-    }
-    
-    public void setPositionToMoveIndex(int idx) {
-        logger.info("Setze Board auf Zug-Index: " + idx);
-        board = new Board();
-        board.loadFromFen(initialFen); // Statt new Board() -> initialFen!
-        for (int i = 0; i < idx; i++) {
-            board.doMove(moves.get(i));
-        }
-        currentMoveIndex = idx;
-        
-        String playedMovesUci = movesToUciString(moves.subList(0, idx));
-        detectedOpening = Opening.detect(playedMovesUci);
-    }
-    public int getCurrentMoveIndex() { 
-    	logger.info("Hole aktuellen Zug-Index: " + currentMoveIndex);
-    	return currentMoveIndex; 
-    }
-    
-    public int getMoveListSize() {
-    	logger.info("Hole Anzahl gespielter Züge: " + moves.size());
-    	return moves.size(); 
-    }
-    
-    private PieceDTO convertPieceToDTO(Piece piece) {
-        if (piece == null || piece.equals(Piece.NONE)) return null;
-        String color = piece.name().startsWith("WHITE") ? "WHITE" : "BLACK";
-        String type = piece.name().substring(piece.name().indexOf('_') + 1); // "PAWN", "KING"...
-        String symbol = pieceToUnicode(piece);
-        return new PieceDTO(type, color, symbol);
-    }
-    
-    public void setPositionFromFEN(String fen) {
-        board.loadFromFen(fen);
-        initialFen = fen; 
-    }
+	private String movesToUciString(List<Move> moves) {
+		StringBuilder sb = new StringBuilder();
+		for (Move m : moves) {
+			sb.append(m.toString()).append(" ");
+		}
+		return sb.toString().trim();
+	}
 
-    
-    public boolean isMated() {
-        boolean mated = board.isMated();
-        logger.info("isMated() = " + mated);
-        return mated;
-    }
-    
-    public boolean isStalemate() {
-        boolean stale = board.isStaleMate();
-        logger.info("isStalemate() = " + stale);
-        return stale;
-    }
-    
-    public boolean isDraw() {
-        boolean draw = board.isDraw();
-        logger.info("isDraw() = " + draw);
-        return draw;
-    }
-    
-    public String getCurrentPlayer() {
-        String player = board.getSideToMove().toString();
-        logger.info("Am Zug: " + player);
-        return player;
-    }
-    
-    public void logging() {
-    	
-    	// Eigener Handler nur für diese Klasse
-        ConsoleHandler handler = new ConsoleHandler();
-        handler.setLevel(Level.ALL);
-        handler.setFormatter(new SimpleFormatter() {
-            @Override
-            public synchronized String format(LogRecord lr) {
-                return String.format("[%s] %s%n%n", lr.getLevel().getLocalizedName(), lr.getMessage());
-            }
-        });
-        logger.setUseParentHandlers(false); 
-        logger.addHandler(handler);
-        
-        logger.info("ChessEngine wurde initialisiert.");
-    }
-    
-    public List<Game> loadGamesFromPgn(String path) throws IOException {
+	public List<MoveDTO> getLegalDestinations(String from) {
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("Hole legale Züge von: " + from);
+		}
+		List<MoveDTO> destinations = new ArrayList<>();
+		try {
+			Square fromSq = Square.valueOf(from.toUpperCase(java.util.Locale.ROOT));
+			for (Move move : board.legalMoves()) {
+				if (move.getFrom().equals(fromSq)) {
+					int fromRow = 8 - fromSq.getRank().ordinal() - 1;
+					int fromCol = fromSq.getFile().ordinal();
+					int toRow = 8 - move.getTo().getRank().ordinal() - 1;
+					int toCol = move.getTo().getFile().ordinal();
+					destinations.add(new MoveDTO(fromRow, fromCol, toRow, toCol));
+				}
+			}
+			if (logger.isLoggable(Level.INFO)) {
+				logger.info("Es wurden " + destinations.size() + " Ziele gefunden.");
+			}
+		} catch (Exception e) {
+			if (logger.isLoggable(Level.SEVERE)) {
+				logger.severe("Fehler beim Holen der legalen Ziele: " + e.getMessage());
+			}
+		}
+		return destinations;
+	}
 
-        PgnHolder pgnHolder = new PgnHolder(path);
-        try {
+	public List<String> getMoveListStringsGrouped() {
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("Gruppiere Züge für Anzeige.");
+		}
+		List<String> result = new ArrayList<>();
+		StringBuilder sb = new StringBuilder();
+		for (int i = 0; i < moves.size(); i++) {
+			if (i % 2 == 0) {
+				sb.append((i / 2 + 1)).append(". ");
+			}
+			sb.append(moves.get(i).toString()).append(" ");
+			if (i % 2 == 1 || i == moves.size() - 1) {
+				result.add(sb.toString().trim());
+				sb = new StringBuilder();
+			}
+		}
+		return result;
+	}
+
+	public void quicksave() {
+		this.quicksaveFen = board.getFen();
+		this.quicksaveMoves = new ArrayList<>(moves);
+		this.quicksaveMoveIndex = currentMoveIndex;
+		if (whiteTimer != null) {
+			quicksaveWhiteTimeLeft = whiteTimer.getSecondsLeft();
+		}
+		if (blackTimer != null) {
+			quicksaveBlackTimeLeft = blackTimer.getSecondsLeft();
+		}
+	}
+
+	public boolean quickload() {
+		if (quicksaveFen == null) {
+			return false;
+		}
+		board = new Board();
+		board.loadFromFen(quicksaveFen);
+		moves = new ArrayList<>(quicksaveMoves);
+		currentMoveIndex = quicksaveMoveIndex;
+		if (whiteTimer != null && quicksaveWhiteTimeLeft != -1) {
+			whiteTimer.setSecondsLeft(quicksaveWhiteTimeLeft);
+		}
+		if (blackTimer != null && quicksaveBlackTimeLeft != -1) {
+			blackTimer.setSecondsLeft(quicksaveBlackTimeLeft);
+		}
+		return true;
+	}
+
+	public void clearQuicksave() {
+		quicksaveFen = null;
+		quicksaveMoves = null;
+		quicksaveMoveIndex = 0;
+	}
+
+	public PieceDTO getPieceAt(String square) {
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("Hole Figur an Feld: " + square);
+		}
+		Piece piece = board.getPiece(Square.valueOf(square.toUpperCase(java.util.Locale.ROOT)));
+		return convertPieceToDTO(piece);
+	}
+
+	public boolean moveWithPromotion(MoveDTO move, String promotionPiece) {
+		String from = "" + (char) ('A' + move.getFromCol()) + (8 - move.getFromRow());
+		String to = "" + (char) ('A' + move.getToCol()) + (8 - move.getToRow());
+
+		boolean isWhite = (8 - move.getFromRow()) < (8 - move.getToRow());
+		Piece promotion;
+		switch (promotionPiece) {
+			case "ROOK":
+				promotion = isWhite ? Piece.WHITE_ROOK : Piece.BLACK_ROOK;
+				break;
+			case "KNIGHT":
+				promotion = isWhite ? Piece.WHITE_KNIGHT : Piece.BLACK_KNIGHT;
+				break;
+			case "BISHOP":
+				promotion = isWhite ? Piece.WHITE_BISHOP : Piece.BLACK_BISHOP;
+				break;
+			default:
+				promotion = isWhite ? Piece.WHITE_QUEEN : Piece.BLACK_QUEEN;
+				break;
+		}
+
+		Move libMove = new Move(Square.valueOf(from), Square.valueOf(to), promotion);
+
+		if (board.legalMoves().contains(libMove)) {
+			board.doMove(libMove);
+
+			if (currentMoveIndex < moves.size()) {
+				moves = new ArrayList<>(moves.subList(0, currentMoveIndex));
+			}
+			moves.add(libMove);
+			currentMoveIndex++;
+			if (logger.isLoggable(Level.INFO)) {
+				logger.info("Promotionszug durchgeführt: " + libMove);
+			}
+			return true;
+		}
+		if (logger.isLoggable(Level.WARNING)) {
+			logger.warning("Ungültiger Promotionszug: " + libMove);
+		}
+		return false;
+	}
+
+	public BoardDTO getBoardAsDTO() {
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("Erstelle DTO-Abbild des Boards");
+		}
+		PieceDTO[][] dtoBoard = new PieceDTO[8][8];
+		for (int rank = 8; rank >= 1; rank--) {
+			for (int file = 0; file < 8; file++) {
+				Square square = Square.valueOf("" + (char) ('A' + file) + rank);
+				Piece piece = board.getPiece(square);
+				dtoBoard[8 - rank][file] = convertPieceToDTO(piece);
+			}
+		}
+		return new BoardDTO(dtoBoard);
+	}
+
+	private String pieceToUnicode(Piece piece) {
+		switch (piece) {
+			case WHITE_KING:
+				return "♔";
+			case WHITE_QUEEN:
+				return "♕";
+			case WHITE_ROOK:
+				return "♖";
+			case WHITE_BISHOP:
+				return "♗";
+			case WHITE_KNIGHT:
+				return "♘";
+			case WHITE_PAWN:
+				return "♙";
+			case BLACK_KING:
+				return "♚";
+			case BLACK_QUEEN:
+				return "♛";
+			case BLACK_ROOK:
+				return "♜";
+			case BLACK_BISHOP:
+				return "♝";
+			case BLACK_KNIGHT:
+				return "♞";
+			case BLACK_PAWN:
+				return "♟";
+			default:
+				return " ";
+		}
+	}
+
+	public void setPositionToMoveIndex(int idx) {
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("Setze Board auf Zug-Index: " + idx);
+		}
+		board = new Board();
+		board.loadFromFen(initialFen);
+		for (int i = 0; i < idx; i++) {
+			board.doMove(moves.get(i));
+		}
+		currentMoveIndex = idx;
+
+		String playedMovesUci = movesToUciString(moves.subList(0, idx));
+		detectedOpening = Opening.detect(playedMovesUci);
+	}
+
+	public int getCurrentMoveIndex() {
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("Hole aktuellen Zug-Index: " + currentMoveIndex);
+		}
+		return currentMoveIndex;
+	}
+
+	public int getMoveListSize() {
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("Hole Anzahl gespielter Züge: " + moves.size());
+		}
+		return moves.size();
+	}
+
+	private PieceDTO convertPieceToDTO(Piece piece) {
+		if (piece == null || piece.equals(Piece.NONE)) {
+			return null;
+		}
+		String color = piece.name().startsWith("WHITE") ? "WHITE" : "BLACK";
+		String type = piece.name().substring(piece.name().indexOf('_') + 1);
+		String symbol = pieceToUnicode(piece);
+		return new PieceDTO(type, color, symbol);
+	}
+
+	public void setPositionFromFEN(String fen) {
+		board.loadFromFen(fen);
+		initialFen = fen;
+	}
+
+	public boolean isMated() {
+		boolean mated = board.isMated();
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("isMated() = " + mated);
+		}
+		return mated;
+	}
+
+	public boolean isStalemate() {
+		boolean stale = board.isStaleMate();
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("isStalemate() = " + stale);
+		}
+		return stale;
+	}
+
+	public boolean isDraw() {
+		boolean draw = board.isDraw();
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("isDraw() = " + draw);
+		}
+		return draw;
+	}
+
+	public String getCurrentPlayer() {
+		String player = board.getSideToMove().toString();
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("Am Zug: " + player);
+		}
+		return player;
+	}
+
+	public void logging() {
+		ConsoleHandler handler = new ConsoleHandler();
+		handler.setLevel(Level.ALL);
+		handler.setFormatter(new SimpleFormatter() {
+			@Override
+			public synchronized String format(LogRecord lr) {
+				return String.format("[%s] %s%n%n", lr.getLevel().getLocalizedName(), lr.getMessage());
+			}
+		});
+		logger.setUseParentHandlers(false);
+		logger.addHandler(handler);
+
+		if (logger.isLoggable(Level.INFO)) {
+			logger.info("ChessEngine wurde initialisiert.");
+		}
+	}
+
+	public List<Game> loadGamesFromPgn(String path) throws IOException {
+		PgnHolder pgnHolder = new PgnHolder(path);
+		try {
 			pgnHolder.loadPgn();
 		} catch (Exception e) {
 			e.printStackTrace();
-		} 
-        List<Game> games = pgnHolder.getGames();
-        return games;
-    }
-    
-    public void initTimers(int min, int sec) {
-        whiteTimer = new Timer(min, sec);
-        blackTimer = new Timer(min, sec);
-    }
-    
-    public void saveAsPgn(Game game, String path, String dateiname) {
-        // Sicher alle Strings holen (nie null)
-        String event = safe(game.getRound().getEvent().getName());
-        String site = safe(game.getRound().getEvent().getSite());
-        String round = "" + game.getRound().getNumber();
-        // Datum für PGN-Format (YYYY.MM.DD)
-        String date = safe(game.getRound().getEvent().getStartDate()).replace("-", ".");
-        String wName = safe(game.getWhitePlayer().getName());
-        String bName = safe(game.getBlackPlayer().getName());
-        String result = safe(game.getResult().getDescription());
+		}
+		return pgnHolder.getGames();
+	}
 
-        // PGN-Header zusammenbauen
-        StringBuilder header = new StringBuilder();
-        header.append("[Event \"" + event + "\"]\n");
-        header.append("[Site \"" + site + "\"]\n");
-        header.append("[Date \"" + date + "\"]\n");
-        header.append("[Round \"" + round + "\"]\n");
-        header.append("[White \"" + wName + "\"]\n");
-        header.append("[Black \"" + bName + "\"]\n");
-        header.append("[Result \"" + result + "\"]\n\n");
+	public void initTimers(int min, int sec) {
+		if (whiteTimer == null) {
+			whiteTimer = new Timer(min, sec);
+		} else if (quicksaveWhiteTimeLeft != -1) {
+			whiteTimer = new Timer(min, sec);
+			whiteTimer.setSecondsLeft(quicksaveWhiteTimeLeft);
+		} else {
+			whiteTimer = new Timer(min, sec);
+		}
 
-        // Züge als SAN holen
-        StringBuilder moves = new StringBuilder();
-        String[] sanArray = game.getHalfMoves().toSanArray();
+		if (blackTimer == null) {
+			blackTimer = new Timer(min, sec);
+		} else if (quicksaveBlackTimeLeft != -1) {
+			blackTimer = new Timer(min, sec);
+			blackTimer.setSecondsLeft(quicksaveBlackTimeLeft);
+		} else {
+			blackTimer = new Timer(min, sec);
+		}
+	}
 
-        for (int i = 0; i < sanArray.length; i++) {
-            if (i % 2 == 0) {
-                moves.append((i / 2 + 1)).append(". ");
-            }
-            moves.append(sanArray[i]).append(" ");
-            // Optional: Zeilenumbruch für Lesbarkeit
-            // if (i > 0 && i % 8 == 0) moves.append("\n");
-        }
-        moves.append(result); // Ergebnis am Ende!
+	public void saveAsPgn(Game game, String path, String dateiname) {
+		String event = safe(game.getRound().getEvent().getName());
+		String site = safe(game.getRound().getEvent().getSite());
+		String round = "" + game.getRound().getNumber();
+		String date = safe(game.getRound().getEvent().getStartDate()).replace("-", ".");
+		String wName = safe(game.getWhitePlayer().getName());
+		String bName = safe(game.getBlackPlayer().getName());
+		String result = safe(game.getResult().getDescription());
 
-        String file = header + moves.toString();
+		StringBuilder header = new StringBuilder();
+		header.append("[Event \"" + event + "\"]\n");
+		header.append("[Site \"" + site + "\"]\n");
+		header.append("[Date \"" + date + "\"]\n");
+		header.append("[Round \"" + round + "\"]\n");
+		header.append("[White \"" + wName + "\"]\n");
+		header.append("[Black \"" + bName + "\"]\n");
+		header.append("[Result \"" + result + "\"]\n\n");
 
-        // Datei schreiben
-        try {
-            Files.writeString(Path.of(path, dateiname), file, StandardCharsets.UTF_8);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
+		StringBuilder movesSb = new StringBuilder();
+		String[] sanArray = game.getHalfMoves().toSanArray();
 
-    // Hilfsfunktion für Null-Sicherheit
-    private String safe(String s) {
-        return s == null ? "?" : s;
-    }
+		for (int i = 0; i < sanArray.length; i++) {
+			if (i % 2 == 0) {
+				movesSb.append((i / 2 + 1)).append(". ");
+			}
+			movesSb.append(sanArray[i]).append(" ");
+		}
+		movesSb.append(result);
 
-    public Game getCurrentGame() {
-        return getCurrentGame(this.board, this.moves, this.currentMoveIndex);
-    }
-    
-    public Game getCurrentGame(Board board, java.util.List<Move> moves, int currentMoveIndex) {
-        // Event und Turnierdaten setzen
-        Event event = new Event();
-        event.setName("Generated Game");
-        event.setSite("Local");
-        event.setStartDate(LocalDate.now().toString()); // Format: yyyy-MM-dd
+		String file = header + movesSb.toString();
 
-        // Runde anlegen
-        Round round = new Round(event);
-        round.setNumber(1);
+		try {
+			Files.writeString(Path.of(path, dateiname), file, StandardCharsets.UTF_8);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
 
-        // Spiel initialisieren
-        Game game = new Game("1", round); // "1" ist die Game-ID
+	private String safe(String s) {
+		return s == null ? "?" : s;
+	}
 
-        // Spieler setzen (deine MyPlayer-Klasse)
-        game.setWhitePlayer(new MyPlayer("White"));
-        game.setBlackPlayer(new MyPlayer("Black"));
+	public Game getCurrentGame() {
+		return getCurrentGame(this.board, this.moves, this.currentMoveIndex);
+	}
 
-        // Ergebnis setzen
-        if (board.isMated()) {
-            game.setResult(board.getSideToMove() == Side.WHITE ? GameResult.BLACK_WON : GameResult.WHITE_WON);
-        } else if (board.isStaleMate() || board.isDraw()) {
-            game.setResult(GameResult.DRAW);
-        } else {
-            game.setResult(GameResult.ONGOING);
-        }
+	public Game getCurrentGame(Board board, List<Move> moves, int currentMoveIndex) {
+		Event event = new Event();
+		event.setName("Generated Game");
+		event.setSite("Local");
+		event.setStartDate(LocalDate.now().toString());
 
-        // Züge übernehmen
-        MoveList moveList = new MoveList();
-        for (Move move : moves) {
-            moveList.add(move);
-        }
-        game.setHalfMoves(moveList);
+		Round round = new Round(event);
+		round.setNumber(1);
 
-        // Position auf aktuellen Zug setzen (letzter gespielter Halbzug)
-        if (currentMoveIndex > 0 && currentMoveIndex <= moveList.size()) {
-            game.setPosition(currentMoveIndex - 1);
-        } else {
-            game.setPosition(moveList.size() - 1);
-        }
+		Game game = new Game("1", round);
 
-        // FEN setzen: JETZT das aktuelle Board-FEN verwenden!
-        game.setBoard(new Board());
-        game.getBoard().loadFromFen(board.getFen());
+		game.setWhitePlayer(new MyPlayer("White"));
+		game.setBlackPlayer(new MyPlayer("Black"));
 
-        return game;
-    }
+		if (board.isMated()) {
+			game.setResult(board.getSideToMove() == Side.WHITE ? GameResult.BLACK_WON : GameResult.WHITE_WON);
+		} else if (board.isStaleMate() || board.isDraw()) {
+			game.setResult(GameResult.DRAW);
+		} else {
+			game.setResult(GameResult.ONGOING);
+		}
 
+		MoveList moveList = new MoveList();
+		for (Move move : moves) {
+			moveList.add(move);
+		}
+		game.setHalfMoves(moveList);
 
-    public void undoLastMove() {
-        if (currentMoveIndex > 0 && moves.size() > 0) {
-            board.undoMove(); // 1. Brett zurücksetzen
-            moves.remove(currentMoveIndex - 1); // 2. Zug aus Move-Liste löschen
-            currentMoveIndex--;                 // 3. Index anpassen
+		if (currentMoveIndex > 0 && currentMoveIndex <= moveList.size()) {
+			game.setPosition(currentMoveIndex - 1);
+		} else {
+			game.setPosition(moveList.size() - 1);
+		}
 
-            // 4. Erkennung Opening neu machen!
-            String playedMovesUci = movesToUciString(moves.subList(0, currentMoveIndex));
-            detectedOpening = Opening.detect(playedMovesUci);
-        }
-    }
-    
-    
-    public void loadMoves(List<Move> moveList) {
-        board = new Board();  // Neues leeres Brett
-        moves.clear();
-        currentMoveIndex = 0;
+		game.setBoard(new Board());
+		game.getBoard().loadFromFen(board.getFen());
 
-        for (Move move : moveList) {
-            board.doMove(move);
-            moves.add(move);
-            currentMoveIndex++;
-        }
+		return game;
+	}
 
-    }
-    
-    public Timer getWhiteTimer() { return whiteTimer; }
-    public Timer getBlackTimer() { return blackTimer; }
-    
+	public void undoLastMove() {
+		if (currentMoveIndex > 0 && !moves.isEmpty()) {
+			board.undoMove();
+			moves.remove(currentMoveIndex - 1);
+			currentMoveIndex--;
+
+			String playedMovesUci = movesToUciString(moves.subList(0, currentMoveIndex));
+			detectedOpening = Opening.detect(playedMovesUci);
+		}
+	}
+
+	public void loadMoves(List<Move> moveList) {
+		board = new Board();
+		moves.clear();
+		currentMoveIndex = 0;
+
+		for (Move move : moveList) {
+			board.doMove(move);
+			moves.add(move);
+			currentMoveIndex++;
+		}
+	}
+
+	public Timer getWhiteTimer() {
+		return whiteTimer;
+	}
+
+	public Timer getBlackTimer() {
+		return blackTimer;
+	}
+
+	public GameMode getGameMode() {
+		return mode;
+	}
 }

schach/src/main/java/de/hs_mannheim/informatik/chess/model/GameMode.java

@@ -0,0 +1,26 @@
+package de.hs_mannheim.informatik.chess.model;
+
+public enum GameMode {
+    CLASSIC(3, 0, 0),
+    RAPID(5, 0, 0),
+    BULLET(1, 0, 10); // 1 Minute + 10 Sek Inkrement
+
+    public final int minutes;
+    public final int seconds;
+    public final int incrementSeconds;
+
+    GameMode(int minutes, int seconds, int incrementSeconds) {
+        this.minutes = minutes;
+        this.seconds = seconds;
+        this.incrementSeconds = incrementSeconds;
+    }
+
+    @Override
+    public String toString() {
+        return switch (this) {
+            case CLASSIC -> "3 Minuten (klassisch)";
+            case RAPID -> "5 Minuten (rapid)";
+            case BULLET -> "1 Minute + 10 Sek Inkrement";
+        };
+    }
+}

schach/src/main/java/de/hs_mannheim/informatik/chess/model/Timer.java

@@ -56,6 +56,13 @@ public class Timer {
     public int getSecondsLeft() {
         return secondsLeft;
     }
+    
+    public void setSecondsLeft(int secondsLeft) {
+        this.secondsLeft = secondsLeft;
+    }
+    public void addSeconds(int seconds) {
+        this.secondsLeft += seconds;
+    }
 }
 
 

schach/src/main/java/de/hs_mannheim/informatik/chess/view/CreativeGui.java

@@ -19,6 +19,8 @@ public class CreativeGui {
     private JButton updateBtn;
     private JButton flipBoardButton;
     
+    private boolean closedByUser = true;
+    
     private StartGameCallback startGameCallback;
     
     private JButton startGameButton;
@@ -64,7 +66,16 @@ public class CreativeGui {
         gbc.insets = new Insets(5, 0, 5, 5);
         gbc.fill = GridBagConstraints.BOTH;
         mainPanel.add(fenPanel(), gbc);
-
+        
+        frame.addWindowListener(new java.awt.event.WindowAdapter() {
+            @Override
+            public void windowClosed(java.awt.event.WindowEvent e) {
+                if (closedByUser) {
+                    new de.hs_mannheim.informatik.chess.controller.MainController();
+                }
+            }
+        });
+        
         frame.setContentPane(mainPanel);
         frame.setVisible(true);
     }
@@ -207,6 +218,7 @@ public class CreativeGui {
 
         startGameButton.addActionListener(e -> {
             if (startGameCallback != null) {
+                setClosedByUser(false);  
                 startGameCallback.onStartGame(getFenText());
             }
         });
@@ -222,6 +234,9 @@ public class CreativeGui {
     public JButton getUpdateButton() { return updateBtn; }
     public void setSelectedPiece(String piece) { selectedPiece = piece; }
     public String getSelectedPiece() { return selectedPiece; }
+    public void setClosedByUser(boolean b) {
+        this.closedByUser = b;
+    }
     
     public JButton getStartGameButton() { return startGameButton; }
     
@@ -232,4 +247,8 @@ public class CreativeGui {
     public boolean isFlipped() { return isFlipped; }
     public void setFlipped(boolean f) { isFlipped = f; }
     public JButton getFlipBoardButton() { return flipBoardButton; }
+    
+    public void close() {
+        frame.dispose();
+    }
 }

schach/src/main/java/de/hs_mannheim/informatik/chess/view/GameGui.java

@@ -26,6 +26,7 @@ import de.hs_mannheim.informatik.chess.model.BoardDTO;
 import de.hs_mannheim.informatik.chess.model.PieceDTO;
 
 public class GameGui {
+	JFrame frame;
 	
 	private JLabel[][] fields = new JLabel[8][8];
 	private JButton flipBoardButton;
@@ -43,7 +44,6 @@ public class GameGui {
     
     private JButton resignButton; 
     private JButton drawButton;   
-    private JButton quickSaveButton;
     private JButton undoButton;
     
     Color LIGHT = new Color(0xe0e1dd);
@@ -59,13 +59,14 @@ public class GameGui {
 	
 	
 	public JFrame mainFrame() {
-		JFrame frame = new JFrame();
+		frame = new JFrame();
 		frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
 		frame.setUndecorated(false);
 		frame.setLocationRelativeTo(null);
 		frame.add(mainPanel());
+	
 		
-		frame.setDefaultCloseOperation(2);
+		frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
 		frame.setVisible(true);
 		return frame;
 	}
@@ -254,8 +255,8 @@ public class GameGui {
 	    JPanel panel = new JPanel(new GridLayout(2, 1));
 	    panel.setBackground(new Color(0x0d1b2a));
 
-	    whiteTimerLabel = new JLabel("Weiß: 03:00", SwingConstants.CENTER);
-	    blackTimerLabel = new JLabel("Schwarz: 03:00", SwingConstants.CENTER);
+	    whiteTimerLabel = new JLabel("Weiß: --:--", SwingConstants.CENTER);
+	    blackTimerLabel = new JLabel("Schwarz: --:--", SwingConstants.CENTER);
 
 	    whiteTimerLabel.setFont(new Font("SansSerif", Font.BOLD, 24));
 	    whiteTimerLabel.setForeground(Color.WHITE);
@@ -378,4 +379,8 @@ public class GameGui {
         JOptionPane.showMessageDialog(null, msg);
     }
 	
+	public JFrame getFrame() {
+	    return frame;
+	}
+	
 }

schach/src/main/java/de/hs_mannheim/informatik/chess/view/GameModeSelector.java

@@ -0,0 +1,23 @@
+package de.hs_mannheim.informatik.chess.view;
+
+import javax.swing.*;
+
+import de.hs_mannheim.informatik.chess.model.GameMode;
+
+public class GameModeSelector {
+
+    public static GameMode selectGameMode() {
+        GameMode[] options = GameMode.values();
+        GameMode selected = (GameMode) JOptionPane.showInputDialog(
+            null,
+            "Wähle den Spielmodus:",
+            "Spielmodus auswählen",
+            JOptionPane.QUESTION_MESSAGE,
+            null,
+            options,
+            GameMode.CLASSIC
+        );
+
+        return selected != null ? selected : GameMode.CLASSIC;
+    }
+}

schach/src/main/java/de/hs_mannheim/informatik/chess/view/PgnGui.java

@@ -58,6 +58,12 @@ public class PgnGui {
 		
 		frame.setDefaultCloseOperation(2);
 		frame.setVisible(true);
+		frame.addWindowListener(new java.awt.event.WindowAdapter() {
+            @Override
+            public void windowClosed(java.awt.event.WindowEvent e) {
+                new de.hs_mannheim.informatik.chess.controller.MainController();
+            }
+        });
 		return frame;
 	}
 	

schach/target/classes/META-INF/maven/de.hs-mannheim.informatik.schach/schach/pom.xml

@@ -1,102 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<project xmlns="http://maven.apache.org/POM/4.0.0" 
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-
-  <groupId>de.hs-mannheim.informatik.schach</groupId>
-  <artifactId>schach</artifactId>
-  <version>0.0.1-SNAPSHOT</version>
-
-  <name>schach</name>
-  <description>A simple schach.</description>
-  <url>http://www.example.com</url>
-
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <maven.compiler.source>21</maven.compiler.source>
-    <maven.compiler.target>21</maven.compiler.target>
-  </properties>
-
-  <repositories>
-    <repository>
-      <id>jitpack.io</id>
-      <url>https://jitpack.io</url>
-    </repository>
-  </repositories>
-
-  <dependencies>
-    <!-- Schachlib (bhlangonijr) -->
-    <dependency>
-      <groupId>com.github.bhlangonijr</groupId>
-      <artifactId>chesslib</artifactId>
-      <version>1.3.4</version>
-    </dependency>
-   <dependency>
-    <groupId>org.junit.jupiter</groupId>
-    <artifactId>junit-jupiter</artifactId>
-    <version>5.10.2</version>
-    <scope>test</scope>
-</dependency>
-    <!-- Mockito damit man Controller und Gui besser testen kann-->
-    <dependency>
-    	<groupId>org.mockito</groupId>
-    	<artifactId>mockito-core</artifactId>
-    	<version>5.11.0</version>
-    	<scope>test</scope>
-	</dependency>
-
-  </dependencies>
-
-  <build>
-    <pluginManagement>
-      <plugins>
-        <plugin>
-          <artifactId>maven-clean-plugin</artifactId>
-          <version>3.4.0</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-site-plugin</artifactId>
-          <version>3.12.1</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-project-info-reports-plugin</artifactId>
-          <version>3.6.1</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-resources-plugin</artifactId>
-          <version>3.3.1</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-compiler-plugin</artifactId>
-          <version>3.13.0</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-surefire-plugin</artifactId>
-          <version>3.3.0</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-jar-plugin</artifactId>
-          <version>3.4.2</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-install-plugin</artifactId>
-          <version>3.1.2</version>
-        </plugin>
-        <plugin>
-          <artifactId>maven-deploy-plugin</artifactId>
-          <version>3.1.2</version>
-        </plugin>
-      </plugins>
-    </pluginManagement> 
-  </build>
-
-  <reporting>
-    <plugins>
-      <plugin>
-        <artifactId>maven-project-info-reports-plugin</artifactId>
-      </plugin>
-    </plugins>
-  </reporting>
-</project>