Exemple #1
0
        internal MoveMapNode AddChild(Square square)
        {
            MoveMapNode node = new MoveMapNode(this, square);

            _children.Add(node);
            return(node);
        }
Exemple #2
0
        public MoveMap(Piece piece)
        {
            Square start = piece.Square;

            _board  = piece.Board;
            _colour = start.Occupier.Colour;
            _root   = new MoveMapNode(null, start);
            Generate();
        }
Exemple #3
0
 private void FindEdges(MoveMapNode node, IList <MoveMapNode> output)
 {
     if (node.Children.Count() == 0)
     {
         output.Add(node);
     }
     else
     {
         foreach (MoveMapNode childNode in node.Children)
         {
             FindEdges(childNode, output);
         }
     }
 }
Exemple #4
0
        public MoveMap(Board board, int row, int column)
        {
            Square start = board[row, column];

            if (start.IsEmpty)
            {
                throw new ArgumentException("Starting square must be occupied.");
            }

            _root   = new MoveMapNode(null, start);
            _board  = board;
            _colour = start.Occupier.Colour;
            Evaluate();
        }
Exemple #5
0
        private void Generate()
        {
            // depending on which player we are evaluating moves for, we need to either move up or down the board
            int rowStep = _root.Square.Occupier.Colour == PieceColour.Black ? 1 : -1;

            int row    = _root.Square.Row;
            int column = _root.Square.Column;

            TestMove(row + rowStep, column + 1, rowStep, _root);
            TestMove(row + rowStep, column - 1, rowStep, _root);

            // a crowned piece ('king') may move in the reverse direction as well
            if (_root.Square.Occupier.IsCrowned)
            {
                TestMove(row - rowStep, column + 1, -rowStep, _root);
                TestMove(row - rowStep, column - 1, -rowStep, _root);
            }

            // extract the edges (end squares) of each sequence, and remove those that end in an occupied square on the board's edge,
            // as those are not valid move targets
            // create a path from each edge which enumerates the squares covered by the move
            List <MoveMapNode> edges = new List <MoveMapNode>();

            FindEdges(_root, edges);

            List <Move> moves = new List <Move>();

            foreach (MoveMapNode edge in edges.Where(e => e.Square.IsEmpty))
            {
                Move        move = new Move(edge.Root.Square.Occupier);
                MoveMapNode node = edge;
                while (true)
                {
                    if (node == null)
                    {
                        break;
                    }

                    move.Add(node.Square.Row, node.Square.Column);
                    node = node.Parent;
                }
                moves.Add(move);
            }

            // exclude any moves that don't take pieces, if at least one does - we *must* take a piece if it's possible
            Moves = moves.Any(m => m.PiecesTaken > 0) ? moves.Where(m => m.PiecesTaken > 0) : moves;
        }
Exemple #6
0
        private void TestMove(int row, int column, int rowStep, MoveMapNode node)
        {
            if (row < 0 || column < 0 || row > 7 || column > 7)
            {
                return;                                                 // stepped out of bounds, sequence ends
            }
            Square square = _board[row, column];

            if (square.IsEmpty) // sequence ends here
            {
                node.AddChild(square);
                return;
            }
            else if (square.Occupier.Colour == _colour) // blocked by piece of own colour, not a valid sequence
            {
                return;
            }
            else // sequence *may* continue, so recurse down one level in each diagonal direction
            {
                MoveMapNode childNode = node.AddChild(square);
                TestMove(row + rowStep, column + 1, rowStep, childNode);
                TestMove(row + rowStep, column - 1, rowStep, childNode);
            }
        }
Exemple #7
0
 public MoveMapNode(MoveMapNode parent, Square square)
 {
     _parent   = parent;
     Square    = square;
     _children = new List <MoveMapNode>();
 }