Example #1
0
        private static void IdentifySuccessors(PathingMaster args, PathingNode activeNode)
        {
            activeNode.IsClosed = true;
            activeNode.IsOpen   = false;

            var priority = args.Priority;

            var neighbors = FindNeighbors(args, activeNode);

            foreach (var neighbor in neighbors)
            {
                int jX = 0, jY = 0;
                if (!Jump(args, neighbor.X, neighbor.Y, activeNode.X, activeNode.Y, ref jX, ref jY))
                {
                    continue;
                }

                var jumpNode = args.GetNode(jX, jY);
                if (jumpNode.IsClosed)
                {
                    continue;
                }

                var newG = activeNode.G + jumpNode.EuclideanDistance(activeNode);
                if ((jumpNode.IsOpen || jumpNode.IsClosed) && newG >= jumpNode.G)
                {
                    continue;
                }

                jumpNode.G      = newG;
                jumpNode.H      = jumpNode.HDistance(args.Target);
                jumpNode.F      = jumpNode.H + jumpNode.G;
                jumpNode.Parent = activeNode;

                if (jumpNode.IsOpen || jumpNode.IsClosed)
                {
                    priority.Update(jumpNode);
                }
                else
                {
                    priority.Add(jumpNode);
                }

                jumpNode.IsOpen   = true;
                jumpNode.IsClosed = false;
            }
        }
Example #2
0
        private static bool IdentifySuccessors(PathingMaster args, PathingNode activeNode)
        {
            var priority = args.Priority;
            var endNode  = args.Target;

            priority.Clear();
            activeNode.IsClosed = true;

            var any       = false;
            var neighbors = activeNode.GetNeighbors();

            foreach (var neighbor in neighbors)
            {
                var checkNode = args.GetNode(neighbor.X, neighbor.Y);
                if (checkNode == null)
                {
                    continue;
                }
                if (args.ValidateNodeForPath(checkNode))
                {
                    continue;
                }
                if (checkNode.IsClosed)
                {
                    continue;
                }

                //get angle, active to end
                var activeToEndAngle = activeNode.GetAngleRadian(endNode);
                //check arc
                if (activeNode.HasInArc(neighbor, activeToEndAngle, 2 * Math.PI / 3, 2.0f))
                {
                    //distance(h) + active to end angle difference from active to neighbor * 2(g) = f
                    var activeToNeighborAngle = activeNode.GetRelativeAngleRadian(neighbor, activeToEndAngle);
                    checkNode.G = Math.Abs(activeToEndAngle - activeToNeighborAngle) * 2;
                    checkNode.H = checkNode.HDistance(endNode);
                    checkNode.F = checkNode.G + checkNode.H;

                    //push to priority stack
                    priority.Add(checkNode);
                    any = true;
                }
            }

            return(any);
        }