Beispiel #1
0
        public void DoStuff()
        {
            var go = gameObject.OwnerOption == OwnerDefaultOption.UseOwner ? Owner : gameObject.GameObject.Value;

            g.root           = go.transform;      // set the root so the scan will turn it into nodes
            g.maxDistance    = maxDistance.Value; // set max distance for connection
            g.initialPenalty = (uint)cost.Value;
            g.name           = name.Value;
            AstarPathExtensions.ScanGraph(g);              // turn the gameObjects into ndoes.

            Nodes.Value = FsmConverter.SetNodes(FsmConverter.NodeListToArray(g.nodes));
            AstarPath.active.FloodFill();
            return;
        }
        public void DoStuff()
        {
            var doo = FsmConverter.GetPath(InputPath);

            doo.duration         = duration.Value;
            doo.heuristicScale   = heuristicScale.Value;
            doo.enabledTags      = enabledTags.Value;
            doo.radius           = radius.Value;
            doo.pathID           = (ushort)pathID.Value;
            doo.searchedNodes    = searchedNodes.Value;
            doo.searchIterations = searchIterations.Value;
            doo.speed            = speed.Value;
            doo.turnRadius       = turnRadius.Value;
            doo.recycled         = recycled.Value;
            nnConstraint.Value   = FsmConverter.SetNNConstraint(doo.nnConstraint);
            nodes.Value          = FsmConverter.SetNodes(doo.path);
            runData.Value        = FsmConverter.SetNodeRunData(doo.runData);
        }
        public void DoStuff()
        {
            var go = graph.Value as FsmNavGraph;

            if (go.Value == null)
            {
                Finish();
                return;
            }

            g = FsmConverter.GetNavGraph(graph);

            guid.Value           = g.guid.ToString();
            drawGizmos.Value     = g.drawGizmos;
            infoScreenOpen.Value = g.infoScreenOpen;
            initialPenalty.Value = (int)g.initialPenalty;
            name.Value           = g.name;

            nodes.Value = FsmConverter.SetNodes(FsmConverter.NodeListToArray(g.nodes)) as FsmNodes;              // everywhere else it's saved as a generic list, only here it is an array, so it needs extra conversion
            open.Value  = g.open;

            if (graphType == GraphType.pointGraph && g as PointGraph != null)
            {
                autoLinkNodes.Value      = (g as PointGraph).autoLinkNodes;
                limits.Value             = (g as PointGraph).limits;
                mask.Value               = (g as PointGraph).mask;
                maxDistance.Value        = (g as PointGraph).maxDistance;
                raycast.Value            = (g as PointGraph).raycast;
                recursive.Value          = (g as PointGraph).recursive;
                root.Value               = (g as PointGraph).root.gameObject;
                searchTag.Value          = (g as PointGraph).searchTag;
                thickRaycast.Value       = (g as PointGraph).thickRaycast;
                thickRaycastRadius.Value = (g as PointGraph).thickRaycastRadius;
            }

            if (graphType == GraphType.gridGraph && g as GridGraph != null)
            {
                getNearestForceOverlap.Value = (g as GridGraph).getNearestForceOverlap;
                scans.Value = (g as GridGraph).scans;
                size.Value  = (g as GridGraph).size;
            }
        }
        public void DoStuff()
        {
            var go = gameObject.OwnerOption == OwnerDefaultOption.UseOwner ? Owner : gameObject.GameObject.Value;

            g.root           = go.transform; // set the root so the scan will turn it into nodes
            g.maxDistance    = -1;           // no autoconnect
            g.initialPenalty = (uint)cost.Value;
            g.name           = name.Value;
            AstarPathExtensions.ScanGraph(g);              // turn the gameObjects into ndoes.

            if (width.Value <= 1)
            {
                for (var i = 1; i < g.nodes.Length; i++)
                {
                    // connect the node with the previously created node
                    g.nodes[i].AddConnection(g.nodes[i - 1], cost.Value);
                    g.nodes[i - 1].AddConnection(g.nodes[i], cost.Value);
                }

                if (connectStart.Value || connectEnd.Value)
                {
                    // You would want to use an NNConstraint to ignore this graph when searching (graphMask)
                    // Since it currently will find g.nodes[0] when searching
                    nnc = NNConstraint.Default;
                    var nncSave = nnc.graphMask;
                    var index   = AstarPath.active.astarData.GetGraphIndex(g);
                    nnc.graphMask = ~(1 << index);

                    if (connectStart.Value)
                    {
                        connectEm(0);
                    }
                    if (connectEnd.Value)
                    {
                        connectEm(g.nodes.Length - 1);
                    }
                    nnc.graphMask = nncSave;
                }
            }
            else
            {
                for (var i = 0; i < g.nodes.Length; i++)
                {
                    // connect the node with the previously created node
                    //g.nodes[i].AddConnection(g.nodes[i-1], cost.Value);
                    //g.nodes[i-1].AddConnection(g.nodes[i], cost.Value);
                    //if(i + width.Value <= g.nodes.Length)
                    //{
                    //connect the node with the next node in line
                    //g.nodes[i-1].AddConnection(g.nodes[i-1+width.Value], cost.Value);
                    //g.nodes[i-1+width.Value].AddConnection(g.nodes[i-1], cost.Value);
                    //}

                    // there are 3 scenarios: Either a node is in the middle or at either of the ends of the row.
                    if (i % width.Value == width.Value - 1)                     //2
                    {
                        if (i + width.Value < g.nodes.Length)
                        {
                            g.nodes[i].AddConnection(g.nodes[i + width.Value], cost.Value);
                            g.nodes[i + width.Value].AddConnection(g.nodes[i], cost.Value);
                        }

                        if (i + width.Value - 1 < g.nodes.Length)
                        {
                            g.nodes[i].AddConnection(g.nodes[i + width.Value - 1], cost.Value);
                            g.nodes[i + width.Value - 1].AddConnection(g.nodes[i], cost.Value);
                        }
                    }
                    else if (i == 0 || 0 == i % width.Value)                 //1 // if i is 0 or a multiple of width
                    {
                        if (i + width.Value < g.nodes.Length)
                        {
                            g.nodes[i].AddConnection(g.nodes[i + width.Value], cost.Value);
                            g.nodes[i + width.Value].AddConnection(g.nodes[i], cost.Value);
                        }
                        if (i + 1 < g.nodes.Length)
                        {
                            g.nodes[i].AddConnection(g.nodes[i + 1], cost.Value);
                            g.nodes[i + 1].AddConnection(g.nodes[i], cost.Value);
                        }
                        if (i + width.Value + 1 < g.nodes.Length)
                        {
                            g.nodes[i].AddConnection(g.nodes[i + width.Value + 1], cost.Value);
                            g.nodes[i + width.Value + 1].AddConnection(g.nodes[i], cost.Value);
                        }
                    }
                    else                     //3
                    {
                        if (i + width.Value < g.nodes.Length)
                        {
                            g.nodes[i].AddConnection(g.nodes[i + width.Value], cost.Value);
                            g.nodes[i + width.Value].AddConnection(g.nodes[i], cost.Value);
                        }

                        if (i + 1 < g.nodes.Length)
                        {
                            g.nodes[i].AddConnection(g.nodes[i + 1], cost.Value);
                            g.nodes[i + 1].AddConnection(g.nodes[i], cost.Value);
                        }

                        if (i + width.Value + 1 < g.nodes.Length)
                        {
                            g.nodes[i].AddConnection(g.nodes[i + width.Value + 1], cost.Value);
                            g.nodes[i + width.Value + 1].AddConnection(g.nodes[i], cost.Value);
                        }

                        if (i + width.Value - 1 < g.nodes.Length)
                        {
                            g.nodes[i].AddConnection(g.nodes[i + width.Value - 1], cost.Value);
                            g.nodes[i + width.Value - 1].AddConnection(g.nodes[i], cost.Value);
                        }
                    }
                }

                if (connectStart.Value || connectEnd.Value)
                {
                    // You would want to use an NNConstraint to ignore this graph when searching (graphMask)
                    // Since it currently will find g.nodes[0] when searching
                    nnc = NNConstraint.Default;
                    var nncSave = nnc.graphMask;
                    var index   = AstarPath.active.astarData.GetGraphIndex(g);
                    nnc.graphMask = ~(1 << index);

                    if (connectStart.Value)
                    {
                        connectEm(0);
                    }
                    if (connectEnd.Value)
                    {
                        connectEm(g.nodes.Length - width.Value);
                    }

                    nnc.graphMask = nncSave;
                }
            }

            Nodes.Value = FsmConverter.SetNodes(FsmConverter.NodeListToArray(g.nodes));

            //Required since the graph connections have been updated
            AstarPath.active.FloodFill();

            //g.AddChildren(Count, go.transform);
            return;
        }