Merge remote-tracking branch 'origin/Main' into PMD-Korrektur

schach/pom.xml

@@ -33,7 +33,6 @@
       <version>1.3.4</version>
     </dependency>
 
-    <!-- JUnit 5 -->
     <dependency>
 	    <groupId>org.junit.jupiter</groupId>
 	    <artifactId>junit-jupiter</artifactId>
@@ -51,6 +50,47 @@
  </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>
     <plugins>
       <!-- Java Compiler Plugin -->
       <plugin>

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

@@ -1,11 +1,10 @@
 package de.hs_mannheim.informatik.chess.model;
-import java.io.BufferedReader;
+
-import java.io.FileReader;
 import java.io.IOException;
-import java.io.PrintWriter;
 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;
@@ -21,10 +20,8 @@ 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<>();
@@ -32,17 +29,13 @@ public class ChessEngine {
 	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() {
@@ -58,6 +51,7 @@ public class 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());
@@ -65,26 +59,29 @@ public class ChessEngine {
 		if (board.legalMoves().contains(libMove)) {
 			board.doMove(libMove);
 
-            // Replay? Dann abschneiden
 			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);
+			}
 
-            // Opening-Erkennung nach jedem erfolgreichen Zug
 			String playedMovesUci = movesToUciString(moves);
 			detectedOpening = Opening.detect(playedMovesUci);
 
-            if (detectedOpening != null) {
+			if (detectedOpening != null && logger.isLoggable(Level.INFO)) {
 				logger.info("Aktuelles Opening erkannt: " + detectedOpening.getEco() + " - " + detectedOpening.getName());
-                // Optional: Speichere das Opening in ein Feld, falls benötigt
 			}
 			return true;
 		}
+		if (logger.isLoggable(Level.WARNING)) {
 			logger.warning("Ungültiger Zug: " + libMove);
+		}
 		return false;
 	}
 
@@ -105,10 +102,12 @@ public class ChessEngine {
 	}
 
 	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());
+			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;
@@ -118,19 +117,27 @@ public class ChessEngine {
 					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;
 	}
 
 	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) + ". ");
+			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());
@@ -144,17 +151,28 @@ public class ChessEngine {
 		this.quicksaveFen = board.getFen();
 		this.quicksaveMoves = new ArrayList<>(moves);
 		this.quicksaveMoveIndex = currentMoveIndex;
-        if (whiteTimer != null) quicksaveWhiteTimeLeft = whiteTimer.getSecondsLeft();
+		if (whiteTimer != null) {
-        if (blackTimer != null) quicksaveBlackTimeLeft = blackTimer.getSecondsLeft();
+			quicksaveWhiteTimeLeft = whiteTimer.getSecondsLeft();
 		}
+		if (blackTimer != null) {
+			quicksaveBlackTimeLeft = blackTimer.getSecondsLeft();
+		}
+	}
+
 	public boolean quickload() {
-        if (quicksaveFen == null) return false;
+		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 (whiteTimer != null && quicksaveWhiteTimeLeft != -1) {
-        if (blackTimer != null && quicksaveBlackTimeLeft != -1) blackTimer.setSecondsLeft(quicksaveBlackTimeLeft);
+			whiteTimer.setSecondsLeft(quicksaveWhiteTimeLeft);
+		}
+		if (blackTimer != null && quicksaveBlackTimeLeft != -1) {
+			blackTimer.setSecondsLeft(quicksaveBlackTimeLeft);
+		}
 		return true;
 	}
 
@@ -164,10 +182,11 @@ public class ChessEngine {
 		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()));
+		}
+		Piece piece = board.getPiece(Square.valueOf(square.toUpperCase(java.util.Locale.ROOT)));
 		return convertPieceToDTO(piece);
 	}
 
@@ -175,14 +194,21 @@ public class ChessEngine {
 		String from = "" + (char) ('A' + move.getFromCol()) + (8 - move.getFromRow());
 		String to = "" + (char) ('A' + move.getToCol()) + (8 - move.getToRow());
 
-        // 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 "ROOK":
-            case "KNIGHT": promotion = isWhite ? Piece.WHITE_KNIGHT : Piece.BLACK_KNIGHT; break;
+				promotion = isWhite ? Piece.WHITE_ROOK : Piece.BLACK_ROOK;
-            case "BISHOP": promotion = isWhite ? Piece.WHITE_BISHOP : Piece.BLACK_BISHOP; break;
+				break;
-            default:       promotion = isWhite ? Piece.WHITE_QUEEN  : Piece.BLACK_QUEEN;
+			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);
@@ -195,15 +221,21 @@ public class ChessEngine {
 			}
 			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++) {
@@ -217,26 +249,41 @@ public class ChessEngine {
 
 	private String pieceToUnicode(Piece piece) {
 		switch (piece) {
-            case WHITE_KING: return "♔";
+			case WHITE_KING:
-            case WHITE_QUEEN: return "♕";
+				return "♔";
-            case WHITE_ROOK: return "♖";
+			case WHITE_QUEEN:
-            case WHITE_BISHOP: return "♗";
+				return "♕";
-            case WHITE_KNIGHT: return "♘";
+			case WHITE_ROOK:
-            case WHITE_PAWN: return "♙";
+				return "♖";
-            case BLACK_KING: return "♚";
+			case WHITE_BISHOP:
-            case BLACK_QUEEN: return "♛";
+				return "♗";
-            case BLACK_ROOK: return "♜";
+			case WHITE_KNIGHT:
-            case BLACK_BISHOP: return "♝";
+				return "♘";
-            case BLACK_KNIGHT: return "♞";
+			case WHITE_PAWN:
-            case BLACK_PAWN: return "♟";
+				return "♙";
-            default: 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); // Statt new Board() -> initialFen!
+		board.loadFromFen(initialFen);
 		for (int i = 0; i < idx; i++) {
 			board.doMove(moves.get(i));
 		}
@@ -245,20 +292,27 @@ public class ChessEngine {
 		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;
+		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 type = piece.name().substring(piece.name().indexOf('_') + 1);
 		String symbol = pieceToUnicode(piece);
 		return new PieceDTO(type, color, symbol);
 	}
@@ -268,34 +322,39 @@ public class ChessEngine {
 		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() {
-    	
-    	// Eigener Handler nur für diese Klasse
 		ConsoleHandler handler = new ConsoleHandler();
 		handler.setLevel(Level.ALL);
 		handler.setFormatter(new SimpleFormatter() {
@@ -307,19 +366,19 @@ public class ChessEngine {
 		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 pgnHolder.getGames();
-        return games;
 	}
 
 	public void initTimers(int min, int sec) {
@@ -343,17 +402,14 @@ public class ChessEngine {
 	}
 
 	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());
 
-        // PGN-Header zusammenbauen
 		StringBuilder header = new StringBuilder();
 		header.append("[Event \"" + event + "\"]\n");
 		header.append("[Site \"" + site + "\"]\n");
@@ -363,23 +419,19 @@ public class ChessEngine {
 		header.append("[Black \"" + bName + "\"]\n");
 		header.append("[Result \"" + result + "\"]\n\n");
 
-        // Züge als SAN holen
+		StringBuilder movesSb = new StringBuilder();
-        StringBuilder moves = new StringBuilder();
 		String[] sanArray = game.getHalfMoves().toSanArray();
 
 		for (int i = 0; i < sanArray.length; i++) {
 			if (i % 2 == 0) {
-                moves.append((i / 2 + 1)).append(". ");
+				movesSb.append((i / 2 + 1)).append(". ");
 			}
-            moves.append(sanArray[i]).append(" ");
+			movesSb.append(sanArray[i]).append(" ");
-            // Optional: Zeilenumbruch für Lesbarkeit
-            // if (i > 0 && i % 8 == 0) moves.append("\n");
 		}
-        moves.append(result); // Ergebnis am Ende!
+		movesSb.append(result);
 
-        String file = header + moves.toString();
+		String file = header + movesSb.toString();
 
-        // Datei schreiben
 		try {
 			Files.writeString(Path.of(path, dateiname), file, StandardCharsets.UTF_8);
 		} catch (IOException e) {
@@ -387,7 +439,6 @@ public class ChessEngine {
 		}
 	}
 
-    // Hilfsfunktion für Null-Sicherheit
 	private String safe(String s) {
 		return s == null ? "?" : s;
 	}
@@ -396,25 +447,20 @@ public class ChessEngine {
 		return getCurrentGame(this.board, this.moves, this.currentMoveIndex);
 	}
 
-    public Game getCurrentGame(Board board, java.util.List<Move> moves, int currentMoveIndex) {
+	public Game getCurrentGame(Board board, 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
+		event.setStartDate(LocalDate.now().toString());
 
-        // Runde anlegen
 		Round round = new Round(event);
 		round.setNumber(1);
 
-        // Spiel initialisieren
+		Game game = new Game("1", round);
-        Game game = new Game("1", round); // "1" ist die Game-ID
 
-        // Spieler setzen (deine MyPlayer-Klasse)
 		game.setWhitePlayer(new MyPlayer("White"));
 		game.setBlackPlayer(new MyPlayer("Black"));
 
-        // Ergebnis setzen
 		if (board.isMated()) {
 			game.setResult(board.getSideToMove() == Side.WHITE ? GameResult.BLACK_WON : GameResult.WHITE_WON);
 		} else if (board.isStaleMate() || board.isDraw()) {
@@ -423,43 +469,37 @@ public class ChessEngine {
 			game.setResult(GameResult.ONGOING);
 		}
 
-        // Züge übernehmen
 		MoveList moveList = new MoveList();
 		for (Move move : moves) {
 			moveList.add(move);
 		}
 		game.setHalfMoves(moveList);
 
-        // Position auf aktuellen Zug setzen (letzter gespielter Halbzug)
 		if (currentMoveIndex > 0 && currentMoveIndex <= moveList.size()) {
 			game.setPosition(currentMoveIndex - 1);
 		} else {
 			game.setPosition(moveList.size() - 1);
 		}
 
-        // FEN setzen: JETZT das aktuelle Board-FEN verwenden!
 		game.setBoard(new Board());
 		game.getBoard().loadFromFen(board.getFen());
 
 		return game;
 	}
 
-
 	public void undoLastMove() {
-        if (currentMoveIndex > 0 && moves.size() > 0) {
+		if (currentMoveIndex > 0 && !moves.isEmpty()) {
-            board.undoMove(); // 1. Brett zurücksetzen
+			board.undoMove();
-            moves.remove(currentMoveIndex - 1); // 2. Zug aus Move-Liste löschen
+			moves.remove(currentMoveIndex - 1);
-            currentMoveIndex--;                 // 3. Index anpassen
+			currentMoveIndex--;
 
-            // 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
+		board = new Board();
 		moves.clear();
 		currentMoveIndex = 0;
 
@@ -468,21 +508,17 @@ public class ChessEngine {
 			moves.add(move);
 			currentMoveIndex++;
 		}
-
 	}
 
-    public Timer getWhiteTimer() { return whiteTimer; }
+	public Timer getWhiteTimer() {
-
+		return whiteTimer;
-    public Timer getBlackTimer() { return blackTimer; }
+	}
 
+	public Timer getBlackTimer() {
+		return blackTimer;
+	}
 
 	public GameMode getGameMode() {
-		// TODO Auto-generated method stub
 		return mode;
 	}
-
-    
 }
-
-
-