예제 #1
0
    void PathFound(NodePath path, Node lastNode)
    {
        path.AddNode(lastNode);
        IntVector2[] posiciones = path.GetPositions();

        result = new PathResult(lastNode.GetPosition(), posiciones);
    }
예제 #2
0
        public void NodePathModel_addingMultipleNodes_SumIsCorrect()
        {
            INode nodeOne = new MockNode {
                Value = 7
            };
            INode nodeTwo = new MockNode {
                Value = 4
            };

            INodePath nodePath      = new NodePath();
            var       expectedTotal = nodeOne.Value + nodeTwo.Value;

            nodePath.AddNode(nodeOne);
            nodePath.AddNode(nodeTwo);

            Assert.AreEqual(expectedTotal, nodePath.Sum);
            Assert.AreEqual(2, nodePath.PathNodes.Count);
        }
예제 #3
0
        public void NodePathModel_addingSingleNode_SumIsCorrect()
        {
            INode node = new MockNode
            {
                Value = 3
            };

            INodePath nodePath = new NodePath();

            nodePath.AddNode(node);

            Assert.AreEqual(node.Value, nodePath.Sum);
        }
예제 #4
0
    void SearchNodes(NodePath path, bool firstPath = false)
    {
        IntVector2 position = path.GetPosition();

        if (position.x < 0 || position.y < 0 || position.x >= manager.totalSize.x || position.y >= manager.totalSize.y)
        {
            return;
        }

        if (firstPath)
        {
            nodes.Add(path);
        }

        List <Node> foundNodes = new List <Node>();

        //Busca todos los nodos disponibles
        for (int i = 0; i < directions.Length; i++)
        {
            Node node = SearchPath(path.GetPosition(), directions[i]);

            if (pathFound)
            {
                PathFound(path, node);
                return;
            }

            if (node == null)
            {
                continue;
            }

            foundNodes.Add(node);
        }

        //Busca si el nodo pertenece a otro camino, y busca si ya no ha sido trazado por otro camino (De ser así pasa al siguiente).
        //Si encuentra más de un camino válido, se clona.
        //Si no encuentra un camino válido, el camino se borra.
        int validNodes   = 0;
        int invalidNodes = 0;

        foreach (Node node in foundNodes)
        {
            if (!ContainNode(node))
            {
                if (validNodes == 0)
                {
                    //Si es primer nodo valido encontrado se
                    path.AddNode(node);
                    path.AddStep();
                }
                else
                {
                    path = new NodePath(path);
                    path.OverwriteNode(node);
                    nodes.Add(path);
                }

                validNodes++;
            }
            else
            {
                invalidNodes++;
            }
        }

        //Si no ha encontrado nodo, borra el camino
        if (foundNodes.Count == 0)
        {
            nodes.Remove(path);
            return;
        }
        else if (foundNodes.Count == invalidNodes)
        {
            path.Desactivate();
        }
    }