static void Main(string[] args)
        {
            int maxX = 55;
            int maxY = 60;

            wallAry = new bool[maxX][];
            int[][] wallAryInts = new int[maxX][];
            for (int i = 0; i < maxX; i++)
            {
                wallAry[i]     = new bool[maxY];
                wallAryInts[i] = new int[maxY];
                for (int j = 0; j < maxY; j++)
                {
                    wallAry[i][j]     = GenerateSpace(i, j).boolRep;
                    wallAryInts[i][j] = GenerateSpace(i, j).intRep;
                }
            }

            visited      = new List <CubeNode>();
            nodesToVisit = new Queue <CubeNode>();
            PrintScreen(wallAry, maxX, maxY, targetX, targetY);
            CubeNode cn = new CubeNode()
            {
                X = 1,
                Y = 1
            };

            visited.Add(cn);
            BuildAdjacencies(cn);

            WalkNodes();
            //WalkNodesMax(50);
            //bool[] row = GenerateRow(5, 0);
            //wallAry[0] = GenerateSpace(33, 0);

            var nodesV = visited.Count(n => n.Depth <= 50);

            Console.WriteLine("Max nodes @ {0}: {1}", 50, nodesV);
            Console.ReadLine();
        }
Beispiel #2
0
 public CubeNode AddChild(CubeNode child)
 {
     this.Children.Enqueue(child);
     child.Parent = this;
     return(child);
 }
Beispiel #3
0
 public CubeNode(CubeNode parent)
 {
     this.Parent   = parent;
     this.Children = new Queue <CubeNode>();
 }
        //static void WalkNodesMax(int maxDepth)
        //{
        //    while (nodesToVisit.Count > 0)
        //    {
        //        var node = nodesToVisit.Dequeue();
        //        if (node.Depth >= maxDepth)
        //        {
        //            Console.WriteLine("Hit Max Depth. {0} unique nodes", visited.Count);
        //            return;
        //        }
        //        Console.WriteLine("Visiting Node: {0},{1}", node.X, node.Y);
        //        if (node.X == targetX && node.Y == targetY)
        //        {
        //            Console.WriteLine("Found Exit Node.  Depth: {0}", node.Depth);
        //            return;
        //        }

        //        BuildAdjacencies(node);
        //    }

        //}

        static void BuildAdjacencies(CubeNode node)
        {
            // North
            if (node.Y > 0 && !wallAry[node.X][node.Y - 1])
            {
                var newNode = new CubeNode()
                {
                    X = node.X, Y = node.Y - 1
                };
                if (!visited.Any(n => n.X == newNode.X && n.Y == newNode.Y) && !(newNode.X == node.X && newNode.Y == node.Y))
                {
                    node.AddChild(newNode);
                    visited.Add(newNode);
                    nodesToVisit.Enqueue(newNode);
                }
            }

            // South
            if (!wallAry[node.X][node.Y + 1])
            {
                var newNode = new CubeNode()
                {
                    X = node.X, Y = node.Y + 1
                };
                if (!visited.Any(n => n.X == newNode.X && n.Y == newNode.Y) && !(newNode.X == node.X && newNode.Y == node.Y))
                {
                    node.AddChild(newNode);
                    visited.Add(newNode);
                    nodesToVisit.Enqueue(newNode);
                }
            }

            // East
            if (!wallAry[node.X + 1][node.Y])
            {
                var newNode = new CubeNode()
                {
                    X = node.X + 1, Y = node.Y
                };
                if (!visited.Any(n => n.X == newNode.X && n.Y == newNode.Y) && !(newNode.X == node.X && newNode.Y == node.Y))
                {
                    node.AddChild(newNode);
                    visited.Add(newNode);
                    nodesToVisit.Enqueue(newNode);
                }
            }

            // West
            if (node.X > 0 && !wallAry[node.X - 1][node.Y])
            {
                var newNode = new CubeNode()
                {
                    X = node.X - 1, Y = node.Y
                };
                if (!visited.Any(n => n.X == newNode.X && n.Y == newNode.Y) && !(newNode.X == node.X && newNode.Y == node.Y))
                {
                    node.AddChild(newNode);
                    visited.Add(newNode);
                    nodesToVisit.Enqueue(newNode);
                }
            }
        }