private ChessBoardModel Starting(GameEntity gameEntity)
        {
            var result = new ChessBoardModel()
            {
                State         = (GameStateModel)(int)(gameEntity?.State ?? GameState.Waiting),
                PlayerOneId   = gameEntity?.PlayerOne?.Id,
                PlayerOneName = gameEntity?.PlayerOne?.Email,
                PlayerTwoId   = gameEntity?.PlayerTwo?.Id,
                PlayerTwoName = gameEntity?.PlayerTwo?.Email,
                Started       = DateTime.Now,
            };

            var pawns = fun((Func <int, int> col, Func <int, int> row, Player p) =>
                            Range(0, 8).Select(x => (new Position(row(1), col(x)), new Models.Chess.Pawn(p) as BasePawn))
                            .Concat(List <(Position, BasePawn)>(
                                        (new Position(row(0), col(0)), new Rook(p)),
                                        (new Position(row(0), col(1)), new Knight(p)),
                                        (new Position(row(0), col(2)), new Bishop(p)),
                                        (new Position(row(0), col(3)), new King(p)),
                                        (new Position(row(0), col(4)), new Queen(p)),
                                        (new Position(row(0), col(5)), new Bishop(p)),
                                        (new Position(row(0), col(6)), new Knight(p)),
                                        (new Position(row(0), col(7)), new Rook(p))
                                        )
                                    )
                            );

            var startingPawns = pawns(x => x, x => x, Player.One).Concat(pawns(x => x, x => 7 - x, Player.Two));

            result.Board = startingPawns.ToDictionary(x => x.Item1, x => x.Item2);
            return(result);
        }
        private static ChessBoardModel UpdatePosition(ChessBoardModel board, MoveJsonEntity item)
        {
            if (item.To == null || item.From == null || item.Player == (Data.Player) 7)
            {
                return(board);
            }
            var p = new Position()
            {
                Column = item.From.Column,
                Row    = item.From.Row
            };
            var pTarget = new Position
            {
                Column = item.To.Column,
                Row    = item.To.Row
            };
            var toChange = board.Board[p];
            //if (board.LastMove != default && (int)toChange.player != (int)item.Player)
            //{
            //    throw new Exception("Cannot change non player pawn");
            //}
            var dict = new Dictionary <Position, BasePawn>(board.Board);

            dict.Remove(p);
            dict[pTarget] = toChange;
            board         = new ChessBoardModel()
            {
                State         = board.State,
                PlayerOneId   = board.PlayerOneId,
                PlayerOneName = board.PlayerOneName,
                PlayerTwoId   = board.PlayerTwoId,
                PlayerTwoName = board.PlayerTwoName,
                LastMove      = DateTime.Now,
                Started       = board.Started,
                Board         = dict,
                CurrentPlayer = (Player)(int)(item?.Player ?? Data.Player.Two) == Player.One ? Player.Two : Player.One
            };
            return(board);
        }