public void TestDirectionality2()
        {
            var model = new AdjacentModel(DirectionSet.Cartesian2d);

            model.AddAdjacency(new Tile(1), new Tile(2), 1, 0, 0);
            model.SetUniformFrequency();

            var topology = new GridTopology(2, 1, false);

            var left  = Direction.XMinus;
            var right = Direction.XPlus;

            var constraint = new ConnectedConstraint
            {
                PathSpec = new EdgedPathSpec
                {
                    Exits = new Dictionary <Tile, ISet <Direction> >()
                    {
                        { new Tile(1), new[] { left, right }.ToHashSet() },
                        { new Tile(2), new[] { left, right }.ToHashSet() },
                    }
                }
            };


            var propagator = new TilePropagator(model, topology, constraints: new[] { constraint });

            propagator.Run();
        }
Beispiel #2
0
        public void Path2Setup()
        {
            var tileCount = 10;
            var topology  = new GridTopology(20, 20, false);

            var model = new AdjacentModel(DirectionSet.Cartesian2d);

            var tiles = Enumerable.Range(0, tileCount).Select(x => new Tile(x)).ToList();;

            model.AddAdjacency(tiles, tiles, Direction.XPlus);
            model.AddAdjacency(tiles, tiles, Direction.YPlus);

            model.SetUniformFrequency();
            var pathConstraint = new ConnectedConstraint {
                PathSpec = new PathSpec {
                    Tiles = tiles.Skip(1).ToHashSet()
                }
            };

            propagatorPath2 = new TilePropagator(model, topology, new TilePropagatorOptions
            {
                BackTrackDepth = -1,
                Constraints    = new[] { pathConstraint },
            });
        }
        public void TestDirectionality()
        {
            var model = new AdjacentModel(DirectionSet.Cartesian2d);

            model.AddAdjacency(new Tile(1), new Tile(2), 1, 0, 0);
            model.SetUniformFrequency();

            var topology = new GridTopology(2, 1, false);

            var up   = Direction.YPlus;
            var down = Direction.YMinus;

            var seed = Environment.TickCount;
            var r    = new Random(seed);

            Console.WriteLine("Seed {0}", seed);

            var constraint = new ConnectedConstraint
            {
                PathSpec = new EdgedPathSpec
                {
                    Exits = new Dictionary <Tile, ISet <Direction> >()
                    {
                        { new Tile(1), new[] { up, down }.ToHashSet() },
                        { new Tile(2), new[] { up, down }.ToHashSet() },
                    }
                }
            };

            var propagator = new TilePropagator(model, topology, new TilePropagatorOptions
            {
                RandomDouble = r.NextDouble,
                Constraints  = new[] { constraint }
            });

            propagator.Run();

            Assert.AreEqual(Resolution.Contradiction, propagator.Status);
        }
        public void TestConnectedConstraintWithEdged()
        {
            var a = new int[, ] {
                { 0, 0, 0, 1, 0, 0 },
                { 0, 0, 0, 1, 0, 0 },
                { 0, 0, 0, 1, 0, 0 },
                { 1, 1, 1, 1, 0, 0 },
                { 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0 }
            };

            var allDirections = DirectionSet.Cartesian2d.ToHashSet();

            var exits = new Dictionary <Tile, ISet <Direction> >()
            {
                { new Tile(1), allDirections },
            };

            var seed = Environment.TickCount;
            var r    = new Random(seed);

            Console.WriteLine("Seed {0}", seed);

            var model = OverlappingModel.Create(a, 3, false, 8);

            var constraint = new ConnectedConstraint
            {
                PathSpec = new EdgedPathSpec
                {
                    Exits         = exits,
                    RelevantCells = new[] { new Point(0, 0), new Point(9, 9) },
                }
            };

            var propagator = new TilePropagator(model, new GridTopology(10, 10, false), new TilePropagatorOptions
            {
                BackTrackDepth = -1,
                Constraints    = new[] { constraint },
                RandomDouble   = r.NextDouble
            });
            var status = propagator.Run();

            Assert.AreEqual(Resolution.Decided, status);
            var result = propagator.ToValueArray <int>().ToArray2d();

            // Write out result for debugging
            for (var y = 0; y < 10; y++)
            {
                for (var x = 0; x < 10; x++)
                {
                    Console.Write(result[x, y]);
                }
                Console.WriteLine();
            }
            // Simple flood fill algorithm to determine we have in fact got a path
            var stack   = new Stack <ValueTuple <int, int> >();
            var visited = new bool[10, 10];

            stack.Push((0, 0));
            while (stack.TryPop(out var current))
            {
                var(x, y) = current;
                if (x < 0 || x >= 10 || y < 0 || y >= 10)
                {
                    continue;
                }
                if (visited[x, y])
                {
                    continue;
                }
                visited[x, y] = true;
                if (result[x, y] == 1)
                {
                    if (x == 9 && y == 9)
                    {
                        return;
                    }
                    stack.Push((x + 1, y));
                    stack.Push((x - 1, y));
                    stack.Push((x, y + 1));
                    stack.Push((x, y - 1));
                }
            }
            Assert.Fail();
        }
Beispiel #5
0
        public void EdgedPath2Setup()
        {
            var topology = new GridTopology(15, 15, false);

            var model = new AdjacentModel(DirectionSet.Cartesian2d);

            var empty     = new Tile(" ");
            var straight1 = new Tile("║");
            var straight2 = new Tile("═");
            var corner1   = new Tile("╚");
            var corner2   = new Tile("╔");
            var corner3   = new Tile("╗");
            var corner4   = new Tile("╝");
            var fork1     = new Tile("╠");
            var fork2     = new Tile("╦");
            var fork3     = new Tile("╣");
            var fork4     = new Tile("╩");

            model.AddAdjacency(
                new[] { empty, straight1, corner3, corner4, fork3 },
                new[] { empty, straight1, corner1, corner2, fork1 },
                Direction.XPlus);

            model.AddAdjacency(
                new[] { straight2, corner1, corner2, fork1, fork2, fork4 },
                new[] { straight2, corner3, corner4, fork2, fork3, fork4 },
                Direction.XPlus);

            model.AddAdjacency(
                new[] { empty, straight2, corner1, corner4, fork4 },
                new[] { empty, straight2, corner2, corner3, fork2 },
                Direction.YPlus);

            model.AddAdjacency(
                new[] { straight1, corner2, corner3, fork1, fork2, fork3 },
                new[] { straight1, corner1, corner4, fork1, fork3, fork4 },
                Direction.YPlus);

            model.SetUniformFrequency();

            var exits = new Dictionary <Tile, ISet <Direction> >
            {
                { straight1, new [] { Direction.YMinus, Direction.YPlus }.ToHashSet() },
                { straight2, new [] { Direction.XMinus, Direction.XPlus }.ToHashSet() },
                { corner1, new [] { Direction.YMinus, Direction.XPlus }.ToHashSet() },
                { corner2, new [] { Direction.YPlus, Direction.XPlus }.ToHashSet() },
                { corner3, new [] { Direction.YPlus, Direction.XMinus }.ToHashSet() },
                { corner4, new [] { Direction.YMinus, Direction.XMinus }.ToHashSet() },
                { fork1, new [] { Direction.YMinus, Direction.XPlus, Direction.YPlus }.ToHashSet() },
                { fork2, new [] { Direction.XPlus, Direction.YPlus, Direction.XMinus }.ToHashSet() },
                { fork3, new [] { Direction.YPlus, Direction.XMinus, Direction.YMinus }.ToHashSet() },
                { fork4, new [] { Direction.XMinus, Direction.YMinus, Direction.XPlus }.ToHashSet() },
            };

            var pathConstraint = new ConnectedConstraint {
                PathSpec = new EdgedPathSpec {
                    Exits = exits
                }
            };

            propagatorEdgedPath2 = new TilePropagator(model, topology, new TilePropagatorOptions
            {
                BackTrackDepth = -1,
                Constraints    = new[] { pathConstraint },
            });
        }