feat(coordinator): add Redis integration and improve configuration for game state management

modules/io/src/main/scala/de/nowchess/io/grpc/IoGrpcService.scala

@@ -39,10 +39,22 @@ class IoGrpcService extends IoServiceGrpc.IoServiceImplBase:
     )
 
   override def exportFen(req: ProtoGameContext, resp: StreamObserver[ProtoStringResult]): Unit =
-    respond(resp, ProtoStringResult.newBuilder().setValue(FenExporter.exportGameContext(IoProtoMapper.fromProtoGameContext(req))).build())
+    respond(
+      resp,
+      ProtoStringResult
+        .newBuilder()
+        .setValue(FenExporter.exportGameContext(IoProtoMapper.fromProtoGameContext(req)))
+        .build(),
+    )
 
   override def exportPgn(req: ProtoGameContext, resp: StreamObserver[ProtoStringResult]): Unit =
-    respond(resp, ProtoStringResult.newBuilder().setValue(PgnExporter.exportGameContext(IoProtoMapper.fromProtoGameContext(req))).build())
+    respond(
+      resp,
+      ProtoStringResult
+        .newBuilder()
+        .setValue(PgnExporter.exportGameContext(IoProtoMapper.fromProtoGameContext(req)))
+        .build(),
+    )
 
   private def respond[T](obs: StreamObserver[T], value: T): Unit =
     obs.onNext(value)

modules/io/src/main/scala/de/nowchess/io/grpc/IoProtoMapper.scala

@@ -1,7 +1,7 @@
 package de.nowchess.io.grpc
 
 import de.nowchess.api.board.*
-import de.nowchess.api.board.{CastlingRights as DomainCastlingRights}
+import de.nowchess.api.board.CastlingRights as DomainCastlingRights
 import de.nowchess.api.game.{DrawReason, GameContext, GameResult, WinReason}
 import de.nowchess.api.move.{Move as DomainMove, MoveType, PromotionPiece}
 import de.nowchess.io.proto.*
@@ -58,7 +58,12 @@ object IoProtoMapper:
     case _                              => MoveType.Normal(false)
 
   def toProtoMove(m: DomainMove): ProtoMove =
-    ProtoMove.newBuilder().setFrom(m.from.toString).setTo(m.to.toString).setMoveKind(toProtoMoveKind(m.moveType)).build()
+    ProtoMove
+      .newBuilder()
+      .setFrom(m.from.toString)
+      .setTo(m.to.toString)
+      .setMoveKind(toProtoMoveKind(m.moveType))
+      .build()
 
   def fromProtoMove(m: ProtoMove): Option[DomainMove] =
     for
@@ -67,16 +72,33 @@ object IoProtoMapper:
     yield DomainMove(from, to, fromProtoMoveKind(m.getMoveKind))
 
   def toProtoBoard(board: Board): java.util.List[ProtoSquarePiece] =
-    board.pieces.map { (sq, piece) =>
-      ProtoSquarePiece
-        .newBuilder()
-        .setSquare(sq.toString)
-        .setPiece(ProtoPiece.newBuilder().setColor(toProtoColor(piece.color)).setPieceType(toProtoPieceType(piece.pieceType)).build())
-        .build()
-    }.toSeq.asJava
+    board.pieces
+      .map { (sq, piece) =>
+        ProtoSquarePiece
+          .newBuilder()
+          .setSquare(sq.toString)
+          .setPiece(
+            ProtoPiece
+              .newBuilder()
+              .setColor(toProtoColor(piece.color))
+              .setPieceType(toProtoPieceType(piece.pieceType))
+              .build(),
+          )
+          .build()
+      }
+      .toSeq
+      .asJava
 
   def fromProtoBoard(pieces: java.util.List[ProtoSquarePiece]): Board =
-    Board(pieces.asScala.flatMap(sp => Square.fromAlgebraic(sp.getSquare).map(_ -> Piece(fromProtoColor(sp.getPiece.getColor), fromProtoPieceType(sp.getPiece.getPieceType)))).toMap)
+    Board(
+      pieces.asScala
+        .flatMap(sp =>
+          Square
+            .fromAlgebraic(sp.getSquare)
+            .map(_ -> Piece(fromProtoColor(sp.getPiece.getColor), fromProtoPieceType(sp.getPiece.getPieceType))),
+        )
+        .toMap,
+    )
 
   def toProtoResultKind(r: Option[GameResult]): ProtoGameResultKind = r match
     case None                                                     => ProtoGameResultKind.ONGOING
@@ -131,12 +153,13 @@ object IoProtoMapper:
   def fromProtoGameContext(p: ProtoGameContext): GameContext =
     val cr = p.getCastlingRights
     GameContext(
-      board         = fromProtoBoard(p.getBoardList),
-      turn          = fromProtoColor(p.getTurn),
-      castlingRights = DomainCastlingRights(cr.getWhiteKingSide, cr.getWhiteQueenSide, cr.getBlackKingSide, cr.getBlackQueenSide),
+      board = fromProtoBoard(p.getBoardList),
+      turn = fromProtoColor(p.getTurn),
+      castlingRights =
+        DomainCastlingRights(cr.getWhiteKingSide, cr.getWhiteQueenSide, cr.getBlackKingSide, cr.getBlackQueenSide),
       enPassantSquare = Option(p.getEnPassantSquare).filter(_.nonEmpty).flatMap(Square.fromAlgebraic),
       halfMoveClock = p.getHalfMoveClock,
-      moves         = p.getMovesList.asScala.flatMap(fromProtoMove).toList,
-      result        = fromProtoResultKind(p.getResult),
-      initialBoard  = fromProtoBoard(p.getInitialBoardList),
+      moves = p.getMovesList.asScala.flatMap(fromProtoMove).toList,
+      result = fromProtoResultKind(p.getResult),
+      initialBoard = fromProtoBoard(p.getInitialBoardList),
     )