refactor(core): optimize castling move logic and enhance move notation methods

modules/core/src/main/scala/de/nowchess/chess/engine/GameEngine.scala

@@ -241,32 +241,41 @@ class GameEngine(
     move.moveType match
       case MoveType.CastleKingside  => "O-O"
       case MoveType.CastleQueenside => "O-O-O"
-      case MoveType.EnPassant =>
+      case MoveType.EnPassant   => enPassantNotation(move)
-        s"${move.from.file.toString.toLowerCase}x${move.to}"
+      case MoveType.Promotion(pp) => promotionNotation(move, pp)
-      case MoveType.Promotion(pp) =>
+      case MoveType.Normal(isCapture) => normalMoveNotation(move, boardBefore, isCapture)
-        val ppChar = pp match
+
-          case PromotionPiece.Queen  => "Q"
+  private def enPassantNotation(move: Move): String =
-          case PromotionPiece.Rook   => "R"
+    s"${move.from.file.toString.toLowerCase}x${move.to}"
-          case PromotionPiece.Bishop => "B"
+
-          case PromotionPiece.Knight => "N"
+  private def promotionNotation(move: Move, piece: PromotionPiece): String =
-        s"${move.to}=$ppChar"
+    val ppChar = piece match
-      case MoveType.Normal(isCapture) =>
+      case PromotionPiece.Queen  => "Q"
-        boardBefore.pieceAt(move.from).map(_.pieceType) match
+      case PromotionPiece.Rook   => "R"
-          case Some(PieceType.Pawn) =>
+      case PromotionPiece.Bishop => "B"
-            if isCapture then s"${move.from.file.toString.toLowerCase}x${move.to}"
+      case PromotionPiece.Knight => "N"
-            else move.to.toString
+    s"${move.to}=$ppChar"
-          case Some(pt) =>
+
-            val letter = pt match
+  private def normalMoveNotation(move: Move, boardBefore: Board, isCapture: Boolean): String =
-              case PieceType.Knight => "N"
+    boardBefore.pieceAt(move.from).map(_.pieceType) match
-              case PieceType.Bishop => "B"
+      case Some(PieceType.Pawn) =>
-              case PieceType.Rook   => "R"
+        if isCapture then s"${move.from.file.toString.toLowerCase}x${move.to}"
-              case PieceType.Queen  => "Q"
+        else move.to.toString
-              case PieceType.King   => "K"
+      case Some(pt) =>
-              case _                => ""
+        val letter = pieceNotation(pt)
-            if isCapture then s"${letter}x${move.to}" else s"$letter${move.to}"
+        if isCapture then s"${letter}x${move.to}" else s"$letter${move.to}"
-          // $COVERAGE-OFF$ unreachable: executeMove is only called after a piece existence check
+      // $COVERAGE-OFF$ unreachable: executeMove is only called after a piece existence check
-          case None => move.to.toString
+      case None => move.to.toString
-          // $COVERAGE-ON$
+      // $COVERAGE-ON$
+
+  private def pieceNotation(pieceType: PieceType): String =
+    pieceType match
+      case PieceType.Knight => "N"
+      case PieceType.Bishop => "B"
+      case PieceType.Rook   => "R"
+      case PieceType.Queen  => "Q"
+      case PieceType.King   => "K"
+      case _                => ""
 
   private def computeCaptured(context: GameContext, move: Move): Option[Piece] =
     move.moveType match

modules/rule/src/main/scala/de/nowchess/rules/sets/DefaultRules.scala

@@ -139,9 +139,9 @@ object DefaultRules extends RuleSet:
     else
       val moves = scala.collection.mutable.ListBuffer[Move]()
       addCastleMove(context, moves, context.castlingRights.whiteKingSide,
-        "e1", "g1", "f1", "h1", MoveType.CastleKingside)
+        "e1", "g1", "f1", MoveType.CastleKingside)
       addCastleMove(context, moves, context.castlingRights.whiteQueenSide,
-        "e1", "c1", "d1", "a1", MoveType.CastleQueenside)
+        "e1", "c1", "d1", MoveType.CastleQueenside)
       moves.toList
 
   private def blackCastles(context: GameContext, from: Square): List[Move] =
@@ -150,9 +150,9 @@ object DefaultRules extends RuleSet:
     else
       val moves = scala.collection.mutable.ListBuffer[Move]()
       addCastleMove(context, moves, context.castlingRights.blackKingSide,
-        "e8", "g8", "f8", "h8", MoveType.CastleKingside)
+        "e8", "g8", "f8", MoveType.CastleKingside)
       addCastleMove(context, moves, context.castlingRights.blackQueenSide,
-        "e8", "c8", "d8", "a8", MoveType.CastleQueenside)
+        "e8", "c8", "d8", MoveType.CastleQueenside)
       moves.toList
 
   private def addCastleMove(
@@ -162,7 +162,6 @@ object DefaultRules extends RuleSet:
     kingFromAlg: String,
     kingToAlg: String,
     middleAlg: String,
-    rookAlg: String,
     moveType: MoveType
   ): Unit =
     if castlingRight then