refactor(core): enhance MoveType to support capture flag and update related logic

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

@@ -85,7 +85,7 @@ object DefaultRules extends RuleSet:
         case Some(next) =>
           board.pieceAt(next) match
             case None => loop(next, Move(from, next) :: acc)
-            case Some(p) if p.color != color => Move(from, next) :: acc
+            case Some(p) if p.color != color => Move(from, next, MoveType.Normal(isCapture = true)) :: acc
             case Some(_) => acc
     loop(from, Nil).reverse
 
@@ -100,7 +100,8 @@ object DefaultRules extends RuleSet:
       from.offset(df, dr).flatMap { to =>
         context.board.pieceAt(to) match
           case Some(p) if p.color == color => None
-          case _ => Some(Move(from, to))
+          case Some(_) => Some(Move(from, to, MoveType.Normal(isCapture = true)))
+          case None    => Some(Move(from, to))
       }
     }
 
@@ -115,7 +116,8 @@ object DefaultRules extends RuleSet:
       from.offset(df, dr).flatMap { to =>
         context.board.pieceAt(to) match
           case Some(p) if p.color == color => None
-          case _ => Some(Move(from, to))
+          case Some(_) => Some(Move(from, to, MoveType.Normal(isCapture = true)))
+          case None    => Some(Move(from, to))
       }
     }
     steps ++ castlingCandidates(context, from, color)
@@ -220,17 +222,17 @@ object DefaultRules extends RuleSet:
       }
     }
 
-    def toMoves(dest: Square): List[Move] =
+    def toMoves(dest: Square, isCapture: Boolean): List[Move] =
       if dest.rank.ordinal == promoRank then
         List(
           PromotionPiece.Queen, PromotionPiece.Rook,
           PromotionPiece.Bishop, PromotionPiece.Knight
         ).map(pt => Move(from, dest, MoveType.Promotion(pt)))
-      else List(Move(from, dest))
+      else List(Move(from, dest, MoveType.Normal(isCapture = isCapture)))
 
     val stepSquares = single.toList ++ double.toList
-    val stepMoves = stepSquares.flatMap(toMoves)
-    val captureMoves = diagonalCaptures.flatMap(toMoves)
+    val stepMoves = stepSquares.flatMap(dest => toMoves(dest, isCapture = false))
+    val captureMoves = diagonalCaptures.flatMap(dest => toMoves(dest, isCapture = true))
     stepMoves ++ captureMoves ++ epCaptures
 
   // ── Check detection ────────────────────────────────────────────────
@@ -287,11 +289,14 @@ object DefaultRules extends RuleSet:
       case MoveType.CastleQueenside => applyCastle(board, color, kingside = false)
       case MoveType.EnPassant       => applyEnPassant(board, move, color)
       case MoveType.Promotion(pp)   => applyPromotion(board, move, color, pp)
-      case MoveType.Normal          => board.applyMove(move)
+      case MoveType.Normal(_)       => board.applyMove(move)
 
     val newCastlingRights = updateCastlingRights(context.castlingRights, board, move, color)
     val newEnPassantSquare = computeEnPassantSquare(board, move, color)
-    val isCapture = board.pieceAt(move.to).isDefined || move.moveType == MoveType.EnPassant
+    val isCapture = move.moveType match
+      case MoveType.Normal(capture) => capture
+      case MoveType.EnPassant       => true
+      case _                        => board.pieceAt(move.to).isDefined
     val isPawnMove = board.pieceAt(move.from).exists(_.pieceType == PieceType.Pawn)
     val newClock = if isPawnMove || isCapture then 0 else context.halfMoveClock + 1