test: add tests for undo and redo notifications in GameEngine

fix: improve TerminalUI coverage and make MoveCommand/ResetCommand immutable
**TerminalUI Coverage Fix:** - Added explicit test for empty input case (lines 64-65 previously uncovered) - Test "TerminalUI should explicitly handle empty input by re-prompting" validates that multiple empty inputs are properly handled by re-prompting - UI module coverage improved to near-100% **MoveCommand Immutability (Anti-pattern Fix):** - Changed MoveCommand fields from var to val: moveResult, previousBoard, previousHistory, previousTurn - Changed ResetCommand fields from var to val: previousBoard, previousHistory, previousTurn - Updated GameEngine to use .copy() instead of direct mutation when updating command state (lines 88, 95, 103, 112) - Removed 3 edge-case tests that relied on command mutation (now impossible with immutable fields) **MoveCommand Immutability Tests:** - Added MoveCommandImmutabilityTest to verify: - Fields cannot be mutated after creation - equals/hashCode respect immutability invariant - .copy() creates new instances with updated values All tests pass; 100% core coverage maintained. Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
2026-03-31 09:34:39 +02:00 · 2026-03-31 08:43:44 +02:00 · 2026-03-31 08:32:15 +02:00 · 2026-03-30 22:38:13 +02:00 · 2026-03-30 22:32:57 +02:00 · 2026-03-30 21:48:04 +02:00
29 changed files with 131 additions and 1310 deletions
@@ -2,10 +2,9 @@
 name: scala-implementer
 description: "Implements Scala 3 + Quarkus REST services, domain logic, and persistence"
 tools: Read, Write, Edit, Bash, Glob
-model: inherit
+model: sonnet
 color: pink
 ---
 You do not have permissions to write tests, just source code.
 You are a Scala 3 expert specialising in Quarkus microservices.
 Always read the relevant /docs/api/ file before implementing.
@@ -2,10 +2,9 @@
 name: test-writer
 description: "Writes QuarkusTest unit and integration tests for a service. Invoke after scala-implementer has finished."
 tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, NotebookEdit
-model: haiku
+model: sonnet
 color: purple
 ---
 You do not have permissions to modify the source code, just write tests.
 You write tests for Scala 3 + Quarkus services.
@@ -20,4 +19,5 @@ When invoked BEFORE scala-implementer (no implementation exists yet):
 When invoked AFTER scala-implementer (implementation exists):
  Run python3 jacoco-reporter/jacoco_coverage_gaps.py modules/{service-name}/build/reports/jacoco/test/jacocoTestReport.xml --output agent
  Use the jacoco-coverage-gaps skill — close coverage gaps revealed by the report.
  To regenerate the report run the tests first.
@@ -1,6 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="AndroidProjectSystem">
    <option name="providerId" value="com.android.tools.idea.GradleProjectSystem" />
  </component>
 </project>
@@ -1,3 +1,4 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="ExternalStorageConfigurationManager" enabled="true" />
  <component name="FrameworkDetectionExcludesConfiguration">
@@ -6,16 +6,6 @@
      <inspection_tool class="CommitNamingConvention" enabled="true" level="WARNING" enabled_by_default="true" />
    </profile>
  </component>
  <component name="IssueNavigationConfiguration">
    <option name="links">
      <list>
        <IssueNavigationLink>
          <option name="issueRegexp" value="(?x)\b(CORE|NCWF|BAC|FRO|K8S|ORG|NCI|NCS)-\d+\b#YouTrack" />
          <option name="linkRegexp" value="https://knockoutwhist.youtrack.cloud/issue/$0" />
        </IssueNavigationLink>
      </list>
    </option>
  </component>
  <component name="VcsDirectoryMappings">
    <mapping directory="" vcs="Git" />
  </component>
@@ -1,20 +0,0 @@
 ## [2026-03-31] Unreachable code blocking 100% statement coverage
 **Requirement/Bug:** Reach 100% statement coverage in core module.
 **Root Cause:** 4 remaining uncovered statements (99.6% coverage) are unreachable code:
 1. **PgnParser.scala:160** (`case _ => None` in extractPromotion) - Regex `=([QRBN])` only matches those 4 characters; fallback case can never execute
 2. **GameHistory.scala:29** (`addMove$default$4` compiler-generated method) - Method overload 3 without defaults shadows the 4-param version, making promotionPiece default accessor unreachable
 3. **GameEngine.scala:201-202** (`case _` in completePromotion) - GameController.completePromotion always returns one of 4 expected MoveResult types; catch-all is defensive code
 **Attempted Fixes:**
 1. Added comprehensive PGN parsing tests (all 4 promotion types) - PgnParser improved from 95.8% to 99.4%
 2. Added GameHistory tests using named parameters - hit `addMove$default$3` (castleSide) but not `$default$4` (promotionPiece)
 3. Named parameter approach: `addMove(from=..., to=..., promotionPiece=...)` triggers 4-param with castleSide default ✓
 4. Positional approach: `addMove(f, t, None, None)` requires all 4 args (explicit, no defaults used) - doesn't hit $default$4
 5. Root issue: Scala's overload resolution prefers more-specific non-default overloads (2-param, 3-param) over the 4-param with defaults
 **Recommendation:** 99.6% (1029/1033) is maximum achievable without refactoring method overloads. Unreachable code design patterns:
 - **Pattern 1 (unreachable regex fallback):** Defensive pattern match against exhaustive regex
 - **Pattern 2 (overshadowed defaults):** Method overloads shadow default parameters in parent signature
 - **Pattern 3 (defensive catch-all):** Error handling for impossible external API returns
@@ -1,6 +1,3 @@
 ##  (2026-03-27)
 ##  (2026-03-28)
 ##  (2026-03-28)
 ##  (2026-03-29)
 ##  (2026-03-31)
 ##  (2026-04-01)
@@ -1,3 +1,3 @@
 MAJOR=0
 MINOR=0
-PATCH=6
+PATCH=3
@@ -44,58 +44,3 @@
 * add missing kings to gameLoop capture test board ([aedd787](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/aedd787b77203c2af934751dba7b784eaf165032))
 * correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
 * update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))
 ##  (2026-03-29)
 ### Features
 * add GameRules stub with PositionStatus enum ([76d4168](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/76d4168038de23e5d6083d4e8f0504fbf31d15a3))
 * add MovedInCheck/Checkmate/Stalemate MoveResult variants (stub dispatch) ([8b7ec57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8b7ec57e5ea6ee1615a1883848a426dc07d26364))
 * implement GameRules with isInCheck, legalMoves, gameStatus ([94a02ff](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/94a02ff6849436d9496c70a0f16c21666dae8e4e))
 * implement legal castling ([#1](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/1)) ([00d326c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/00d326c1ba67711fbe180f04e1100c3f01dd0254))
 * NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
 * NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
 * wire check/checkmate/stalemate into processMove and gameLoop ([5264a22](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5264a225418b885c5e6ea6411b96f85e38837f6c))
 ### Bug Fixes
 * add missing kings to gameLoop capture test board ([aedd787](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/aedd787b77203c2af934751dba7b784eaf165032))
 * correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
 * update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))
 ##  (2026-03-31)
 ### Features
 * add GameRules stub with PositionStatus enum ([76d4168](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/76d4168038de23e5d6083d4e8f0504fbf31d15a3))
 * add MovedInCheck/Checkmate/Stalemate MoveResult variants (stub dispatch) ([8b7ec57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8b7ec57e5ea6ee1615a1883848a426dc07d26364))
 * implement GameRules with isInCheck, legalMoves, gameStatus ([94a02ff](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/94a02ff6849436d9496c70a0f16c21666dae8e4e))
 * implement legal castling ([#1](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/1)) ([00d326c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/00d326c1ba67711fbe180f04e1100c3f01dd0254))
 * NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
 * NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
 * NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
 * wire check/checkmate/stalemate into processMove and gameLoop ([5264a22](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5264a225418b885c5e6ea6411b96f85e38837f6c))
 ### Bug Fixes
 * add missing kings to gameLoop capture test board ([aedd787](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/aedd787b77203c2af934751dba7b784eaf165032))
 * correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
 * update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))
 ##  (2026-04-01)
 ### Features
 * add GameRules stub with PositionStatus enum ([76d4168](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/76d4168038de23e5d6083d4e8f0504fbf31d15a3))
 * add MovedInCheck/Checkmate/Stalemate MoveResult variants (stub dispatch) ([8b7ec57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8b7ec57e5ea6ee1615a1883848a426dc07d26364))
 * implement GameRules with isInCheck, legalMoves, gameStatus ([94a02ff](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/94a02ff6849436d9496c70a0f16c21666dae8e4e))
 * implement legal castling ([#1](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/1)) ([00d326c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/00d326c1ba67711fbe180f04e1100c3f01dd0254))
 * NCS-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
 * NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
 * NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
 * NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
 * wire check/checkmate/stalemate into processMove and gameLoop ([5264a22](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5264a225418b885c5e6ea6411b96f85e38837f6c))
 ### Bug Fixes
 * add missing kings to gameLoop capture test board ([aedd787](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/aedd787b77203c2af934751dba7b784eaf165032))
 * correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
 * update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))
 * update move validation to check for king safety ([#13](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/13)) ([e5e20c5](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e5e20c566e368b12ca1dc59680c34e9112bf6762))
@@ -1,7 +1,6 @@
 package de.nowchess.chess.controller
-import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
+import de.nowchess.api.board.{Board, Color, File, Piece, Rank, Square}
 import de.nowchess.api.move.PromotionPiece
 import de.nowchess.chess.logic.*
 // ---------------------------------------------------------------------------
@@ -15,14 +14,6 @@ object MoveResult:
  case object NoPiece                                                                   extends MoveResult
  case object WrongColor                                                                extends MoveResult
  case object IllegalMove                                                               extends MoveResult
  case class  PromotionRequired(
    from: Square,
    to: Square,
    boardBefore: Board,
    historyBefore: GameHistory,
    captured: Option[Piece],
    turn: Color
  ) extends MoveResult
  case class  Moved(newBoard: Board, newHistory: GameHistory, captured: Option[Piece], newTurn: Color)      extends MoveResult
  case class  MovedInCheck(newBoard: Board, newHistory: GameHistory, captured: Option[Piece], newTurn: Color) extends MoveResult
  case class  Checkmate(winner: Color)                                                  extends MoveResult
@@ -39,67 +30,37 @@ object GameController:
   */
  def processMove(board: Board, history: GameHistory, turn: Color, raw: String): MoveResult =
    raw.trim match
-      case "quit" | "q" => MoveResult.Quit
+      case "quit" | "q" =>
        MoveResult.Quit
      case trimmed =>
        Parser.parseMove(trimmed) match
-          case None              => MoveResult.InvalidFormat(trimmed)
+          case None =>
-          case Some((from, to))  => validateAndApply(board, history, turn, from, to)
+            MoveResult.InvalidFormat(trimmed)
-
+          case Some((from, to)) =>
-  /** Apply a previously detected promotion move with the chosen piece.
+            board.pieceAt(from) match
-   *  Called after processMove returned PromotionRequired.
+              case None =>
-   */
+                MoveResult.NoPiece
-  def completePromotion(
+              case Some(piece) if piece.color != turn =>
-    board: Board,
+                MoveResult.WrongColor
-    history: GameHistory,
+              case Some(_) =>
-    from: Square,
+                if !MoveValidator.isLegal(board, history, from, to) then
-    to: Square,
+                  MoveResult.IllegalMove
-    piece: PromotionPiece,
+                else
-    turn: Color
+                  val castleOpt = if MoveValidator.isCastle(board, from, to)
-  ): MoveResult =
+                                  then Some(MoveValidator.castleSide(from, to))
-    val (boardAfterMove, captured) = board.withMove(from, to)
+                                  else None
-    val promotedPieceType = piece match
+                  val isEP = EnPassantCalculator.isEnPassant(board, history, from, to)
-      case PromotionPiece.Queen  => PieceType.Queen
+                  val (newBoard, captured) = castleOpt match
-      case PromotionPiece.Rook   => PieceType.Rook
+                    case Some(side) => (board.withCastle(turn, side), None)
-      case PromotionPiece.Bishop => PieceType.Bishop
+                    case None =>
-      case PromotionPiece.Knight => PieceType.Knight
+                      val (b, cap) = board.withMove(from, to)
-    val newBoard    = boardAfterMove.updated(to, Piece(turn, promotedPieceType))
+                      if isEP then
-    // Promotion is always a pawn move → clock resets
+                        val capturedSq = EnPassantCalculator.capturedPawnSquare(to, turn)
-    val newHistory = history.addMove(from, to, None, Some(piece), wasPawnMove = true)
+                        (b.removed(capturedSq), board.pieceAt(capturedSq))
-    toMoveResult(newBoard, newHistory, captured, turn)
+                      else (b, cap)
-
+                  val newHistory = history.addMove(from, to, castleOpt)
-  // ---------------------------------------------------------------------------
+                  GameRules.gameStatus(newBoard, newHistory, turn.opposite) match
-  // Private helpers
+                    case PositionStatus.Normal  => MoveResult.Moved(newBoard, newHistory, captured, turn.opposite)
-  // ---------------------------------------------------------------------------
+                    case PositionStatus.InCheck => MoveResult.MovedInCheck(newBoard, newHistory, captured, turn.opposite)
-
+                    case PositionStatus.Mated   => MoveResult.Checkmate(turn)
-  private def validateAndApply(board: Board, history: GameHistory, turn: Color, from: Square, to: Square): MoveResult =
+                    case PositionStatus.Drawn   => MoveResult.Stalemate
    board.pieceAt(from) match
      case None                              => MoveResult.NoPiece
      case Some(piece) if piece.color != turn => MoveResult.WrongColor
      case Some(_) =>
        if !GameRules.legalMoves(board, history, turn).contains(from -> to) then MoveResult.IllegalMove
        else if MoveValidator.isPromotionMove(board, from, to) then
          MoveResult.PromotionRequired(from, to, board, history, board.pieceAt(to), turn)
        else applyNormalMove(board, history, turn, from, to)
  private def applyNormalMove(board: Board, history: GameHistory, turn: Color, from: Square, to: Square): MoveResult =
    val castleOpt              = Option.when(MoveValidator.isCastle(board, from, to))(MoveValidator.castleSide(from, to))
    val isEP                   = EnPassantCalculator.isEnPassant(board, history, from, to)
    val (newBoard, captured)   = castleOpt match
      case Some(side) => (board.withCastle(turn, side), None)
      case None =>
        val (b, cap) = board.withMove(from, to)
        if isEP then
          val capturedSq = EnPassantCalculator.capturedPawnSquare(to, turn)
          (b.removed(capturedSq), board.pieceAt(capturedSq))
        else (b, cap)
    val wasPawnMove = board.pieceAt(from).exists(_.pieceType == PieceType.Pawn)
    val wasCapture  = captured.isDefined
    val newHistory  = history.addMove(from, to, castleOpt, wasPawnMove = wasPawnMove, wasCapture = wasCapture)
    toMoveResult(newBoard, newHistory, captured, turn)
  private def toMoveResult(newBoard: Board, newHistory: GameHistory, captured: Option[Piece], turn: Color): MoveResult =
    GameRules.gameStatus(newBoard, newHistory, turn.opposite) match
      case PositionStatus.Normal  => MoveResult.Moved(newBoard, newHistory, captured, turn.opposite)
      case PositionStatus.InCheck => MoveResult.MovedInCheck(newBoard, newHistory, captured, turn.opposite)
      case PositionStatus.Mated   => MoveResult.Checkmate(turn)
      case PositionStatus.Drawn   => MoveResult.Stalemate
@@ -1,7 +1,6 @@
 package de.nowchess.chess.engine
 import de.nowchess.api.board.{Board, Color, Piece, Square}
 import de.nowchess.api.move.PromotionPiece
 import de.nowchess.chess.logic.{GameHistory, GameRules, PositionStatus}
 import de.nowchess.chess.controller.{GameController, Parser, MoveResult}
 import de.nowchess.chess.observer.*
@@ -12,31 +11,12 @@ import de.nowchess.chess.command.{CommandInvoker, MoveCommand}
 *  All user interactions must go through this engine via Commands, and all state changes
 *  are communicated to observers via GameEvent notifications.
 */
-class GameEngine(
+class GameEngine extends Observable:
-  initialBoard: Board = Board.initial,
+  private var currentBoard: Board = Board.initial
-  initialHistory: GameHistory = GameHistory.empty,
+  private var currentHistory: GameHistory = GameHistory.empty
-  initialTurn: Color = Color.White,
+  private var currentTurn: Color = Color.White
  completePromotionFn: (Board, GameHistory, Square, Square, PromotionPiece, Color) => MoveResult =
    GameController.completePromotion
 ) extends Observable:
  private var currentBoard: Board = initialBoard
  private var currentHistory: GameHistory = initialHistory
  private var currentTurn: Color = initialTurn
  private val invoker = new CommandInvoker()
  /** Inner class for tracking pending promotion state */
  private case class PendingPromotion(
    from: Square, to: Square,
    boardBefore: Board, historyBefore: GameHistory,
    turn: Color
  )
  /** Current pending promotion, if any */
  private var pendingPromotion: Option[PendingPromotion] = None
  /** True if a pawn promotion move is pending and needs a piece choice. */
  def isPendingPromotion: Boolean = synchronized { pendingPromotion.isDefined }
  // Synchronized accessors for current state
  def board: Board = synchronized { currentBoard }
  def history: GameHistory = synchronized { currentHistory }
@@ -67,19 +47,6 @@ class GameEngine(
      case "redo" =>
        performRedo()
      case "draw" =>
        if currentHistory.halfMoveClock >= 100 then
          currentBoard   = Board.initial
          currentHistory = GameHistory.empty
          currentTurn    = Color.White
          invoker.clear()
          notifyObservers(DrawClaimedEvent(currentBoard, currentHistory, currentTurn))
        else
          notifyObservers(InvalidMoveEvent(
            currentBoard, currentHistory, currentTurn,
            "Draw cannot be claimed: the 50-move rule has not been triggered."
          ))
      case "" =>
        val event = InvalidMoveEvent(
          currentBoard,
@@ -90,65 +57,66 @@ class GameEngine(
        notifyObservers(event)
      case moveInput =>
        // Try to parse as a move
        Parser.parseMove(moveInput) match
          case None =>
-            notifyObservers(InvalidMoveEvent(
+            val event = InvalidMoveEvent(
-              currentBoard, currentHistory, currentTurn,
+              currentBoard,
              currentHistory,
              currentTurn,
              s"Invalid move format '$moveInput'. Use coordinate notation, e.g. e2e4."
-            ))
+            )
            notifyObservers(event)
          case Some((from, to)) =>
-            handleParsedMove(from, to, moveInput)
+            // Create a move command with current state snapshot
            val cmd = MoveCommand(
              from = from,
              to = to,
              previousBoard = Some(currentBoard),
              previousHistory = Some(currentHistory),
              previousTurn = Some(currentTurn)
            )
            // Execute the move through GameController
            GameController.processMove(currentBoard, currentHistory, currentTurn, moveInput) match
              case MoveResult.InvalidFormat(_) | MoveResult.NoPiece | MoveResult.WrongColor | MoveResult.IllegalMove | MoveResult.Quit =>
                handleFailedMove(moveInput)
              case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
                // Move succeeded - store result and execute through invoker
                val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(newBoard, newHistory, newTurn, captured)))
                invoker.execute(updatedCmd)
                updateGameState(newBoard, newHistory, newTurn)
                emitMoveEvent(from.toString, to.toString, captured, newTurn)
              case MoveResult.MovedInCheck(newBoard, newHistory, captured, newTurn) =>
                // Move succeeded with check
                val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(newBoard, newHistory, newTurn, captured)))
                invoker.execute(updatedCmd)
                updateGameState(newBoard, newHistory, newTurn)
                emitMoveEvent(from.toString, to.toString, captured, newTurn)
                notifyObservers(CheckDetectedEvent(currentBoard, currentHistory, currentTurn))
              case MoveResult.Checkmate(winner) =>
                // Move resulted in checkmate
                val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)))
                invoker.execute(updatedCmd)
                currentBoard = Board.initial
                currentHistory = GameHistory.empty
                currentTurn = Color.White
                notifyObservers(CheckmateEvent(currentBoard, currentHistory, currentTurn, winner))
              case MoveResult.Stalemate =>
                // Move resulted in stalemate
                val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)))
                invoker.execute(updatedCmd)
                currentBoard = Board.initial
                currentHistory = GameHistory.empty
                currentTurn = Color.White
                notifyObservers(StalemateEvent(currentBoard, currentHistory, currentTurn))
  }
  private def handleParsedMove(from: Square, to: Square, moveInput: String): Unit =
    val cmd = MoveCommand(
      from = from,
      to = to,
      previousBoard = Some(currentBoard),
      previousHistory = Some(currentHistory),
      previousTurn = Some(currentTurn)
    )
    GameController.processMove(currentBoard, currentHistory, currentTurn, moveInput) match
      case MoveResult.InvalidFormat(_) | MoveResult.NoPiece | MoveResult.WrongColor | MoveResult.IllegalMove | MoveResult.Quit =>
        handleFailedMove(moveInput)
      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
        val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(newBoard, newHistory, newTurn, captured)))
        invoker.execute(updatedCmd)
        updateGameState(newBoard, newHistory, newTurn)
        emitMoveEvent(from.toString, to.toString, captured, newTurn)
        if currentHistory.halfMoveClock >= 100 then
          notifyObservers(FiftyMoveRuleAvailableEvent(currentBoard, currentHistory, currentTurn))
      case MoveResult.MovedInCheck(newBoard, newHistory, captured, newTurn) =>
        val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(newBoard, newHistory, newTurn, captured)))
        invoker.execute(updatedCmd)
        updateGameState(newBoard, newHistory, newTurn)
        emitMoveEvent(from.toString, to.toString, captured, newTurn)
        notifyObservers(CheckDetectedEvent(currentBoard, currentHistory, currentTurn))
        if currentHistory.halfMoveClock >= 100 then
          notifyObservers(FiftyMoveRuleAvailableEvent(currentBoard, currentHistory, currentTurn))
      case MoveResult.Checkmate(winner) =>
        val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)))
        invoker.execute(updatedCmd)
        currentBoard = Board.initial
        currentHistory = GameHistory.empty
        currentTurn = Color.White
        notifyObservers(CheckmateEvent(currentBoard, currentHistory, currentTurn, winner))
      case MoveResult.Stalemate =>
        val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)))
        invoker.execute(updatedCmd)
        currentBoard = Board.initial
        currentHistory = GameHistory.empty
        currentTurn = Color.White
        notifyObservers(StalemateEvent(currentBoard, currentHistory, currentTurn))
      case MoveResult.PromotionRequired(promFrom, promTo, boardBefore, histBefore, _, promotingTurn) =>
        pendingPromotion = Some(PendingPromotion(promFrom, promTo, boardBefore, histBefore, promotingTurn))
        notifyObservers(PromotionRequiredEvent(currentBoard, currentHistory, currentTurn, promFrom, promTo))
  /** Undo the last move. */
  def undo(): Unit = synchronized {
    performUndo()
@@ -159,59 +127,6 @@ class GameEngine(
    performRedo()
  }
  /** Apply a player's promotion piece choice.
   *  Must only be called when isPendingPromotion is true.
   */
  def completePromotion(piece: PromotionPiece): Unit = synchronized {
    pendingPromotion match
      case None =>
        notifyObservers(InvalidMoveEvent(currentBoard, currentHistory, currentTurn, "No promotion pending."))
      case Some(pending) =>
        pendingPromotion = None
        val cmd = MoveCommand(
          from = pending.from,
          to = pending.to,
          previousBoard = Some(pending.boardBefore),
          previousHistory = Some(pending.historyBefore),
          previousTurn = Some(pending.turn)
        )
        completePromotionFn(
          pending.boardBefore, pending.historyBefore,
          pending.from, pending.to, piece, pending.turn
        ) match
          case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
            val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(newBoard, newHistory, newTurn, captured)))
            invoker.execute(updatedCmd)
            updateGameState(newBoard, newHistory, newTurn)
            emitMoveEvent(pending.from.toString, pending.to.toString, captured, newTurn)
          case MoveResult.MovedInCheck(newBoard, newHistory, captured, newTurn) =>
            val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(newBoard, newHistory, newTurn, captured)))
            invoker.execute(updatedCmd)
            updateGameState(newBoard, newHistory, newTurn)
            emitMoveEvent(pending.from.toString, pending.to.toString, captured, newTurn)
            notifyObservers(CheckDetectedEvent(currentBoard, currentHistory, currentTurn))
          case MoveResult.Checkmate(winner) =>
            val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)))
            invoker.execute(updatedCmd)
            currentBoard = Board.initial
            currentHistory = GameHistory.empty
            currentTurn = Color.White
            notifyObservers(CheckmateEvent(currentBoard, currentHistory, currentTurn, winner))
          case MoveResult.Stalemate =>
            val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)))
            invoker.execute(updatedCmd)
            currentBoard = Board.initial
            currentHistory = GameHistory.empty
            currentTurn = Color.White
            notifyObservers(StalemateEvent(currentBoard, currentHistory, currentTurn))
          case _ =>
            notifyObservers(InvalidMoveEvent(currentBoard, currentHistory, currentTurn, "Error completing promotion."))
  }
  /** Reset the board to initial position. */
  def reset(): Unit = synchronized {
    currentBoard = Board.initial
@@ -1,46 +1,24 @@
 package de.nowchess.chess.logic
 import de.nowchess.api.board.Square
 import de.nowchess.api.move.PromotionPiece
 /** A single move recorded in the game history. Distinct from api.move.Move which represents user intent. */
 case class HistoryMove(
  from: Square,
  to: Square,
-  castleSide: Option[CastleSide],
+  castleSide: Option[CastleSide]
  promotionPiece: Option[PromotionPiece] = None
 )
-/** Complete game history: ordered list of moves plus the half-move clock for the 50-move rule.
+/** Complete game history: ordered list of moves. */
- *
+case class GameHistory(moves: List[HistoryMove] = List.empty):
 *  @param moves         moves played so far, oldest first
 *  @param halfMoveClock plies since the last pawn move or capture (FIDE 50-move rule counter)
 */
 case class GameHistory(moves: List[HistoryMove] = List.empty, halfMoveClock: Int = 0):
  /** Add a raw HistoryMove record. Clock increments by 1.
   *  Use the coordinate overload when you know whether the move is a pawn move or capture.
   */
  def addMove(move: HistoryMove): GameHistory =
-    GameHistory(moves :+ move, halfMoveClock + 1)
+    GameHistory(moves :+ move)
-  /** Add a move by coordinates.
+  def addMove(from: Square, to: Square): GameHistory =
-   *
+    addMove(HistoryMove(from, to, None))
-   *  @param wasPawnMove true when the moving piece is a pawn — resets the clock to 0
+
-   *  @param wasCapture  true when a piece was captured (including en passant) — resets the clock to 0
+  def addMove(from: Square, to: Square, castleSide: Option[CastleSide]): GameHistory =
-   *
+    addMove(HistoryMove(from, to, castleSide))
   *  If neither flag is set the clock increments by 1.
   */
  def addMove(
    from: Square,
    to: Square,
    castleSide: Option[CastleSide] = None,
    promotionPiece: Option[PromotionPiece] = None,
    wasPawnMove: Boolean = false,
    wasCapture: Boolean = false
  ): GameHistory =
    val newClock = if wasPawnMove || wasCapture then 0 else halfMoveClock + 1
    GameHistory(moves :+ HistoryMove(from, to, castleSide, promotionPiece), newClock)
 object GameHistory:
  val empty: GameHistory = GameHistory()
@@ -173,11 +173,3 @@ object MoveValidator:
  def isLegal(board: Board, history: GameHistory, from: Square, to: Square): Boolean =
    legalTargets(board, history, from).contains(to)
  /** Returns true if the piece on `from` is a pawn moving to its back rank (promotion). */
  def isPromotionMove(board: Board, from: Square, to: Square): Boolean =
    board.pieceAt(from) match
      case Some(Piece(_, PieceType.Pawn)) =>
        (from.rank == Rank.R7 && to.rank == Rank.R8) ||
        (from.rank == Rank.R2 && to.rank == Rank.R1)
      case _ => false
@@ -1,7 +1,6 @@
 package de.nowchess.chess.notation
 import de.nowchess.api.board.*
 import de.nowchess.api.move.PromotionPiece
 import de.nowchess.chess.logic.{CastleSide, GameHistory, HistoryMove}
 object PgnExporter:
@@ -22,8 +21,7 @@ object PgnExporter:
        if blackMoveStr.isEmpty then s"$moveNum. $whiteMoveStr"
        else s"$moveNum. $whiteMoveStr $blackMoveStr"
-      val termination = headers.getOrElse("Result", "*")
+      moveLines.mkString(" ") + " *"
      moveLines.mkString(" ") + s" $termination"
    if headerLines.isEmpty then moveText
    else if moveText.isEmpty then headerLines
@@ -34,11 +32,4 @@ object PgnExporter:
    move.castleSide match
      case Some(CastleSide.Kingside)  => "O-O"
      case Some(CastleSide.Queenside) => "O-O-O"
-      case None =>
+      case None => s"${move.from}${move.to}"
        val base = s"${move.from}${move.to}"
        move.promotionPiece match
          case Some(PromotionPiece.Queen)  => s"$base=Q"
          case Some(PromotionPiece.Rook)   => s"$base=R"
          case Some(PromotionPiece.Bishop) => s"$base=B"
          case Some(PromotionPiece.Knight) => s"$base=N"
          case None                        => base
@@ -1,7 +1,6 @@
 package de.nowchess.chess.notation
 import de.nowchess.api.board.*
 import de.nowchess.api.move.PromotionPiece
 import de.nowchess.chess.logic.{CastleSide, GameHistory, HistoryMove, GameRules, MoveValidator, withCastle}
 /** A parsed PGN game containing headers and the resolved move list. */
@@ -42,30 +41,16 @@ object PgnParser:
        if isMoveNumberOrResult(token) then state
        else
          parseAlgebraicMove(token, board, history, color) match
-            case None       => state  // unrecognised token — skip silently
+            case None => state  // unrecognised token — skip silently
            case Some(move) =>
-              val newBoard   = applyMoveToBoard(board, move, color)
+              val newBoard = move.castleSide match
                case Some(side) => board.withCastle(color, side)
                case None       => board.withMove(move.from, move.to)._1
              val newHistory = history.addMove(move)
              (newBoard, newHistory, color.opposite, acc :+ move)
    moves
  /** Apply a single HistoryMove to a Board, handling castling and promotion. */
  private def applyMoveToBoard(board: Board, move: HistoryMove, color: Color): Board =
    move.castleSide match
      case Some(side) => board.withCastle(color, side)
      case None =>
        val (boardAfterMove, _) = board.withMove(move.from, move.to)
        move.promotionPiece match
          case Some(pp) =>
            val pieceType = pp match
              case PromotionPiece.Queen  => PieceType.Queen
              case PromotionPiece.Rook   => PieceType.Rook
              case PromotionPiece.Bishop => PieceType.Bishop
              case PromotionPiece.Knight => PieceType.Knight
            boardAfterMove.updated(move.to, Piece(color, pieceType))
          case None => boardAfterMove
  /** True for move-number tokens ("1.", "12.") and PGN result tokens. */
  private def isMoveNumberOrResult(token: String): Boolean =
    token.matches("""\d+\.""") ||
@@ -143,26 +128,16 @@ object PgnParser:
          if hint.isEmpty then byPiece
          else byPiece.filter(from => matchesHint(from, hint))
-        val promotion = extractPromotion(notation)
+        disambiguated.headOption.map(from => HistoryMove(from, toSquare, None))
        disambiguated.headOption.map(from => HistoryMove(from, toSquare, None, promotion))
  /** True if `sq` matches a disambiguation hint (file letter, rank digit, or both). */
  private def matchesHint(sq: Square, hint: String): Boolean =
-    hint.forall(c => if c >= 'a' && c <= 'h' then sq.file.toString.equalsIgnoreCase(c.toString)
+    hint.foldLeft(true): (ok, c) =>
-    else if c >= '1' && c <= '8' then sq.rank.ordinal == (c - '1')
+      ok && (
-    else true)
+        if c >= 'a' && c <= 'h' then sq.file.toString.equalsIgnoreCase(c.toString)
-
+        else if c >= '1' && c <= '8' then sq.rank.ordinal == (c - '1')
-  /** Extract a promotion piece from a notation string containing =Q/=R/=B/=N. */
+        else true
-  private[notation] def extractPromotion(notation: String): Option[PromotionPiece] =
+      )
    val promotionPattern = """=([A-Z])""".r
    promotionPattern.findFirstMatchIn(notation).flatMap { m =>
      m.group(1) match
        case "Q" => Some(PromotionPiece.Queen)
        case "R" => Some(PromotionPiece.Rook)
        case "B" => Some(PromotionPiece.Bishop)
        case "N" => Some(PromotionPiece.Knight)
        case _   => None
    }
  /** Convert a piece-letter character to a PieceType. */
  private def charToPieceType(c: Char): Option[PieceType] =
@@ -1,6 +1,6 @@
 package de.nowchess.chess.observer
-import de.nowchess.api.board.{Board, Color, Square}
+import de.nowchess.api.board.{Board, Color}
 import de.nowchess.chess.logic.GameHistory
 /** Base trait for all game state events.
@@ -51,15 +51,6 @@ case class InvalidMoveEvent(
  reason: String
 ) extends GameEvent
 /** Fired when a pawn reaches the back rank and the player must choose a promotion piece. */
 case class PromotionRequiredEvent(
  board: Board,
  history: GameHistory,
  turn: Color,
  from: Square,
  to: Square
 ) extends GameEvent
 /** Fired when the board is reset. */
 case class BoardResetEvent(
  board: Board,
@@ -67,20 +58,6 @@ case class BoardResetEvent(
  turn: Color
 ) extends GameEvent
 /** Fired after any move where the half-move clock reaches 100 — the 50-move rule is now claimable. */
 case class FiftyMoveRuleAvailableEvent(
  board: Board,
  history: GameHistory,
  turn: Color
 ) extends GameEvent
 /** Fired when a player successfully claims a draw under the 50-move rule. */
 case class DrawClaimedEvent(
  board: Board,
  history: GameHistory,
  turn: Color
 ) extends GameEvent
 /** Observer trait: implement to receive game state updates. */
 trait Observer:
  def onGameEvent(event: GameEvent): Unit
@@ -2,9 +2,7 @@ package de.nowchess.chess.controller
 import de.nowchess.api.board.*
 import de.nowchess.api.game.CastlingRights
 import de.nowchess.api.move.PromotionPiece
 import de.nowchess.chess.logic.{CastleSide, GameHistory}
 import de.nowchess.chess.notation.FenParser
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
@@ -43,30 +41,6 @@ class GameControllerTest extends AnyFunSuite with Matchers:
    // White pawn at E2 cannot jump three squares to E5
    processMove(Board.initial, GameHistory.empty, Color.White, "e2e5") shouldBe MoveResult.IllegalMove
  test("processMove: move that leaves own king in check returns IllegalMove"):
    // White King E1 is in check from Black Rook E8. Moving the D2 pawn is
    // geometrically legal but does not resolve the check — must be rejected.
    val b = Board(Map(
      sq(File.E, Rank.R1) -> Piece.WhiteKing,
      sq(File.D, Rank.R2) -> Piece.WhitePawn,
      sq(File.E, Rank.R8) -> Piece.BlackRook,
      sq(File.A, Rank.R8) -> Piece.BlackKing
    ))
    processMove(b, GameHistory.empty, Color.White, "d2d4") shouldBe MoveResult.IllegalMove
  test("processMove: move that resolves check is allowed"):
    // White King E1 is in check from Black Rook E8 along the E-file.
    // White Rook A5 interposes at E5 — resolves the check, no new check on Black King A8.
    val b = Board(Map(
      sq(File.E, Rank.R1) -> Piece.WhiteKing,
      sq(File.A, Rank.R5) -> Piece.WhiteRook,
      sq(File.E, Rank.R8) -> Piece.BlackRook,
      sq(File.A, Rank.R8) -> Piece.BlackKing
    ))
    processMove(b, GameHistory.empty, Color.White, "a5e5") match
      case _: MoveResult.Moved => succeed
      case other => fail(s"Expected Moved, got $other")
  test("processMove: legal pawn move returns Moved with updated board and flipped turn"):
    processMove(Board.initial, GameHistory.empty, Color.White, "e2e4") match
      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
@@ -319,208 +293,3 @@ class GameControllerTest extends AnyFunSuite with Matchers:
        newBoard.pieceAt(Square(File.E, Rank.R3)) shouldBe Some(Piece.BlackPawn)  // capturing pawn placed
        captured shouldBe Some(Piece.WhitePawn)
      case other => fail(s"Expected Moved but got $other")
  // ──── pawn promotion detection ───────────────────────────────────────────
  test("processMove detects white pawn reaching R8 and returns PromotionRequired"):
    val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val result = GameController.processMove(board, GameHistory.empty, Color.White, "e7e8")
    result should matchPattern { case _: MoveResult.PromotionRequired => }
    result match
      case MoveResult.PromotionRequired(from, to, _, _, _, turn) =>
        from should be (sq(File.E, Rank.R7))
        to   should be (sq(File.E, Rank.R8))
        turn should be (Color.White)
      case _ => fail("Expected PromotionRequired")
  test("processMove detects black pawn reaching R1 and returns PromotionRequired"):
    val board = FenParser.parseBoard("8/8/8/8/4K3/8/4p3/8").get
    val result = GameController.processMove(board, GameHistory.empty, Color.Black, "e2e1")
    result should matchPattern { case _: MoveResult.PromotionRequired => }
    result match
      case MoveResult.PromotionRequired(from, to, _, _, _, turn) =>
        from should be (sq(File.E, Rank.R2))
        to   should be (sq(File.E, Rank.R1))
        turn should be (Color.Black)
      case _ => fail("Expected PromotionRequired")
  test("processMove detects pawn capturing to back rank as PromotionRequired with captured piece"):
    val board = FenParser.parseBoard("3q4/4P3/8/8/8/8/8/8").get
    val result = GameController.processMove(board, GameHistory.empty, Color.White, "e7d8")
    result should matchPattern { case _: MoveResult.PromotionRequired => }
    result match
      case MoveResult.PromotionRequired(_, _, _, _, captured, _) =>
        captured should be (Some(Piece(Color.Black, PieceType.Queen)))
      case _ => fail("Expected PromotionRequired")
  // ──── completePromotion ──────────────────────────────────────────────────
  test("completePromotion applies move and places queen"):
    // Black king on h1: not attacked by queen on e8 (different file, rank, and diagonals)
    val board = FenParser.parseBoard("8/4P3/8/8/8/8/8/7k").get
    val result = GameController.completePromotion(
      board, GameHistory.empty,
      sq(File.E, Rank.R7), sq(File.E, Rank.R8),
      PromotionPiece.Queen, Color.White
    )
    result should matchPattern { case _: MoveResult.Moved => }
    result match
      case MoveResult.Moved(newBoard, newHistory, _, _) =>
        newBoard.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
        newBoard.pieceAt(sq(File.E, Rank.R7)) should be (None)
        newHistory.moves should have length 1
        newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Queen))
      case _ => fail("Expected Moved")
  test("completePromotion with rook underpromotion"):
    // Black king on h1: not attacked by rook on e8 (different file and rank)
    val board = FenParser.parseBoard("8/4P3/8/8/8/8/8/7k").get
    val result = GameController.completePromotion(
      board, GameHistory.empty,
      sq(File.E, Rank.R7), sq(File.E, Rank.R8),
      PromotionPiece.Rook, Color.White
    )
    result match
      case MoveResult.Moved(newBoard, newHistory, _, _) =>
        newBoard.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Rook)))
        newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Rook))
      case _ => fail("Expected Moved with Rook")
  test("completePromotion with bishop underpromotion"):
    val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val result = GameController.completePromotion(
      board, GameHistory.empty,
      sq(File.E, Rank.R7), sq(File.E, Rank.R8),
      PromotionPiece.Bishop, Color.White
    )
    result match
      case MoveResult.Moved(newBoard, newHistory, _, _) =>
        newBoard.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Bishop)))
        newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Bishop))
      case _ => fail("Expected Moved with Bishop")
  test("completePromotion with knight underpromotion"):
    val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val result = GameController.completePromotion(
      board, GameHistory.empty,
      sq(File.E, Rank.R7), sq(File.E, Rank.R8),
      PromotionPiece.Knight, Color.White
    )
    result match
      case MoveResult.Moved(newBoard, newHistory, _, _) =>
        newBoard.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Knight)))
        newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Knight))
      case _ => fail("Expected Moved with Knight")
  test("completePromotion captures opponent piece"):
    // Black king on h1: after white queen captures d8 queen, h1 king is safe (queen on d8 does not attack h1)
    val board = FenParser.parseBoard("3q4/4P3/8/8/8/8/8/7k").get
    val result = GameController.completePromotion(
      board, GameHistory.empty,
      sq(File.E, Rank.R7), sq(File.D, Rank.R8),
      PromotionPiece.Queen, Color.White
    )
    result match
      case MoveResult.Moved(newBoard, _, captured, _) =>
        newBoard.pieceAt(sq(File.D, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
        captured should be (Some(Piece(Color.Black, PieceType.Queen)))
      case _ => fail("Expected Moved with captured piece")
  test("completePromotion for black pawn to R1"):
    val board = FenParser.parseBoard("8/8/8/8/4K3/8/4p3/8").get
    val result = GameController.completePromotion(
      board, GameHistory.empty,
      sq(File.E, Rank.R2), sq(File.E, Rank.R1),
      PromotionPiece.Knight, Color.Black
    )
    result match
      case MoveResult.Moved(newBoard, newHistory, _, _) =>
        newBoard.pieceAt(sq(File.E, Rank.R1)) should be (Some(Piece(Color.Black, PieceType.Knight)))
        newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Knight))
      case _ => fail("Expected Moved")
  test("completePromotion evaluates check after promotion"):
    val board = FenParser.parseBoard("3k4/4P3/8/8/8/8/8/8").get
    val result = GameController.completePromotion(
      board, GameHistory.empty,
      sq(File.E, Rank.R7), sq(File.E, Rank.R8),
      PromotionPiece.Queen, Color.White
    )
    result should matchPattern { case _: MoveResult.MovedInCheck => }
  test("completePromotion full round-trip via processMove then completePromotion"):
    // Black king on h1: not attacked by queen on e8
    val board = FenParser.parseBoard("8/4P3/8/8/8/8/8/7k").get
    GameController.processMove(board, GameHistory.empty, Color.White, "e7e8") match
      case MoveResult.PromotionRequired(from, to, boardBefore, histBefore, _, turn) =>
        val result = GameController.completePromotion(boardBefore, histBefore, from, to, PromotionPiece.Queen, turn)
        result should matchPattern { case _: MoveResult.Moved => }
        result match
          case MoveResult.Moved(finalBoard, finalHistory, _, _) =>
            finalBoard.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
            finalHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Queen))
          case _ => fail("Expected Moved")
      case _ => fail("Expected PromotionRequired")
  test("completePromotion results in checkmate when promotion delivers checkmate"):
    // Black king a8, white pawn h7, white king b6.
    // After h7→h8=Q: Qh8 attacks rank 8 putting Ka8 in check;
    // a7 covered by Kb6, b7 covered by Kb6, b8 covered by Qh8 — no escape.
    val board = FenParser.parseBoard("k7/7P/1K6/8/8/8/8/8").get
    val result = GameController.completePromotion(
      board, GameHistory.empty,
      sq(File.H, Rank.R7), sq(File.H, Rank.R8),
      PromotionPiece.Queen, Color.White
    )
    result should matchPattern { case MoveResult.Checkmate(_) => }
    result match
      case MoveResult.Checkmate(winner) => winner should be (Color.White)
      case _ => fail("Expected Checkmate")
  test("completePromotion results in stalemate when promotion stalemates opponent"):
    // Black king a8, white pawn b7, white bishop c7, white king b6.
    // After b7→b8=N: knight on b8 (doesn't check a8); a7 and b7 covered by Kb6;
    // b8 defended by Bc7 so Ka8xb8 would walk into bishop — no legal moves.
    val board = FenParser.parseBoard("k7/1PB5/1K6/8/8/8/8/8").get
    val result = GameController.completePromotion(
      board, GameHistory.empty,
      sq(File.B, Rank.R7), sq(File.B, Rank.R8),
      PromotionPiece.Knight, Color.White
    )
    result should be (MoveResult.Stalemate)
  // ──── half-move clock propagation ────────────────────────────────────
  test("processMove: non-pawn non-capture increments halfMoveClock"):
    // g1f3 is a knight move — not a pawn, not a capture
    processMove(Board.initial, GameHistory.empty, Color.White, "g1f3") match
      case MoveResult.Moved(_, newHistory, _, _) =>
        newHistory.halfMoveClock shouldBe 1
      case other => fail(s"Expected Moved, got $other")
  test("processMove: pawn move resets halfMoveClock to 0"):
    processMove(Board.initial, GameHistory.empty, Color.White, "e2e4") match
      case MoveResult.Moved(_, newHistory, _, _) =>
        newHistory.halfMoveClock shouldBe 0
      case other => fail(s"Expected Moved, got $other")
  test("processMove: capture resets halfMoveClock to 0"):
    // White pawn on e5, Black pawn on d6 — exd6 is a capture
    val board = Board(Map(
      sq(File.E, Rank.R5) -> Piece.WhitePawn,
      sq(File.D, Rank.R6) -> Piece.BlackPawn,
      sq(File.E, Rank.R1) -> Piece.WhiteKing,
      sq(File.E, Rank.R8) -> Piece.BlackKing
    ))
    val history = GameHistory(halfMoveClock = 10)
    processMove(board, history, Color.White, "e5d6") match
      case MoveResult.Moved(_, newHistory, _, _) =>
        newHistory.halfMoveClock shouldBe 0
      case other => fail(s"Expected Moved, got $other")
  test("processMove: clock carries from previous history on non-pawn non-capture"):
    val history = GameHistory(halfMoveClock = 5)
    processMove(Board.initial, history, Color.White, "g1f3") match
      case MoveResult.Moved(_, newHistory, _, _) =>
        newHistory.halfMoveClock shouldBe 6
      case other => fail(s"Expected Moved, got $other")
@@ -1,167 +0,0 @@
 package de.nowchess.chess.engine
 import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
 import de.nowchess.api.move.PromotionPiece
 import de.nowchess.chess.logic.GameHistory
 import de.nowchess.chess.notation.FenParser
 import de.nowchess.chess.observer.*
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 class GameEnginePromotionTest extends AnyFunSuite with Matchers:
  private def sq(f: File, r: Rank): Square = Square(f, r)
  private def captureEvents(engine: GameEngine): collection.mutable.ListBuffer[GameEvent] =
    val events = collection.mutable.ListBuffer[GameEvent]()
    engine.subscribe(new Observer { def onGameEvent(e: GameEvent): Unit = events += e })
    events
  test("processUserInput fires PromotionRequiredEvent when pawn reaches back rank") {
    val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val engine = new GameEngine(initialBoard = promotionBoard)
    val events = captureEvents(engine)
    engine.processUserInput("e7e8")
    events.exists(_.isInstanceOf[PromotionRequiredEvent]) should be (true)
    events.collect { case e: PromotionRequiredEvent => e }.head.from should be (sq(File.E, Rank.R7))
  }
  test("isPendingPromotion is true after PromotionRequired input") {
    val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val engine = new GameEngine(initialBoard = promotionBoard)
    captureEvents(engine)
    engine.processUserInput("e7e8")
    engine.isPendingPromotion should be (true)
  }
  test("isPendingPromotion is false before any promotion input") {
    val engine = new GameEngine()
    engine.isPendingPromotion should be (false)
  }
  test("completePromotion fires MoveExecutedEvent with promoted piece") {
    val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val engine = new GameEngine(initialBoard = promotionBoard)
    val events = captureEvents(engine)
    engine.processUserInput("e7e8")
    engine.completePromotion(PromotionPiece.Queen)
    engine.isPendingPromotion should be (false)
    engine.board.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
    engine.board.pieceAt(sq(File.E, Rank.R7)) should be (None)
    engine.history.moves.head.promotionPiece should be (Some(PromotionPiece.Queen))
    events.exists(_.isInstanceOf[MoveExecutedEvent]) should be (true)
  }
  test("completePromotion with rook underpromotion") {
    val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val engine = new GameEngine(initialBoard = promotionBoard)
    captureEvents(engine)
    engine.processUserInput("e7e8")
    engine.completePromotion(PromotionPiece.Rook)
    engine.board.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Rook)))
  }
  test("completePromotion with no pending promotion fires InvalidMoveEvent") {
    val engine = new GameEngine()
    val events = captureEvents(engine)
    engine.completePromotion(PromotionPiece.Queen)
    events.exists(_.isInstanceOf[InvalidMoveEvent]) should be (true)
    engine.isPendingPromotion should be (false)
  }
  test("completePromotion fires CheckDetectedEvent when promotion gives check") {
    val promotionBoard = FenParser.parseBoard("3k4/4P3/8/8/8/8/8/8").get
    val engine = new GameEngine(initialBoard = promotionBoard)
    val events = captureEvents(engine)
    engine.processUserInput("e7e8")
    engine.completePromotion(PromotionPiece.Queen)
    events.exists(_.isInstanceOf[CheckDetectedEvent]) should be (true)
  }
  test("completePromotion results in Moved when promotion doesn't give check") {
    // White pawn on e7, black king on a2 (far away, not in check after promotion)
    val board = FenParser.parseBoard("8/4P3/8/8/8/8/k7/8").get
    val engine = new GameEngine(initialBoard = board)
    val events = captureEvents(engine)
    engine.processUserInput("e7e8")
    engine.completePromotion(PromotionPiece.Queen)
    engine.isPendingPromotion should be (false)
    engine.board.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
    events.filter(_.isInstanceOf[MoveExecutedEvent]) should not be empty
    events.exists(_.isInstanceOf[CheckDetectedEvent]) should be (false)
  }
  test("completePromotion results in Checkmate when promotion delivers checkmate") {
    // Black king on a8, white king on b6, white pawn on h7
    // h7->h8=Q delivers checkmate
    val board = FenParser.parseBoard("k7/7P/1K6/8/8/8/8/8").get
    val engine = new GameEngine(initialBoard = board)
    val events = captureEvents(engine)
    engine.processUserInput("h7h8")
    engine.completePromotion(PromotionPiece.Queen)
    engine.isPendingPromotion should be (false)
    events.exists(_.isInstanceOf[CheckmateEvent]) should be (true)
  }
  test("completePromotion results in Stalemate when promotion creates stalemate") {
    // Black king on a8, white pawn on b7, white bishop on c7, white king on b6
    // b7->b8=N: no check; Ka8 has no legal moves -> stalemate
    val board = FenParser.parseBoard("k7/1PB5/1K6/8/8/8/8/8").get
    val engine = new GameEngine(initialBoard = board)
    val events = captureEvents(engine)
    engine.processUserInput("b7b8")
    engine.completePromotion(PromotionPiece.Knight)
    engine.isPendingPromotion should be (false)
    events.exists(_.isInstanceOf[StalemateEvent]) should be (true)
  }
  test("completePromotion with black pawn promotion results in Moved") {
    // Black pawn e2, white king h3 (not on rank 1 or file e), black king a8
    // e2->e1=Q: queen on e1 does not attack h3 -> normal Moved
    val board = FenParser.parseBoard("k7/8/8/8/8/7K/4p3/8").get
    val engine = new GameEngine(initialBoard = board, initialTurn = Color.Black)
    val events = captureEvents(engine)
    engine.processUserInput("e2e1")
    engine.completePromotion(PromotionPiece.Queen)
    engine.isPendingPromotion should be (false)
    engine.board.pieceAt(sq(File.E, Rank.R1)) should be (Some(Piece(Color.Black, PieceType.Queen)))
    events.filter(_.isInstanceOf[MoveExecutedEvent]) should not be empty
    events.exists(_.isInstanceOf[CheckDetectedEvent]) should be (false)
  }
  test("completePromotion catch-all fires InvalidMoveEvent for unexpected MoveResult") {
    // Inject a function that returns an unexpected MoveResult to hit the catch-all case
    val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val stubFn: (de.nowchess.api.board.Board, de.nowchess.chess.logic.GameHistory, Square, Square, PromotionPiece, Color) => de.nowchess.chess.controller.MoveResult =
      (_, _, _, _, _, _) => de.nowchess.chess.controller.MoveResult.NoPiece
    val engine = new GameEngine(initialBoard = promotionBoard, completePromotionFn = stubFn)
    val events = captureEvents(engine)
    engine.processUserInput("e7e8")
    engine.isPendingPromotion should be (true)
    engine.completePromotion(PromotionPiece.Queen)
    engine.isPendingPromotion should be (false)
    events.exists(_.isInstanceOf[InvalidMoveEvent]) should be (true)
  }
@@ -3,7 +3,7 @@ package de.nowchess.chess.engine
 import scala.collection.mutable
 import de.nowchess.api.board.{Board, Color}
 import de.nowchess.chess.logic.GameHistory
-import de.nowchess.chess.observer.{Observer, GameEvent, MoveExecutedEvent, CheckDetectedEvent, BoardResetEvent, InvalidMoveEvent, FiftyMoveRuleAvailableEvent, DrawClaimedEvent}
+import de.nowchess.chess.observer.{Observer, GameEvent, MoveExecutedEvent, CheckDetectedEvent, BoardResetEvent, InvalidMoveEvent}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
@@ -302,47 +302,6 @@ class GameEngineTest extends AnyFunSuite with Matchers:
    engine.board shouldBe boardAfterSecondMove
    engine.turn shouldBe Color.White
  // ──── 50-move rule ───────────────────────────────────────────────────
  test("GameEngine: 'draw' rejected when halfMoveClock < 100"):
    val engine = new GameEngine()
    val observer = new MockObserver()
    engine.subscribe(observer)
    engine.processUserInput("draw")
    observer.events.size shouldBe 1
    observer.events.head shouldBe a[InvalidMoveEvent]
  test("GameEngine: 'draw' accepted and fires DrawClaimedEvent when halfMoveClock >= 100"):
    val engine = new GameEngine(initialHistory = GameHistory(halfMoveClock = 100))
    val observer = new MockObserver()
    engine.subscribe(observer)
    engine.processUserInput("draw")
    observer.events.size shouldBe 1
    observer.events.head shouldBe a[DrawClaimedEvent]
  test("GameEngine: state resets to initial after draw claimed"):
    val engine = new GameEngine(initialHistory = GameHistory(halfMoveClock = 100))
    engine.processUserInput("draw")
    engine.board shouldBe Board.initial
    engine.history shouldBe GameHistory.empty
    engine.turn shouldBe Color.White
  test("GameEngine: FiftyMoveRuleAvailableEvent fired when move brings clock to 100"):
    // Start at clock 99; a knight move (non-pawn, non-capture) increments to 100
    val engine = new GameEngine(initialHistory = GameHistory(halfMoveClock = 99))
    val observer = new MockObserver()
    engine.subscribe(observer)
    engine.processUserInput("g1f3")  // knight move on initial board
    // Should receive MoveExecutedEvent AND FiftyMoveRuleAvailableEvent
    observer.events.exists(_.isInstanceOf[FiftyMoveRuleAvailableEvent]) shouldBe true
  test("GameEngine: FiftyMoveRuleAvailableEvent not fired when clock is below 100 after move"):
    val engine = new GameEngine(initialHistory = GameHistory(halfMoveClock = 5))
    val observer = new MockObserver()
    engine.subscribe(observer)
    engine.processUserInput("g1f3")
    observer.events.exists(_.isInstanceOf[FiftyMoveRuleAvailableEvent]) shouldBe false
  // Mock Observer for testing
  private class MockObserver extends Observer:
    val events = mutable.ListBuffer[GameEvent]()
@@ -1,7 +1,6 @@
 package de.nowchess.chess.logic
 import de.nowchess.api.board.*
 import de.nowchess.api.move.PromotionPiece
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
@@ -40,65 +39,3 @@ class GameHistoryTest extends AnyFunSuite with Matchers:
    val history = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
    history.moves should have length 1
    history.moves.head.castleSide shouldBe None
  test("Move with promotion records the promotion piece"):
    val move = HistoryMove(sq(File.E, Rank.R7), sq(File.E, Rank.R8), None, Some(PromotionPiece.Queen))
    move.promotionPiece should be (Some(PromotionPiece.Queen))
  test("Normal move has no promotion piece"):
    val move = HistoryMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4), None, None)
    move.promotionPiece should be (None)
  test("addMove with promotion stores promotionPiece"):
    val history = GameHistory.empty
    val newHistory = history.addMove(sq(File.E, Rank.R7), sq(File.E, Rank.R8), None, Some(PromotionPiece.Rook))
    newHistory.moves should have length 1
    newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Rook))
  test("addMove with castleSide only uses promotionPiece default (None)"):
    val history = GameHistory.empty
    // With overload 3 removed, this uses the 4-param version and triggers addMove$default$4
    val newHistory = history.addMove(sq(File.E, Rank.R1), sq(File.G, Rank.R1), Some(CastleSide.Kingside))
    newHistory.moves should have length 1
    newHistory.moves.head.castleSide should be (Some(CastleSide.Kingside))
    newHistory.moves.head.promotionPiece should be (None)
  test("addMove using named parameters with only promotion, using castleSide default"):
    val history = GameHistory.empty
    val newHistory = history.addMove(from = sq(File.E, Rank.R7), to = sq(File.E, Rank.R8), promotionPiece = Some(PromotionPiece.Queen))
    newHistory.moves should have length 1
    newHistory.moves.head.castleSide should be (None)
    newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Queen))
  // ──── half-move clock ────────────────────────────────────────────────
  test("halfMoveClock starts at 0"):
    GameHistory.empty.halfMoveClock shouldBe 0
  test("halfMoveClock increments on a non-pawn non-capture move"):
    val h = GameHistory.empty.addMove(sq(File.G, Rank.R1), sq(File.F, Rank.R3))
    h.halfMoveClock shouldBe 1
  test("halfMoveClock resets to 0 on a pawn move"):
    val h = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4), wasPawnMove = true)
    h.halfMoveClock shouldBe 0
  test("halfMoveClock resets to 0 on a capture"):
    val h = GameHistory.empty.addMove(sq(File.E, Rank.R5), sq(File.D, Rank.R6), wasCapture = true)
    h.halfMoveClock shouldBe 0
  test("halfMoveClock resets to 0 when both wasPawnMove and wasCapture are true"):
    val h = GameHistory.empty.addMove(sq(File.E, Rank.R5), sq(File.D, Rank.R6), wasPawnMove = true, wasCapture = true)
    h.halfMoveClock shouldBe 0
  test("halfMoveClock carries across multiple moves"):
    val h = GameHistory.empty
      .addMove(sq(File.G, Rank.R1), sq(File.F, Rank.R3))          // +1 → 1
      .addMove(sq(File.G, Rank.R8), sq(File.F, Rank.R6))          // +1 → 2
      .addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4), wasPawnMove = true)  // reset → 0
      .addMove(sq(File.B, Rank.R1), sq(File.C, Rank.R3))          // +1 → 1
    h.halfMoveClock shouldBe 1
  test("GameHistory can be initialised with a non-zero halfMoveClock"):
    val h = GameHistory(halfMoveClock = 42)
    h.halfMoveClock shouldBe 42
@@ -3,7 +3,6 @@ package de.nowchess.chess.logic
 import de.nowchess.api.board.{Board, Color, File, Piece, Rank, Square}
 import de.nowchess.api.game.CastlingRights
 import de.nowchess.chess.logic.{CastleSide, GameHistory}
 import de.nowchess.chess.notation.FenParser
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
@@ -256,25 +255,3 @@ class MoveValidatorTest extends AnyFunSuite with Matchers:
    val b = board(sq(File.D, Rank.R4) -> Piece.WhiteRook)
    val h = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
    MoveValidator.legalTargets(b, h, sq(File.D, Rank.R4)) shouldBe MoveValidator.legalTargets(b, sq(File.D, Rank.R4))
  // ──── isPromotionMove ────────────────────────────────────────────────
  test("White pawn reaching R8 is a promotion move"):
    val b = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    MoveValidator.isPromotionMove(b, Square(File.E, Rank.R7), Square(File.E, Rank.R8)) should be (true)
  test("Black pawn reaching R1 is a promotion move"):
    val b = FenParser.parseBoard("8/8/8/8/4K3/8/4p3/8").get
    MoveValidator.isPromotionMove(b, Square(File.E, Rank.R2), Square(File.E, Rank.R1)) should be (true)
  test("Pawn capturing to back rank is a promotion move"):
    val b = FenParser.parseBoard("3q4/4P3/8/8/8/8/8/8").get
    MoveValidator.isPromotionMove(b, Square(File.E, Rank.R7), Square(File.D, Rank.R8)) should be (true)
  test("Pawn not reaching back rank is not a promotion move"):
    val b = FenParser.parseBoard("8/8/8/4P3/8/8/8/8").get
    MoveValidator.isPromotionMove(b, Square(File.E, Rank.R5), Square(File.E, Rank.R6)) should be (false)
  test("Non-pawn piece is never a promotion move"):
    val b = FenParser.parseBoard("8/8/8/4Q3/8/8/8/8").get
    MoveValidator.isPromotionMove(b, Square(File.E, Rank.R5), Square(File.E, Rank.R8)) should be (false)
@@ -67,22 +67,3 @@ class FenExporterTest extends AnyFunSuite with Matchers:
    )
    val fen = FenExporter.gameStateToFen(gameState)
    fen shouldBe "rnbqkbnr/pp1ppppp/8/2pP4/8/8/PPPP1PPP/RNBQKBNR w KQkq c6 2 3"
  test("halfMoveClock round-trips through FEN export and import"):
    import de.nowchess.chess.logic.GameHistory
    import de.nowchess.chess.notation.FenParser
    val history = GameHistory(halfMoveClock = 42)
    val gameState = GameState(
      piecePlacement  = FenExporter.boardToFen(de.nowchess.api.board.Board.initial),
      activeColor     = Color.White,
      castlingWhite   = CastlingRights.Both,
      castlingBlack   = CastlingRights.Both,
      enPassantTarget = None,
      halfMoveClock   = history.halfMoveClock,
      fullMoveNumber  = 1,
      status          = GameStatus.InProgress
    )
    val fen    = FenExporter.gameStateToFen(gameState)
    FenParser.parseFen(fen) match
      case Some(gs) => gs.halfMoveClock shouldBe 42
      case None     => fail("FEN parsing failed")
@@ -1,7 +1,6 @@
 package de.nowchess.chess.notation
 import de.nowchess.api.board.*
 import de.nowchess.api.move.PromotionPiece
 import de.nowchess.chess.logic.{GameHistory, HistoryMove, CastleSide}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
@@ -64,51 +63,3 @@ class PgnExporterTest extends AnyFunSuite with Matchers:
    pgn.contains("O-O-O") shouldBe true
  }
  test("exportGame encodes promotion to Queen as =Q suffix") {
    val history = GameHistory()
      .addMove(HistoryMove(Square(File.E, Rank.R7), Square(File.E, Rank.R8), None, Some(PromotionPiece.Queen)))
    val pgn = PgnExporter.exportGame(Map.empty, history)
    pgn should include ("e7e8=Q")
  }
  test("exportGame encodes promotion to Rook as =R suffix") {
    val history = GameHistory()
      .addMove(HistoryMove(Square(File.E, Rank.R7), Square(File.E, Rank.R8), None, Some(PromotionPiece.Rook)))
    val pgn = PgnExporter.exportGame(Map.empty, history)
    pgn should include ("e7e8=R")
  }
  test("exportGame encodes promotion to Bishop as =B suffix") {
    val history = GameHistory()
      .addMove(HistoryMove(Square(File.E, Rank.R7), Square(File.E, Rank.R8), None, Some(PromotionPiece.Bishop)))
    val pgn = PgnExporter.exportGame(Map.empty, history)
    pgn should include ("e7e8=B")
  }
  test("exportGame encodes promotion to Knight as =N suffix") {
    val history = GameHistory()
      .addMove(HistoryMove(Square(File.E, Rank.R7), Square(File.E, Rank.R8), None, Some(PromotionPiece.Knight)))
    val pgn = PgnExporter.exportGame(Map.empty, history)
    pgn should include ("e7e8=N")
  }
  test("exportGame does not add suffix for normal moves") {
    val history = GameHistory()
      .addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None, None))
    val pgn = PgnExporter.exportGame(Map.empty, history)
    pgn should include ("e2e4")
    pgn should not include ("=")
  }
  test("exportGame uses Result header as termination marker"):
    val history = GameHistory()
      .addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None))
    val pgn = PgnExporter.exportGame(Map("Result" -> "1/2-1/2"), history)
    pgn should endWith("1/2-1/2")
  test("exportGame with no Result header still uses * as default"):
    val history = GameHistory()
      .addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None))
    val pgn = PgnExporter.exportGame(Map.empty, history)
    pgn shouldBe "1. e2e4 *"
@@ -1,9 +1,7 @@
 package de.nowchess.chess.notation
 import de.nowchess.api.board.*
 import de.nowchess.api.move.PromotionPiece
 import de.nowchess.chess.logic.{GameHistory, HistoryMove, CastleSide}
 import de.nowchess.chess.notation.FenParser
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
@@ -334,118 +332,3 @@ class PgnParserTest extends AnyFunSuite with Matchers:
    result.isDefined shouldBe true
    result.get.to shouldBe Square(File.D, Rank.R1)
  }
  test("parseAlgebraicMove preserves promotion to Queen in HistoryMove") {
    val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val result = PgnParser.parseAlgebraicMove("e7e8=Q", board, GameHistory.empty, Color.White)
    result.isDefined should be (true)
    result.get.promotionPiece should be (Some(PromotionPiece.Queen))
    result.get.to should be (Square(File.E, Rank.R8))
  }
  test("parseAlgebraicMove preserves promotion to Rook") {
    val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val result = PgnParser.parseAlgebraicMove("e7e8=R", board, GameHistory.empty, Color.White)
    result.get.promotionPiece should be (Some(PromotionPiece.Rook))
  }
  test("parseAlgebraicMove preserves promotion to Bishop") {
    val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val result = PgnParser.parseAlgebraicMove("e7e8=B", board, GameHistory.empty, Color.White)
    result.get.promotionPiece should be (Some(PromotionPiece.Bishop))
  }
  test("parseAlgebraicMove preserves promotion to Knight") {
    val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
    val result = PgnParser.parseAlgebraicMove("e7e8=N", board, GameHistory.empty, Color.White)
    result.get.promotionPiece should be (Some(PromotionPiece.Knight))
  }
  test("parsePgn applies promoted piece to board for subsequent moves") {
    // Build a board with a white pawn on e7 plus the two kings
    import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
    val pieces: Map[Square, Piece] = Map(
      Square(File.E, Rank.R7) -> Piece(Color.White, PieceType.Pawn),
      Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
      Square(File.H, Rank.R1) -> Piece(Color.Black, PieceType.King)
    )
    val board = Board(pieces)
    val move = PgnParser.parseAlgebraicMove("e7e8=Q", board, GameHistory.empty, Color.White)
    move.isDefined should be (true)
    move.get.promotionPiece should be (Some(PromotionPiece.Queen))
    // After applying the promotion the square e8 should hold a White Queen
    val (boardAfterPawnMove, _) = board.withMove(move.get.from, move.get.to)
    val promotedBoard = boardAfterPawnMove.updated(move.get.to, Piece(Color.White, PieceType.Queen))
    promotedBoard.pieceAt(Square(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
  }
  test("parsePgn with all four promotion piece types (Queen, Rook, Bishop, Knight) in sequence") {
    // This test exercises lines 53-58 in PgnParser.parseMovesText which contain
    // the pattern match over PromotionPiece for Queen, Rook, Bishop, Knight
    val pgn = """[Event "Promotion Test"]
 [White "A"]
 [Black "B"]
 1. a2a3 h7h5 2. a3a4 h5h4 3. a4a5 h4h3 4. a5a6 h3h2 5. a6a7 h2h1=Q 6. a7a8=R 1-0
 """
    val game = PgnParser.parsePgn(pgn)
    game.isDefined shouldBe true
    // Move 10 is h2h1=Q (black pawn promotes to queen)
    val blackPromotionToQ = game.get.moves(9)  // 0-indexed
    blackPromotionToQ.promotionPiece shouldBe Some(PromotionPiece.Queen)
    // Move 11 is a7a8=R (white pawn promotes to rook)
    val whitePromotionToR = game.get.moves(10)
    whitePromotionToR.promotionPiece shouldBe Some(PromotionPiece.Rook)
  }
  test("parseAlgebraicMove promotion with Rook through full PGN parse") {
    val pgn = """[Event "Test"]
 [White "A"]
 [Black "B"]
 1. a2a3 h7h6 2. a3a4 h6h5 3. a4a5 h5h4 4. a5a6 h4h3 5. a6a7 h3h2 6. a7a8=R
 """
    val game = PgnParser.parsePgn(pgn)
    game.isDefined shouldBe true
    val lastMove = game.get.moves.last
    lastMove.promotionPiece shouldBe Some(PromotionPiece.Rook)
  }
  test("parseAlgebraicMove promotion with Bishop through full PGN parse") {
    val pgn = """[Event "Test"]
 [White "A"]
 [Black "B"]
 1. b2b3 h7h6 2. b3b4 h6h5 3. b4b5 h5h4 4. b5b6 h4h3 5. b6b7 h3h2 6. b7b8=B
 """
    val game = PgnParser.parsePgn(pgn)
    game.isDefined shouldBe true
    val lastMove = game.get.moves.last
    lastMove.promotionPiece shouldBe Some(PromotionPiece.Bishop)
  }
  test("parseAlgebraicMove promotion with Knight through full PGN parse") {
    val pgn = """[Event "Test"]
 [White "A"]
 [Black "B"]
 1. c2c3 h7h6 2. c3c4 h6h5 3. c4c5 h5h4 4. c5c6 h4h3 5. c6c7 h3h2 6. c7c8=N
 """
    val game = PgnParser.parsePgn(pgn)
    game.isDefined shouldBe true
    val lastMove = game.get.moves.last
    lastMove.promotionPiece shouldBe Some(PromotionPiece.Knight)
  }
  test("extractPromotion returns None for invalid promotion letter") {
    // Regex =([A-Z]) now captures any uppercase letter, so =X is matched but case _ => None fires
    val result = PgnParser.extractPromotion("e7e8=X")
    result shouldBe None
  }
  test("extractPromotion returns None when no promotion in notation") {
    val result = PgnParser.extractPromotion("e7e8")
    result shouldBe None
  }
@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=6
+MINOR=3
 PATCH=0
@@ -1,6 +0,0 @@
 ##  (2026-04-01)
 ### Features
 * NCS-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
 * NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
@@ -1,7 +1,6 @@
 package de.nowchess.ui.terminal
 import scala.io.StdIn
 import de.nowchess.api.move.PromotionPiece
 import de.nowchess.chess.engine.GameEngine
 import de.nowchess.chess.observer.{Observer, GameEvent, *}
 import de.nowchess.chess.view.Renderer
@@ -12,7 +11,6 @@ import de.nowchess.chess.view.Renderer
 */
 class TerminalUI(engine: GameEngine) extends Observer:
  private var running = true
  private var awaitingPromotion = false
  /** Called by GameEngine whenever a game event occurs. */
  override def onGameEvent(event: GameEvent): Unit =
@@ -46,10 +44,6 @@ class TerminalUI(engine: GameEngine) extends Observer:
        print(Renderer.render(e.board))
        printPrompt(e.turn)
      case _: PromotionRequiredEvent =>
        println("Promote to: q=Queen, r=Rook, b=Bishop, n=Knight")
        synchronized { awaitingPromotion = true }
  /** Start the terminal UI game loop. */
  def start(): Unit =
    // Register as observer
@@ -63,26 +57,14 @@ class TerminalUI(engine: GameEngine) extends Observer:
    // Game loop
    while running do
      val input = Option(StdIn.readLine()).getOrElse("quit").trim
-      synchronized {
+      input.toLowerCase match
-        if awaitingPromotion then
+        case "quit" | "q" =>
-          input.toLowerCase match
+          running = false
-            case "q" => awaitingPromotion = false; engine.completePromotion(PromotionPiece.Queen)
+          println("Game over. Goodbye!")
-            case "r" => awaitingPromotion = false; engine.completePromotion(PromotionPiece.Rook)
+        case "" =>
-            case "b" => awaitingPromotion = false; engine.completePromotion(PromotionPiece.Bishop)
+          printPrompt(engine.turn)
-            case "n" => awaitingPromotion = false; engine.completePromotion(PromotionPiece.Knight)
+        case _ =>
-            case _ =>
+          engine.processUserInput(input)
              println("Invalid choice. Enter q, r, b, or n.")
              println("Promote to: q=Queen, r=Rook, b=Bishop, n=Knight")
        else
          input.toLowerCase match
            case "quit" | "q" =>
              running = false
              println("Game over. Goodbye!")
            case "" =>
              printPrompt(engine.turn)
            case _ =>
              engine.processUserInput(input)
      }
    // Unsubscribe when done
    engine.unsubscribe(this)
@@ -91,3 +73,4 @@ class TerminalUI(engine: GameEngine) extends Observer:
    val undoHint = if engine.canUndo then " [undo]" else ""
    val redoHint = if engine.canRedo then " [redo]" else ""
    print(s"${turn.label}'s turn. Enter move (or 'quit'/'q' to exit)$undoHint$redoHint: ")
@@ -5,7 +5,7 @@ import org.scalatest.matchers.should.Matchers
 import java.io.{ByteArrayInputStream, ByteArrayOutputStream}
 import de.nowchess.chess.engine.GameEngine
 import de.nowchess.chess.observer.*
-import de.nowchess.api.board.{Board, Color, File, Rank, Square}
+import de.nowchess.api.board.{Board, Color}
 import de.nowchess.chess.logic.GameHistory
 class TerminalUITest extends AnyFunSuite with Matchers {
@@ -186,142 +186,4 @@ class TerminalUITest extends AnyFunSuite with Matchers {
    // The move should have been processed and the board displayed
    engine.turn shouldBe Color.Black
  }
  test("TerminalUI shows promotion prompt on PromotionRequiredEvent") {
    val out = new ByteArrayOutputStream()
    val engine = new GameEngine()
    val ui = new TerminalUI(engine)
    Console.withOut(out) {
      ui.onGameEvent(PromotionRequiredEvent(
        Board(Map.empty), GameHistory(), Color.White,
        Square(File.E, Rank.R7), Square(File.E, Rank.R8)
      ))
    }
    out.toString should include("Promote to")
  }
  test("TerminalUI routes promotion choice to engine.completePromotion") {
    import de.nowchess.api.move.PromotionPiece
    var capturedPiece: Option[PromotionPiece] = None
    val engine = new GameEngine() {
      override def processUserInput(rawInput: String): Unit =
        if rawInput.trim == "e7e8" then
          notifyObservers(PromotionRequiredEvent(
            Board(Map.empty), GameHistory.empty, Color.White,
            Square(File.E, Rank.R7), Square(File.E, Rank.R8)
          ))
      override def completePromotion(piece: PromotionPiece): Unit =
        capturedPiece = Some(piece)
        notifyObservers(MoveExecutedEvent(Board(Map.empty), GameHistory.empty, Color.Black, "e7", "e8", None))
    }
    val in = new ByteArrayInputStream("e7e8\nq\nquit\n".getBytes)
    val out = new ByteArrayOutputStream()
    val ui = new TerminalUI(engine)
    Console.withIn(in) {
      Console.withOut(out) {
        ui.start()
      }
    }
    capturedPiece should be(Some(PromotionPiece.Queen))
    out.toString should include("Promote to")
  }
  test("TerminalUI re-prompts on invalid promotion choice") {
    import de.nowchess.api.move.PromotionPiece
    var capturedPiece: Option[PromotionPiece] = None
    val engine = new GameEngine() {
      override def processUserInput(rawInput: String): Unit =
        if rawInput.trim == "e7e8" then
          notifyObservers(PromotionRequiredEvent(
            Board(Map.empty), GameHistory.empty, Color.White,
            Square(File.E, Rank.R7), Square(File.E, Rank.R8)
          ))
      override def completePromotion(piece: PromotionPiece): Unit =
        capturedPiece = Some(piece)
        notifyObservers(MoveExecutedEvent(Board(Map.empty), GameHistory.empty, Color.Black, "e7", "e8", None))
    }
    // "x" is invalid, then "r" for rook
    val in = new ByteArrayInputStream("e7e8\nx\nr\nquit\n".getBytes)
    val out = new ByteArrayOutputStream()
    val ui = new TerminalUI(engine)
    Console.withIn(in) {
      Console.withOut(out) {
        ui.start()
      }
    }
    capturedPiece should be(Some(PromotionPiece.Rook))
    out.toString should include("Invalid")
  }
  test("TerminalUI routes Bishop promotion choice to engine.completePromotion") {
    import de.nowchess.api.move.PromotionPiece
    var capturedPiece: Option[PromotionPiece] = None
    val engine = new GameEngine() {
      override def processUserInput(rawInput: String): Unit =
        if rawInput.trim == "e7e8" then
          notifyObservers(PromotionRequiredEvent(
            Board(Map.empty), GameHistory.empty, Color.White,
            Square(File.E, Rank.R7), Square(File.E, Rank.R8)
          ))
      override def completePromotion(piece: PromotionPiece): Unit =
        capturedPiece = Some(piece)
        notifyObservers(MoveExecutedEvent(Board(Map.empty), GameHistory.empty, Color.Black, "e7", "e8", None))
    }
    val in = new ByteArrayInputStream("e7e8\nb\nquit\n".getBytes)
    val out = new ByteArrayOutputStream()
    val ui = new TerminalUI(engine)
    Console.withIn(in) {
      Console.withOut(out) {
        ui.start()
      }
    }
    capturedPiece should be(Some(PromotionPiece.Bishop))
  }
  test("TerminalUI routes Knight promotion choice to engine.completePromotion") {
    import de.nowchess.api.move.PromotionPiece
    var capturedPiece: Option[PromotionPiece] = None
    val engine = new GameEngine() {
      override def processUserInput(rawInput: String): Unit =
        if rawInput.trim == "e7e8" then
          notifyObservers(PromotionRequiredEvent(
            Board(Map.empty), GameHistory.empty, Color.White,
            Square(File.E, Rank.R7), Square(File.E, Rank.R8)
          ))
      override def completePromotion(piece: PromotionPiece): Unit =
        capturedPiece = Some(piece)
        notifyObservers(MoveExecutedEvent(Board(Map.empty), GameHistory.empty, Color.Black, "e7", "e8", None))
    }
    val in = new ByteArrayInputStream("e7e8\nn\nquit\n".getBytes)
    val out = new ByteArrayOutputStream()
    val ui = new TerminalUI(engine)
    Console.withIn(in) {
      Console.withOut(out) {
        ui.start()
      }
    }
    capturedPiece should be(Some(PromotionPiece.Knight))
  }
 }
@@ -1,3 +0,0 @@
 MAJOR=0
 MINOR=1
 PATCH=0
Author	SHA1	Message	Date
Janis	c75a3a28af	test: add tests for undo and redo notifications in GameEngine Build & Test (NowChessSystems) TeamCity build finished Details	2026-03-31 09:34:39 +02:00
Janis	40086a331f	fix: improve TerminalUI coverage and make MoveCommand/ResetCommand immutable TerminalUI Coverage Fix: - Added explicit test for empty input case (lines 64-65 previously uncovered) - Test "TerminalUI should explicitly handle empty input by re-prompting" validates that multiple empty inputs are properly handled by re-prompting - UI module coverage improved to near-100% MoveCommand Immutability (Anti-pattern Fix): - Changed MoveCommand fields from var to val: moveResult, previousBoard, previousHistory, previousTurn - Changed ResetCommand fields from var to val: previousBoard, previousHistory, previousTurn - Updated GameEngine to use .copy() instead of direct mutation when updating command state (lines 88, 95, 103, 112) - Removed 3 edge-case tests that relied on command mutation (now impossible with immutable fields) MoveCommand Immutability Tests: - Added MoveCommandImmutabilityTest to verify: - Fields cannot be mutated after creation - equals/hashCode respect immutability invariant - .copy() creates new instances with updated values All tests pass; 100% core coverage maintained. Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>	2026-03-31 08:43:44 +02:00
Janis	8f64273ceb	fix: add thread-safety synchronization to Observable and CommandInvoker Test-driven fixes for code review blockers NCS-16: Observable (CRITICAL): Added synchronized blocks to subscribe, unsubscribe, notifyObservers, and observerCount to prevent race conditions when concurrent threads register observers while notifications are dispatched. CommandInvoker (IMPORTANT): Added synchronized blocks to all methods (execute, undo, redo, history, getCurrentIndex, canUndo, canRedo, clear) to ensure atomic access to mutable state (executedCommands, currentIndex). Tests: - Added ObservableThreadSafetyTest: 3 tests for concurrent subscribe/unsubscribe/notify - Added CommandInvokerThreadSafetyTest: 2 tests for concurrent execute/undo/redo - All 54 existing tests remain green - Full build passes with 100% core coverage Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>	2026-03-31 08:32:15 +02:00
Janis	418e45e805	refactor: simplify undo and redo logic in GameEngine and removed Hacky Test Build & Test (NowChessSystems) TeamCity build failed Details	2026-03-30 22:38:13 +02:00
shahdlala66	41b53d1dee	test: added UI model tests Build & Test (NowChessSystems) TeamCity build failed Details	2026-03-30 22:32:57 +02:00
shahdlala66	75f2363517	fix: PR issues fixed Build & Test (NowChessSystems) TeamCity build failed Details	2026-03-30 21:48:04 +02:00
shahdlala66	ab96aee3ea	test: 100% Build & Test (NowChessSystems) TeamCity build failed Details	2026-03-30 21:42:52 +02:00
shahdlala66	5499d528de	fix: removing the scala metal folder Build & Test (NowChessSystems) TeamCity build failed Details	2026-03-30 19:44:02 +02:00
shahdlala66	7f44c07c23	fix: removing metal folder Build & Test (NowChessSystems) TeamCity build failed Details	2026-03-30 19:37:17 +02:00
shahdlala66	5278de96a5	test: reached 99% for GameEngine Build & Test (NowChessSystems) TeamCity build failed Details	2026-03-30 00:32:10 +02:00
shahdlala66	f0cd46f132	test: more branch coverage for CommandInvoker Build & Test (NowChessSystems) TeamCity build finished Details	2026-03-29 21:08:07 +02:00
shahdlala66	9c1acfc9db	feat: undo/redo added	2026-03-29 20:58:33 +02:00
shahdlala66	d2f294294f	feat: core sepration, observer added	2026-03-29 20:47:58 +02:00
Janis	7d60c4bb29	feat: enhance FEN and PGN parsers with additional test cases and coverage improvements	2026-03-29 17:49:05 +02:00
Janis	60b02d8f20	style: replace .isDefined/.get with pattern matching in PgnParser Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-29 17:14:41 +02:00
Janis	9bc1ef550f	feat: add PGN exporter for game notation Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-29 17:14:41 +02:00
Janis	98896535ed	feat: add PGN parser with algebraic move notation Implements PgnParser with parsePgn(), parseAlgebraicMove(), and move resolution using geometric piece reachability with disambiguation support for piece type, file, and rank hints. Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>	2026-03-29 17:13:16 +02:00
Janis	18c712d5c9	feat: add full FEN parsing with GameState support Implements parseFen() in FenParser and gameStateToFen() in FenExporter, covering all 6 FEN fields (piece placement, active color, castling, en passant, half-move clock, full-move number). Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-29 17:12:29 +02:00
Janis	ade9d14ddc	feat: add FEN exporter and round-trip tests Implements FenExporter.boardToFen() converting Board to FEN piece-placement string, and adds three round-trip tests (initial position, empty board, partial position). Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-29 17:11:31 +02:00
Janis	5db1405066	feat: add FEN piece-placement parser Implements FenParser.parseBoard() to parse FEN piece-placement strings into a Board, with proper None propagation on invalid input. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-29 17:11:13 +02:00