C# IBoard.SeeFigureOnPosition方法代码示例

        public void RenderBoard(IBoard board)
        {
            int counter = 0;
            int startRow = (Console.BufferHeight / 2) - ((board.Size / 2) * BoardCellSymbolsCount);
            int startCol = (Console.BufferWidth / 2) - ((board.Size / 2) * BoardCellSymbolsCount);

            this.PrintBoardBorder(startRow - Renderer.BorderSize, startCol - Renderer.BorderSize, board);

            for (int row = 0; row < board.Size; row++)
            {
                for (int col = 0; col < board.Size; col++)
                {
                    int printRow = startRow + (row * BoardCellSymbolsCount);
                    int printCol = startCol + (col * BoardCellSymbolsCount);
                    ConsoleColor color = counter % 2 == 0 ? Renderer.DarkBoardCells : Renderer.LigthBoardCells;
                    var figure = board.SeeFigureOnPosition(row, col);
                    this.PrintCell(printRow, printCol, color, figure);
                    counter++;
                }

                counter++;
            }

            Console.BackgroundColor = ConsoleColor.Black;
            Console.WriteLine();
        }

        public void ValidateMove(IFigure figure, IBoard board, Move move)
        {
            var rowDistance = Math.Abs(move.From.Row - move.To.Row);
            var colDistance = Math.Abs(move.From.Col - move.To.Col);

            if (rowDistance != colDistance)
            {
                throw new InvalidOperationException(string.Format(GlobalConstants.ExceptionMessege, figure.Type));
            }

            int rowDirection = move.From.Row > move.To.Row ? -1 : 1;
            int colDirection = move.From.Col > move.To.Col ? -1 : 1;

            var row = move.From.Row;
            var col = move.From.Col;

            var endRow = move.To.Row + (rowDirection * (-1));
            var endCol = move.To.Col + (colDirection * (-1));

            while (row != endRow && col != endCol)
            {
                row += rowDirection;
                col += colDirection;

                if (board.SeeFigureOnPosition(row, col) != null)
                {
                    throw new InvalidOperationException(string.Format(GlobalConstants.ExceptionMessege, figure.Type));
                }
            }

            base.ValidateMove(figure, board, move);
        }

        private bool CheckCaslte(IFigure figure, IBoard board, Move move, FigureColor color, int row, int col, int startCheck, int endCheck)
        {
            if (figure.Color == color && move.To.Row == row && move.To.Col == col)
            {
                var rook = board.SeeFigureOnPosition(row, 0);

                if (rook.Color == color && rook.IsFirstMove && figure.IsFirstMove)
                {
                    for (int i = startCheck; i < endCheck; i++)
                    {
                        if (board.SeeFigureOnPosition(row, i) != null)
                        {
                            return false;
                        }

                    }

                    return true;
                }
            }

            return false;
        }

        private bool ValidPLayerMoves(Move move, IBoard board)
        {
            var figureToPosition = board.SeeFigureOnPosition(move.To.Row, move.To.Col);

            if (figureToPosition == null)
            {
                return this.ValidEmptyCellMoves(move, figureToPosition, board);
            }
            else if (figureToPosition.Color == this.oppositeColor)
            {
                if (move.From.Row + this.direction == move.To.Row && (move.From.Col - 1 == move.To.Col || move.From.Col + 1 == move.To.Col))
                {
                    return true;
                }
            }

            return false;
        }

        public override void ValidateMove(IFigure figure, IBoard board, Move move)
        {
            var rowDistance = Math.Abs(move.From.Row - move.To.Row);
            var colDistance = Math.Abs(move.From.Col - move.To.Col);

            if (rowDistance > 0 && colDistance > 0)
            {
                throw new InvalidOperationException(string.Format(GlobalConstants.ExceptionMessege, figure.Type));
            }

            var rowDirection = move.From.Row < move.To.Row ? 1 : -1;
            var colDirection = move.From.Col < move.To.Col ? 1 : -1;

            rowDirection = rowDistance > 0 ? rowDirection : 0;
            colDirection = colDistance > 0 ? colDirection : 0;

            var row = move.From.Row;
            var col = move.From.Col;

            var finalRow = move.To.Row;// + (rowDirection * (-1));
            var finalCol = move.To.Col;// + (colDirection * (-1));

            while (true)
            {
                row += rowDirection;
                col += colDirection;

                if (board.SeeFigureOnPosition(row, col) != null)
                {
                    throw new InvalidOperationException(string.Format(GlobalConstants.ExceptionMessege, figure.Type));
                }

                if (row == finalRow && col == finalCol)
                {
                    break;
                }
            }

            base.ValidateMove(figure, board, move);
        }

        private bool ValidEmptyCellMoves(Move move, IFigure figure, IBoard board)
        {
            if (this.startRow == move.From.Row &&
                  move.From.Col == move.To.Col &&
                  move.From.Row + (2 * this.direction) == move.To.Row &&
                  board.SeeFigureOnPosition(move.From.Row + this.direction, move.From.Col) == null)
            {
                return true;
            }

            if (this.startRow == move.From.Row &&
                    move.From.Col == move.To.Col &&
                    move.From.Row + this.direction == move.To.Row)
            {
                return true;
            }

            if (move.From.Row + this.direction == move.To.Row && move.From.Col == move.To.Col && figure == null)
            {
                return true;
            }

            return false;
        }

        private void CheckIfToPositionSafeKing(IPlayer attacker, IFigure playFigure, Move move, IBoard gameBoard, Position kingPosition, IDictionary<Position, IFigure> defenderFigures)
        {
            var toFigure = gameBoard.SeeFigureOnPosition(move.To.Row, move.To.Col);
            gameBoard.SetFigure(move.To.Row, move.To.Col, playFigure);
            gameBoard.SetFigure(move.From.Row, move.From.Col, null);
            kingPosition = this.FindKingPosition(attacker);

            if (this.CheckIfCheck(gameBoard, kingPosition, defenderFigures))
            {
                gameBoard.SetFigure(move.To.Row, move.To.Col, toFigure);
                gameBoard.SetFigure(move.From.Row, move.From.Col, playFigure);

                throw new InvalidOperationException("Under Chess Save Your King!");
            }

            gameBoard.SetFigure(move.To.Row, move.To.Col, toFigure);
            gameBoard.SetFigure(move.From.Row, move.From.Col, playFigure);
        }

 private void TakeDefenderFigure(IPlayer attacker, IPlayer defender, Move move, IBoard gameBoard)
 {
     var figure = gameBoard.SeeFigureOnPosition(move.To.Row, move.To.Col);
     if (figure != null)
     {
         attacker.TakeFigure(move.To, figure, defender);
     }
 }