예제 #1
0
        public void GeneratePreFilledArray_CrossCorners(int width, int height, Point2[] blockedNodes)
        {
            var factory       = new DefinitionNodeGridFactory();
            var collisionMask = new NodeGridCollisionMask(PathfindaxCollisionCategory.Cat1, width, height);

            foreach (var blockedNode in blockedNodes)
            {
                collisionMask.Layers[0].CollisionDirections[blockedNode.X, blockedNode.Y] = CollisionDirection.Solid;
            }
            var nodeGrid = factory.GeneratePreFilledArray(GenerateNodeGridConnections.All, collisionMask, true);

            Assert.AreEqual(width, nodeGrid.Width);
            Assert.AreEqual(height, nodeGrid.Height);

            foreach (var point in blockedNodes)
            {
                var index = nodeGrid.ToIndex(point.X, point.Y);
                foreach (var connection in nodeGrid.Array[index].Connections)
                {
                    Assert.AreEqual(PathfindaxCollisionCategory.Cat1, connection.CollisionCategory);
                    var connectionToThis = nodeGrid.Array[connection.To].Connections.First(x => x.To == index);
                    Assert.AreEqual(PathfindaxCollisionCategory.Cat1, connectionToThis.CollisionCategory);
                }
            }
        }
예제 #2
0
        public void GeneratePreFilledArray(int width, int height, Point2[] blockedNodes)
        {
            var factory       = new DefinitionNodeGridFactory();
            var collisionMask = new NodeGridCollisionMask(PathfindaxCollisionCategory.Cat1, width, height);

            foreach (var blockedNode in blockedNodes)
            {
                collisionMask.Layers[0].CollisionDirections[blockedNode.X, blockedNode.Y] = CollisionDirection.Solid;
            }
            var nodeGrid = factory.GeneratePreFilledArray(GenerateNodeGridConnections.All, collisionMask);

            Assert.AreEqual(width, nodeGrid.Width);
            Assert.AreEqual(height, nodeGrid.Height);

            foreach (var point in blockedNodes)
            {
                var index = nodeGrid.ToIndex(point.X, point.Y);
                foreach (var connection in nodeGrid.Array[index].Connections)
                {
                    Assert.AreEqual(PathfindaxCollisionCategory.Cat1, connection.CollisionCategory);
                    var connectionToThis = nodeGrid.Array[connection.To].Connections.First(x => x.To == index);
                    Assert.AreEqual(PathfindaxCollisionCategory.Cat1, connectionToThis.CollisionCategory);
                }

                var topNodeIndex    = GetIndex(nodeGrid, point.X, point.Y + 1);
                var bottomNodeIndex = GetIndex(nodeGrid, point.X, point.Y - 1);
                var leftNodeIndex   = GetIndex(nodeGrid, point.X - 1, point.Y);
                var rightNodeIndex  = GetIndex(nodeGrid, point.X + 1, point.Y);

                Assert.IsTrue(ConnectionIsBlocked(nodeGrid, topNodeIndex, leftNodeIndex));
                Assert.IsTrue(ConnectionIsBlocked(nodeGrid, topNodeIndex, rightNodeIndex));

                Assert.IsTrue(ConnectionIsBlocked(nodeGrid, bottomNodeIndex, leftNodeIndex));
                Assert.IsTrue(ConnectionIsBlocked(nodeGrid, bottomNodeIndex, rightNodeIndex));

                Assert.IsTrue(ConnectionIsBlocked(nodeGrid, leftNodeIndex, topNodeIndex));
                Assert.IsTrue(ConnectionIsBlocked(nodeGrid, leftNodeIndex, bottomNodeIndex));

                Assert.IsTrue(ConnectionIsBlocked(nodeGrid, rightNodeIndex, topNodeIndex));
                Assert.IsTrue(ConnectionIsBlocked(nodeGrid, rightNodeIndex, bottomNodeIndex));
            }
        }
예제 #3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="tilemapColliderWithBodies"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <returns></returns>
        public NodeGridCollisionMask GetCollisionLayers(TilemapColliderWithBody[] tilemapColliderWithBodies, int width, int height)
        {
            var mask = new NodeGridCollisionMask(tilemapColliderWithBodies.Select(x => x.CollisionCategory).ToArray(), width, height);

            for (var i = 0; i < mask.Layers.Length; i++)
            {
                var currentLayer = mask.Layers[i];
                foreach (var tilemapCollisionSource in tilemapColliderWithBodies[i].TilemapCollisionSources)
                {
                    for (var y = 0; y < height; y++)
                    {
                        for (var x = 0; x < width; x++)
                        {
                            currentLayer.CollisionDirections[x, y] |= GetColShape(tilemapCollisionSource, x, y);
                        }
                    }
                }
            }
            return(mask);
        }
예제 #4
0
        private static TestCaseData GeneratePathTestCase(int width, int height, Point2 start, Point2 end, Point2[] blockedNodes = null)
        {
            var factory       = new DefinitionNodeGridFactory();
            var collisionMask = new NodeGridCollisionMask(PathfindaxCollisionCategory.Cat1, width, height);

            if (blockedNodes != null)
            {
                foreach (var blockedNode in blockedNodes)
                {
                    collisionMask.Layers[0].CollisionDirections[blockedNode.X, blockedNode.Y] = CollisionDirection.Solid;
                }
            }
            var nodeGrid = factory.GeneratePreFilledArray(GenerateNodeGridConnections.All, collisionMask, true);
            var grid     = new DefinitionNodeGrid(nodeGrid, new Vector2(1, 1));


            var description = blockedNodes != null ?
                              $"Path from {start} to {end} on a {width} by {height} grid with blocked nodes {string.Join(", ", blockedNodes)}" :
                              $"Path from {start} to {end} on a {width} by {height} grid";

            return(new TestCaseData(grid, start, end).SetName(description));
        }