Esempio n. 1
0
        protected QuadNode <T> SearchColumn(QuadNode <T> root, QuadNode <T> node)
        {
            if (root == null)
            {
                return(null);
            }

            if (root == node)
            {
                return(root);
            }
            else
            {
                return(SearchColumn(root.Bottom, node));
            }
        }
Esempio n. 2
0
        public bool AddNodeToBottom(QuadNode <T> node, int column)
        {
            int newNodeHeight = GetColumnHeight(column);

            //add node to node above
            if (newNodeHeight != 0)
            {
                QuadNode <T> aboveNode = GetTheMostBottomNode(column);
                if (aboveNode != null)
                {
                    aboveNode.Bottom = node;
                    node.Top         = aboveNode;
                }
            }
            else
            {
                _columnsRoots[column] = node;
            }


            //add node to left column
            if (column > 0)
            {
                QuadNode <T> leftNode = SearchColumn(_columnsRoots[column - 1], newNodeHeight);

                if (leftNode != null)
                {
                    leftNode.Right = node;
                    node.Left      = leftNode;
                }
            }

            //add node to right column
            if (column < NumberOfColumns - 1)
            {
                QuadNode <T> rightNode = SearchColumn(_columnsRoots[column + 1], newNodeHeight);

                if (rightNode != null)
                {
                    rightNode.Left = node;
                    node.Right     = rightNode;
                }
            }

            return(true);
        }
Esempio n. 3
0
        public Neighbours IsAdjacentToNode(QuadNode <T> node)
        {
            if (Top != null && Top == node)
            {
                return(Neighbours.Top);
            }
            if (Left != null && Left == node)
            {
                return(Neighbours.Left);
            }
            if (Bottom != null && Bottom == node)
            {
                return(Neighbours.Bottom);
            }
            if (Right != null && Right == node)
            {
                return(Neighbours.Right);
            }

            return(Neighbours.None);
        }
Esempio n. 4
0
        /// <summary>
        /// Switchs the position of the node with a neighbouring node. Has in consideration the references of the neigbour node neighbours.
        /// </summary>
        /// <param name="neighbour">The relative position of the node we want to switch places with.</param>
        /// <returns>Returns <see langword="false"/> if the neigbour node is null.</returns>
        public bool SwitchNodePosition(Neighbours neighbour)
        {
            switch (neighbour)
            {
            case Neighbours.Top:

                if (Top == null)
                {
                    return(false);
                }

                QuadNode <T> temporary  = Top.MemberwiseClone() as QuadNode <T>;
                QuadNode <T> substitute = Top;

                ////assign nodes to the neigbour nodes of the involved pieces
                if (substitute.Left != null)
                {
                    substitute.Left.Right = this;
                }
                if (substitute.Right != null)
                {
                    substitute.Right.Left = this;
                }
                if (substitute.Top != null)
                {
                    substitute.Top.Bottom = this;
                }

                if (this.Left != null)
                {
                    this.Left.Right = substitute;
                }
                if (this.Bottom != null)
                {
                    this.Bottom.Top = substitute;
                }
                if (this.Right != null)
                {
                    this.Right.Left = substitute;
                }

                ////---------------------------------------

                ////assign nodes of the involved pieces
                substitute.Left   = this.Left;
                substitute.Top    = this;
                substitute.Bottom = this.Bottom;
                substitute.Right  = this.Right;

                this.Top    = temporary.Top;
                this.Left   = temporary.Left;
                this.Right  = temporary.Right;
                this.Bottom = substitute;

                return(true);

            case Neighbours.Left:

                if (this.Left == null)
                {
                    return(false);
                }

                temporary  = this.Left.MemberwiseClone() as QuadNode <T>;
                substitute = this.Left;

                //deal with neigbors of the involved pieces
                if (substitute.Left != null)
                {
                    substitute.Left.Right = this;
                }
                if (substitute.Top != null)
                {
                    substitute.Top.Bottom = this;
                }
                if (substitute.Bottom != null)
                {
                    substitute.Bottom.Top = this;
                }

                if (this.Top != null)
                {
                    this.Top.Bottom = substitute;
                }
                if (this.Right != null)
                {
                    this.Right.Left = substitute;
                }
                if (this.Bottom != null)
                {
                    this.Bottom.Top = substitute;
                }


                //assign end nodes of the involved pieces
                substitute.Left   = this;
                substitute.Top    = this.Top;
                substitute.Bottom = this.Bottom;
                substitute.Right  = this.Right;

                this.Top    = temporary.Top;
                this.Left   = temporary.Left;
                this.Bottom = temporary.Bottom;
                this.Right  = substitute;

                return(true);

            case Neighbours.Bottom:

                if (this.Bottom == null)
                {
                    return(false);
                }

                temporary  = this.Bottom.MemberwiseClone() as QuadNode <T>;
                substitute = this.Bottom;

                //deal with neigbors of the involved pieces
                if (substitute.Left != null)
                {
                    substitute.Left.Right = this;
                }
                if (substitute.Bottom != null)
                {
                    substitute.Bottom.Top = this;
                }
                if (substitute.Right != null)
                {
                    substitute.Right.Left = this;
                }

                if (this.Top != null)
                {
                    this.Top.Bottom = substitute;
                }
                if (this.Left != null)
                {
                    this.Left.Right = substitute;
                }
                if (this.Right != null)
                {
                    this.Right.Left = substitute;
                }


                //assing end nodes of the involved pieces
                this.Bottom.Bottom = this;
                substitute.Left    = this.Left;
                substitute.Top     = this.Top;
                substitute.Right   = this.Right;

                this.Top    = substitute;
                this.Left   = temporary.Left;
                this.Bottom = temporary.Bottom;
                this.Right  = temporary.Right;

                return(true);

            case Neighbours.Right:

                if (this.Right == null)
                {
                    return(false);
                }

                temporary  = this.Right.MemberwiseClone() as QuadNode <T>;
                substitute = this.Right;

                //assign end nodes of the neighbour nodes of the involved pieces
                if (substitute.Top != null)
                {
                    substitute.Top.Bottom = this;
                }
                if (substitute.Right != null)
                {
                    substitute.Right.Left = this;
                }
                if (substitute.Bottom != null)
                {
                    substitute.Bottom.Top = this;
                }

                if (this.Top != null)
                {
                    this.Top.Bottom = substitute;
                }
                if (this.Left != null)
                {
                    this.Left.Right = substitute;
                }
                if (this.Bottom != null)
                {
                    this.Bottom.Top = substitute;
                }


                //assign end nodes of the involved pieces
                substitute.Right  = this;
                substitute.Left   = this.Left;
                substitute.Bottom = this.Bottom;
                substitute.Top    = this.Top;

                this.Top    = temporary.Top;
                this.Left   = substitute;
                this.Bottom = temporary.Bottom;
                this.Right  = temporary.Right;

                return(true);


            default:
                break;
            }

            return(false);
        }
Esempio n. 5
0
        /// <summary>
        /// Recursive function that looks for a path from a root node to an endNode passing through objects of the same type.
        /// </summary>
        /// <param name="root"></param>
        /// <param name="endNode"></param>
        /// <param name="history"> We add a List to dont repeat nodes.</param>
        /// <returns>Returns true if a path exists.</returns>
        public bool CanConnectThroughType(QuadNode <T> root, QuadNode <T> endNode, List <QuadNode <T> > history)
        {
            //nulll checks
            if (root.TypeID != endNode.TypeID)
            {
                return(false);
            }

            //add this node to the history list.
            history.Add(root);

            //enters the if statement if the root.Top is not null and we never checked the root.Top node
            //Is the same for the rest of the nodes (Left, Bottom, Right).
            if (root.Top != null && !history.Contains(root.Top))
            {
                if (root.Top == endNode)
                {
                    return(true);
                }
                if (CanConnectThroughType(root.Top, endNode, history))
                {
                    return(true);
                }
            }

            if (root.Left != null && !history.Contains(root.Left))
            {
                if (root.Left == endNode)
                {
                    return(true);
                }
                if (CanConnectThroughType(root.Left, endNode, history))
                {
                    return(true);
                }
            }

            if (root.Bottom != null && !history.Contains(root.Bottom))
            {
                if (root.Bottom == endNode)
                {
                    return(true);
                }
                if (CanConnectThroughType(root.Bottom, endNode, history))
                {
                    return(true);
                }
            }

            if (root.Right != null && !history.Contains(root.Right))
            {
                if (root.Right == endNode)
                {
                    return(true);
                }
                if (CanConnectThroughType(root.Right, endNode, history))
                {
                    return(true);
                }
            }

            return(false);
        }
Esempio n. 6
0
 public QuadNode <T> GetNode(QuadNode <T> node, int column)
 {
     return(SearchColumn(_columnsRoots[column], node));
 }