feat: NCS-16 Core Separation via Patterns (#10)

Co-authored-by: Janis <janis-e@gmx.de>
Co-authored-by: shahdlala66 <shahd.lala66@gmail.com>
Co-authored-by: Janis <janis.e.20@gmx.de>
Reviewed-on: #10
Reviewed-by: Janis <janis-e@gmx.de>
Co-authored-by: Shahd Lala <shosho996@blackhole.local>
Co-committed-by: Shahd Lala <shosho996@blackhole.local>

modules/core/src/main/scala/de/nowchess/chess/Main.scala

@@ -1,12 +0,0 @@
-package de.nowchess.chess
-
-import de.nowchess.api.board.Board
-import de.nowchess.api.board.Color
-import de.nowchess.chess.controller.GameController
-import de.nowchess.chess.logic.GameHistory
-
-object Main {
-  def main(args: Array[String]): Unit =
-    println("NowChess TUI — type moves in coordinate notation (e.g. e2e4). Type 'quit' to exit.")
-    GameController.gameLoop(Board.initial, GameHistory.empty, Color.White)
-}

modules/core/src/main/scala/de/nowchess/chess/command/Command.scala

@@ -0,0 +1,64 @@
+package de.nowchess.chess.command
+
+import de.nowchess.api.board.{Square, Board, Color, Piece}
+import de.nowchess.chess.logic.GameHistory
+
+/** Marker trait for all commands that can be executed and undone.
+ *  Commands encapsulate user actions and game state transitions.
+ */
+trait Command:
+  /** Execute the command and return true if successful, false otherwise. */
+  def execute(): Boolean
+
+  /** Undo the command and return true if successful, false otherwise. */
+  def undo(): Boolean
+
+  /** A human-readable description of this command. */
+  def description: String
+
+/** Command to move a piece from one square to another.
+ *  Stores the move result so undo can restore previous state.
+ */
+case class MoveCommand(
+  from: Square,
+  to: Square,
+  moveResult: Option[MoveResult] = None,
+  previousBoard: Option[Board] = None,
+  previousHistory: Option[GameHistory] = None,
+  previousTurn: Option[Color] = None
+) extends Command:
+
+  override def execute(): Boolean =
+    moveResult.isDefined
+
+  override def undo(): Boolean =
+    previousBoard.isDefined && previousHistory.isDefined && previousTurn.isDefined
+
+  override def description: String = s"Move from $from to $to"
+
+// Sealed hierarchy of move outcomes (for tracking state changes)
+sealed trait MoveResult
+object MoveResult:
+  case class Successful(newBoard: Board, newHistory: GameHistory, newTurn: Color, captured: Option[Piece]) extends MoveResult
+  case object InvalidFormat extends MoveResult
+  case object InvalidMove extends MoveResult
+
+/** Command to quit the game. */
+case class QuitCommand() extends Command:
+  override def execute(): Boolean = true
+  override def undo(): Boolean = false
+  override def description: String = "Quit game"
+
+/** Command to reset the board to initial position. */
+case class ResetCommand(
+  previousBoard: Option[Board] = None,
+  previousHistory: Option[GameHistory] = None,
+  previousTurn: Option[Color] = None
+) extends Command:
+
+  override def execute(): Boolean = true
+
+  override def undo(): Boolean =
+    previousBoard.isDefined && previousHistory.isDefined && previousTurn.isDefined
+
+  override def description: String = "Reset board"

modules/core/src/main/scala/de/nowchess/chess/command/CommandInvoker.scala

@@ -0,0 +1,73 @@
+package de.nowchess.chess.command
+
+/** Manages command execution and history for undo/redo support. */
+class CommandInvoker:
+  private val executedCommands = scala.collection.mutable.ListBuffer[Command]()
+  private var currentIndex = -1
+
+  /** Execute a command and add it to history.
+   *  Discards any redo history if not at the end of the stack.
+   */
+  def execute(command: Command): Boolean = synchronized {
+    if command.execute() then
+      // Remove any commands after current index (redo stack is discarded)
+      while currentIndex < executedCommands.size - 1 do
+        executedCommands.remove(executedCommands.size - 1)
+      executedCommands += command
+      currentIndex += 1
+      true
+    else
+      false
+  }
+
+  /** Undo the last executed command if possible. */
+  def undo(): Boolean = synchronized {
+    if currentIndex >= 0 && currentIndex < executedCommands.size then
+      val command = executedCommands(currentIndex)
+      if command.undo() then
+        currentIndex -= 1
+        true
+      else
+        false
+    else
+      false
+  }
+
+  /** Redo the next command in history if available. */
+  def redo(): Boolean = synchronized {
+    if currentIndex + 1 < executedCommands.size then
+      val command = executedCommands(currentIndex + 1)
+      if command.execute() then
+        currentIndex += 1
+        true
+      else
+        false
+    else
+      false
+  }
+
+  /** Get the history of all executed commands. */
+  def history: List[Command] = synchronized {
+    executedCommands.toList
+  }
+
+  /** Get the current position in command history. */
+  def getCurrentIndex: Int = synchronized {
+    currentIndex
+  }
+
+  /** Clear all command history. */
+  def clear(): Unit = synchronized {
+    executedCommands.clear()
+    currentIndex = -1
+  }
+
+  /** Check if undo is available. */
+  def canUndo: Boolean = synchronized {
+    currentIndex >= 0
+  }
+
+  /** Check if redo is available. */
+  def canRedo: Boolean = synchronized {
+    currentIndex + 1 < executedCommands.size
+  }

modules/core/src/main/scala/de/nowchess/chess/controller/GameController.scala

@@ -1,9 +1,7 @@
 package de.nowchess.chess.controller
 
-import scala.io.StdIn
 import de.nowchess.api.board.{Board, Color, File, Piece, Rank, Square}
 import de.nowchess.chess.logic.*
-import de.nowchess.chess.view.Renderer
 
 // ---------------------------------------------------------------------------
 // Result ADT returned by the pure processMove function
@@ -66,46 +64,3 @@ object GameController:
                     case PositionStatus.InCheck => MoveResult.MovedInCheck(newBoard, newHistory, captured, turn.opposite)
                     case PositionStatus.Mated   => MoveResult.Checkmate(turn)
                     case PositionStatus.Drawn   => MoveResult.Stalemate
-
-  /** Thin I/O shell: renders the board, reads a line, delegates to processMove,
-   *  prints the outcome, and recurses until the game ends.
-   */
-  def gameLoop(board: Board, history: GameHistory, turn: Color): Unit =
-    println()
-    print(Renderer.render(board))
-    println(s"${turn.label}'s turn. Enter move: ")
-    val input = Option(StdIn.readLine()).getOrElse("quit").trim
-    processMove(board, history, turn, input) match
-      case MoveResult.Quit =>
-        println("Game over. Goodbye!")
-      case MoveResult.InvalidFormat(raw) =>
-        println(s"Invalid move format '$raw'. Use coordinate notation, e.g. e2e4.")
-        gameLoop(board, history, turn)
-      case MoveResult.NoPiece =>
-        println(s"No piece on ${Parser.parseMove(input).map(_._1).fold("?")(_.toString)}.")
-        gameLoop(board, history, turn)
-      case MoveResult.WrongColor =>
-        println(s"That is not your piece.")
-        gameLoop(board, history, turn)
-      case MoveResult.IllegalMove =>
-        println(s"Illegal move.")
-        gameLoop(board, history, turn)
-      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
-        val prevTurn = newTurn.opposite
-        captured.foreach: cap =>
-          val toSq = Parser.parseMove(input).map(_._2).fold("?")(_.toString)
-          println(s"${prevTurn.label} captures ${cap.color.label} ${cap.pieceType.label} on $toSq")
-        gameLoop(newBoard, newHistory, newTurn)
-      case MoveResult.MovedInCheck(newBoard, newHistory, captured, newTurn) =>
-        val prevTurn = newTurn.opposite
-        captured.foreach: cap =>
-          val toSq = Parser.parseMove(input).map(_._2).fold("?")(_.toString)
-          println(s"${prevTurn.label} captures ${cap.color.label} ${cap.pieceType.label} on $toSq")
-        println(s"${newTurn.label} is in check!")
-        gameLoop(newBoard, newHistory, newTurn)
-      case MoveResult.Checkmate(winner) =>
-        println(s"Checkmate! ${winner.label} wins.")
-        gameLoop(Board.initial, GameHistory.empty, Color.White)
-      case MoveResult.Stalemate =>
-        println("Stalemate! The game is a draw.")
-        gameLoop(Board.initial, GameHistory.empty, Color.White)

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

@@ -0,0 +1,209 @@
+package de.nowchess.chess.engine
+
+import de.nowchess.api.board.{Board, Color, Piece, Square}
+import de.nowchess.chess.logic.{GameHistory, GameRules, PositionStatus}
+import de.nowchess.chess.controller.{GameController, Parser, MoveResult}
+import de.nowchess.chess.observer.*
+import de.nowchess.chess.command.{CommandInvoker, MoveCommand}
+
+/** Pure game engine that manages game state and notifies observers of state changes.
+ *  This class is the single source of truth for the game state.
+ *  All user interactions must go through this engine via Commands, and all state changes
+ *  are communicated to observers via GameEvent notifications.
+ */
+class GameEngine extends Observable:
+  private var currentBoard: Board = Board.initial
+  private var currentHistory: GameHistory = GameHistory.empty
+  private var currentTurn: Color = Color.White
+  private val invoker = new CommandInvoker()
+
+  // Synchronized accessors for current state
+  def board: Board = synchronized { currentBoard }
+  def history: GameHistory = synchronized { currentHistory }
+  def turn: Color = synchronized { currentTurn }
+
+  /** Check if undo is available. */
+  def canUndo: Boolean = synchronized { invoker.canUndo }
+
+  /** Check if redo is available. */
+  def canRedo: Boolean = synchronized { invoker.canRedo }
+
+  /** Get the command history for inspection (testing/debugging). */
+  def commandHistory: List[de.nowchess.chess.command.Command] = synchronized { invoker.history }
+
+  /** Process a raw move input string and update game state if valid.
+   *  Notifies all observers of the outcome via GameEvent.
+   */
+  def processUserInput(rawInput: String): Unit = synchronized {
+    val trimmed = rawInput.trim.toLowerCase
+    trimmed match
+      case "quit" | "q" =>
+        // Client should handle quit logic; we just return
+        ()
+
+      case "undo" =>
+        performUndo()
+
+      case "redo" =>
+        performRedo()
+
+      case "" =>
+        val event = InvalidMoveEvent(
+          currentBoard,
+          currentHistory,
+          currentTurn,
+          "Please enter a valid move or command."
+        )
+        notifyObservers(event)
+
+      case moveInput =>
+        // Try to parse as a move
+        Parser.parseMove(moveInput) match
+          case None =>
+            val event = InvalidMoveEvent(
+              currentBoard,
+              currentHistory,
+              currentTurn,
+              s"Invalid move format '$moveInput'. Use coordinate notation, e.g. e2e4."
+            )
+            notifyObservers(event)
+
+          case Some((from, to)) =>
+            // 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))
+  }
+
+  /** Undo the last move. */
+  def undo(): Unit = synchronized {
+    performUndo()
+  }
+
+  /** Redo the last undone move. */
+  def redo(): Unit = synchronized {
+    performRedo()
+  }
+
+  /** Reset the board to initial position. */
+  def reset(): Unit = synchronized {
+    currentBoard = Board.initial
+    currentHistory = GameHistory.empty
+    currentTurn = Color.White
+    invoker.clear()
+    notifyObservers(BoardResetEvent(
+      currentBoard,
+      currentHistory,
+      currentTurn
+    ))
+  }
+
+  // ──── Private Helpers ────
+
+  private def performUndo(): Unit =
+    if invoker.canUndo then
+      val cmd = invoker.history(invoker.getCurrentIndex)
+      (cmd: @unchecked) match
+        case moveCmd: MoveCommand =>
+          moveCmd.previousBoard.foreach(currentBoard = _)
+          moveCmd.previousHistory.foreach(currentHistory = _)
+          moveCmd.previousTurn.foreach(currentTurn = _)
+          invoker.undo()
+          notifyObservers(BoardResetEvent(currentBoard, currentHistory, currentTurn))
+    else
+      notifyObservers(InvalidMoveEvent(currentBoard, currentHistory, currentTurn, "Nothing to undo."))
+
+  private def performRedo(): Unit =
+    if invoker.canRedo then
+      val cmd = invoker.history(invoker.getCurrentIndex + 1)
+      (cmd: @unchecked) match
+        case moveCmd: MoveCommand =>
+          for case de.nowchess.chess.command.MoveResult.Successful(nb, nh, nt, cap) <- moveCmd.moveResult do
+            updateGameState(nb, nh, nt)
+            invoker.redo()
+            emitMoveEvent(moveCmd.from.toString, moveCmd.to.toString, cap, nt)
+    else
+      notifyObservers(InvalidMoveEvent(currentBoard, currentHistory, currentTurn, "Nothing to redo."))
+
+  private def updateGameState(newBoard: Board, newHistory: GameHistory, newTurn: Color): Unit =
+    currentBoard = newBoard
+    currentHistory = newHistory
+    currentTurn = newTurn
+
+  private def emitMoveEvent(fromSq: String, toSq: String, captured: Option[Piece], newTurn: Color): Unit =
+    val capturedDesc = captured.map(c => s"${c.color.label} ${c.pieceType.label}")
+    notifyObservers(MoveExecutedEvent(
+      currentBoard,
+      currentHistory,
+      newTurn,
+      fromSq,
+      toSq,
+      capturedDesc
+    ))
+
+  private def handleFailedMove(moveInput: String): Unit =
+    (GameController.processMove(currentBoard, currentHistory, currentTurn, moveInput): @unchecked) match
+      case MoveResult.NoPiece =>
+        notifyObservers(InvalidMoveEvent(
+          currentBoard,
+          currentHistory,
+          currentTurn,
+          "No piece on that square."
+        ))
+      case MoveResult.WrongColor =>
+        notifyObservers(InvalidMoveEvent(
+          currentBoard,
+          currentHistory,
+          currentTurn,
+          "That is not your piece."
+        ))
+      case MoveResult.IllegalMove =>
+        notifyObservers(InvalidMoveEvent(
+          currentBoard,
+          currentHistory,
+          currentTurn,
+          "Illegal move."
+        ))
+

modules/core/src/main/scala/de/nowchess/chess/observer/Observer.scala

@@ -0,0 +1,87 @@
+package de.nowchess.chess.observer
+
+import de.nowchess.api.board.{Board, Color}
+import de.nowchess.chess.logic.GameHistory
+
+/** Base trait for all game state events.
+ *  Events are immutable snapshots of game state changes.
+ */
+sealed trait GameEvent:
+  def board: Board
+  def history: GameHistory
+  def turn: Color
+
+/** Fired when a move is successfully executed. */
+case class MoveExecutedEvent(
+  board: Board,
+  history: GameHistory,
+  turn: Color,
+  fromSquare: String,
+  toSquare: String,
+  capturedPiece: Option[String]
+) extends GameEvent
+
+/** Fired when the current player is in check. */
+case class CheckDetectedEvent(
+  board: Board,
+  history: GameHistory,
+  turn: Color
+) extends GameEvent
+
+/** Fired when the game reaches checkmate. */
+case class CheckmateEvent(
+  board: Board,
+  history: GameHistory,
+  turn: Color,
+  winner: Color
+) extends GameEvent
+
+/** Fired when the game reaches stalemate. */
+case class StalemateEvent(
+  board: Board,
+  history: GameHistory,
+  turn: Color
+) extends GameEvent
+
+/** Fired when a move is invalid. */
+case class InvalidMoveEvent(
+  board: Board,
+  history: GameHistory,
+  turn: Color,
+  reason: String
+) extends GameEvent
+
+/** Fired when the board is reset. */
+case class BoardResetEvent(
+  board: Board,
+  history: GameHistory,
+  turn: Color
+) extends GameEvent
+
+/** Observer trait: implement to receive game state updates. */
+trait Observer:
+  def onGameEvent(event: GameEvent): Unit
+
+/** Observable trait: manages observers and notifies them of events. */
+trait Observable:
+  private val observers = scala.collection.mutable.Set[Observer]()
+
+  /** Register an observer to receive game events. */
+  def subscribe(observer: Observer): Unit = synchronized {
+    observers += observer
+  }
+
+  /** Unregister an observer. */
+  def unsubscribe(observer: Observer): Unit = synchronized {
+    observers -= observer
+  }
+
+  /** Notify all observers of a game event. */
+  protected def notifyObservers(event: GameEvent): Unit = synchronized {
+    observers.foreach(_.onGameEvent(event))
+  }
+
+  /** Return current list of observers (for testing). */
+  def observerCount: Int = synchronized {
+    observers.size
+  }