Exemple #1
0
        public async Task <ChessGameState> MovePieceAsync(string gameId, string playerName, string from, string to)
        {
            var dictActiveGames = await GetActiveGameDict();

            var dictCompletedGames = await GetCompletedGameDict();

            ChessGameState newGameState;
            var            board = new Board();

            using (var tx = StateManager.CreateTransaction())
            {
                var game = await GetActiveGameAsync(tx, gameId);

                if (playerName != game.White.Name && playerName != game.Black.Name)
                {
                    throw new ArgumentException("Player not in the game.");
                }

                board.PerformMoves(game.MoveHistory);
                var fromField = ChessGameUtils.FieldFromString(from);
                var toField   = ChessGameUtils.FieldFromString(to);
                var piece     = board[fromField.Item1, fromField.Item2];
                if (!piece.MoveTo(toField.Item1, toField.Item2))
                {
                    throw new ArgumentException("Illegal move.");
                }

                var newGameInfo = new ChessGameInfo(game.GameId, game.White, game.Black, board.ToMovesString());
                if (board.IsCheckmate || board.IsDraw)
                {
                    await dictActiveGames.TryRemoveAsync(tx, gameId);

                    await dictCompletedGames.TryAddAsync(tx, gameId, newGameInfo);
                }
                else
                {
                    await dictActiveGames.TryUpdateAsync(tx, gameId, newGameInfo, game);
                }

                await tx.CommitAsync();

                newGameState = new ChessGameState(newGameInfo);
            }

            var chessSignalRClient = proxyFactory.CreateServiceProxy <IChessFabrickSignalRService>(chessSignalRUri /*, ChessFabrickUtils.GuidPartitionKey(gameId)*/);

            chessSignalRClient.PieceMovedAsync(playerName, from, to, newGameState);

            if (newGameState.GetCurrentPlayer().IsBot() && !board.IsCheckmate && !board.IsDraw)
            {
                var actor = ActorProxy.Create <IChessFabrickActor>(new ActorId(gameId), chessActorUri);
                actor.PerformMove();
            }

            return(newGameState);
        }
        public void SetPieceChars(List <char> pieceChars)
        {
            var pieces = new List <Piece>(pieceChars.Count);

            foreach (var c in pieceChars)
            {
                pieces.Add(ChessGameUtils.FromChar(c));
            }
            SetPieces(pieces);
        }
Exemple #3
0
        public async Task <List <string> > ListPieceMovesAsync(string gameId, string from)
        {
            Board board;

            using (var tx = StateManager.CreateTransaction())
            {
                board = await GetActiveGameBoardAsync(tx, gameId);
            }
            var moves     = new List <string>();
            var fromField = ChessGameUtils.FieldFromString(from);
            var piece     = board[fromField.Item1, fromField.Item2];

            foreach (var move in piece.GetPossibleMoves())
            {
                moves.Add(ChessGameUtils.FieldToString(move.Item1, move.Item2));
            }
            return(moves);
        }
Exemple #4
0
        public ChessGameState(ChessGameInfo gameInfo)
        {
            GameInfo = gameInfo;

            var board = new Board();

            board.PerformMoves(gameInfo.MoveHistory);

            var sb = new StringBuilder();

            for (int i = 0; i < Board.SIZE; ++i)
            {
                for (int j = 0; j < Board.SIZE; ++j)
                {
                    if (board[i, j] != null)
                    {
                        sb.Append(board[i, j].ToChar());
                    }
                    sb.Append(',');
                }
                sb.Remove(sb.Length - 1, 1).Append(';');
            }
            ChessBoard = sb.Remove(sb.Length - 1, 1).ToString();

            CapturedPieces = new List <char>();
            foreach (var piece in board.GetCaptured())
            {
                CapturedPieces.Add(piece.ToChar());
            }

            CheckingPieces = new List <string>();
            foreach (var piece in board.CheckingPieces)
            {
                CheckingPieces.Add(ChessGameUtils.FieldToString(piece.X, piece.Y));
            }

            IsDraw      = board.IsDraw;
            IsCheckmate = board.IsCheckmate;
            OnTurn      = board.TurnColor;
        }
Exemple #5
0
        private Tuple <string, string> GetRandomMove(Board board)
        {
            var pieces = board.GetAlive(board.TurnColor);

            while (true)
            {
                var piece = pieces[rand.Next(0, pieces.Count)];
                var x     = piece.X;
                var y     = piece.Y;
                var moves = piece.GetPossibleMoves();
                while (moves.Count > 0)
                {
                    var move = moves[rand.Next(0, moves.Count)];
                    if (piece.MoveTo(move.Item1, move.Item2))
                    {
                        return(Tuple.Create(ChessGameUtils.FieldToString(x, y), ChessGameUtils.FieldToString(move.Item1, move.Item2)));
                    }
                    moves.Remove(move);
                }
                pieces.Remove(piece);
            }
        }
        private async void FieldBox_Click(object sender, EventArgs e)
        {
            var fieldBox = sender as ChessFieldBox;
            var field    = fieldBox.Tag as Tuple <int, int>;

            showLastMove = false;

            if (selectedField == null)
            {
                selectedField = field;
                var selectedPiece = board[selectedField.Item1, selectedField.Item2];
                if (selectedPiece?.Color != playerColor || selectedPiece?.Color != gameState.OnTurn)
                {
                    selectedField = null;
                }
                if (selectedField != null)
                {
                    fieldBox.Style = ChessFieldBox.BoxStyle.Selected;
                    fieldBox.Invalidate();
                    try
                    {
                        possibleMoves = new List <Tuple <int, int> >();
                        var newPossibleMoves = new List <Tuple <int, int> >();
                        var moves            = await connection.InvokeAsync <List <string> >("GetPieceMoves", gameId,
                                                                                             ChessGameUtils.FieldToString(selectedField.Item1, selectedField.Item2)
                                                                                             );

                        foreach (var move in moves)
                        {
                            newPossibleMoves.Add(ChessGameUtils.FieldFromString(move));
                        }
                        possibleMoves = newPossibleMoves;
                    } catch (HubException ex)
                    {
                        selectedField = null;
                        possibleMoves = null;
                        Console.Error.WriteLine(ex);
                        txbMessage.Text = ex.Message;
                    }
                }
            }
            else
            {
                if (possibleMoves.Contains(field))
                {
                    try
                    {
                        gameState = await connection.InvokeAsync <ChessGameState>("MovePiece", gameId,
                                                                                  ChessGameUtils.FieldToString(selectedField.Item1, selectedField.Item2),
                                                                                  ChessGameUtils.FieldToString(field.Item1, field.Item2)
                                                                                  );
                    } catch (HubException ex)
                    {
                        Console.Error.WriteLine(ex);
                        txbMessage.Text = ex.Message;
                    }
                }
                selectedField = null;
                possibleMoves = null;
            }
            UpdateBoard();
        }
        private void RefreshViews()
        {
            if (board == null)
            {
                return;
            }

            labPlayerNames.Text = $"White: \n{gameState?.GameInfo?.White?.Name} \n\nBlack: \n{gameState?.GameInfo?.Black?.Name}";

            if (gameState == null)
            {
                btnAddBot.Visible = true;
                return;
            }

            btnAddBot.Visible = false;

            if (gameState.IsCheckmate)
            {
                panTable.Enabled = false;
                grbPlaying.Text  = "Checkmate";
                cfbPlaying.Image = PieceImageUtils.King(gameState.OnTurn.Other());
                if (playerColor != null)
                {
                    cfbPlaying.BackColor = gameState.OnTurn != playerColor ? Color.YellowGreen : Color.OrangeRed;
                }
            }
            else if (gameState.IsDraw)
            {
                panTable.Enabled     = false;
                grbPlaying.Text      = "Draw";
                cfbPlaying.Image     = Properties.Resources.king_multi;
                cfbPlaying.BackColor = Control.DefaultBackColor;
            }
            else
            {
                panTable.Enabled = true;
                grbPlaying.Text  = "On turn";
                cfbPlaying.Image = PieceImageUtils.Pawn(gameState.OnTurn);
                if (playerColor != null)
                {
                    cfbPlaying.BackColor = gameState.OnTurn == playerColor ? Color.YellowGreen : Control.DefaultBackColor;
                }
            }

            pieceListPanelBlack.SetPieceChars(gameState.CapturedPieces.Where(c => c >= 'a' && c <= 'z').ToList());
            pieceListPanelWhite.SetPieceChars(gameState.CapturedPieces.Where(c => c >= 'A' && c <= 'Z').ToList());

            for (int i = 0; i < 8; ++i)
            {
                for (int j = 0; j < 8; ++j)
                {
                    var fieldBox = fieldBoxes[i, j];
                    fieldBox.SuspendLayout();
                    fieldBox.Style = ChessFieldBox.BoxStyle.None;
                    fieldBox.Image = board[i, j]?.Image();
                }
            }

            if (gameState.CheckingPieces?.Count > 0)
            {
                var king = board.King(board.TurnColor);
                fieldBoxes[king.X, king.Y].Style = ChessFieldBox.BoxStyle.Checked;
                foreach (var piece in gameState.CheckingPieces)
                {
                    var field = ChessGameUtils.FieldFromString(piece);
                    fieldBoxes[field.Item1, field.Item2].Style = ChessFieldBox.BoxStyle.Checking;
                }
            }

            if (selectedField != null)
            {
                fieldBoxes[selectedField.Item1, selectedField.Item2].Style = ChessFieldBox.BoxStyle.Selected;
                if (possibleMoves != null)
                {
                    var selectedPiece = board[selectedField.Item1, selectedField.Item2];
                    foreach (var field in possibleMoves)
                    {
                        fieldBoxes[field.Item1, field.Item2].Style =
                            board[field.Item1, field.Item2] != null || (selectedPiece is Pawn && selectedPiece.X != field.Item1) ?
                            ChessFieldBox.BoxStyle.Attack : ChessFieldBox.BoxStyle.Move;
                    }
                }
            }

            if (board.LastMove != null)
            {
                var lastMove = board.LastMove;
                if (lastMove.ConnectedMove)
                {
                    lastMove = lastMove.LastMove;
                }
                labLastMove.Text = $"Last move:\n{ChessGameUtils.FieldToString(lastMove.FromX, lastMove.FromY)} => {ChessGameUtils.FieldToString(lastMove.ToX, lastMove.ToY)}";
                if (showLastMove)
                {
                    fieldBoxes[lastMove.FromX, lastMove.FromY].Style = ChessFieldBox.BoxStyle.MoveFrom;
                    fieldBoxes[lastMove.ToX, lastMove.ToY].Style     = lastMove.CapturedPiece != null ?
                                                                       ChessFieldBox.BoxStyle.MoveToCapture : ChessFieldBox.BoxStyle.MoveTo;
                }
            }

            foreach (var fieldBox in fieldBoxes)
            {
                fieldBox.ResumeLayout(false);
                fieldBox.Invalidate();
            }
        }