public static void Pathfind(ActionSet actionSet, PathfinderInfo info, Element pathResult, Element target, Element destination)
 {
     actionSet.AddAction(info.Path.SetVariable(
                             Element.Part <V_Append>(pathResult, destination),
                             target
                             ));
 }
        protected override MethodResult Get(PathfinderInfo info)
        {
            Element player = (Element)Parameters[0];

            return(new MethodResult(ArrayBuilder <Element> .Build(
                                        info.Path.SetVariable(new V_EmptyArray(), player)
                                        ), null));
        }
 public static Element Get(PathfinderInfo info, Element player)
 {
     return(new V_Compare(
                Element.Part <V_CountOf>(info.Path.GetVariable(player)),
                Operators.GreaterThan,
                new V_Number(0)
                ));
 }
        override protected MethodResult Get(PathfinderInfo info)
        {
            Element player = (Element)Parameters[0];

            TranslateContext.Actions.AddRange(ArrayBuilder <Element> .Build(
                                                  Element.Part <A_Teleport>(player, info.NextPosition(player))
                                                  ));
            return(new MethodResult(null, null));
        }
        protected override MethodResult Get()
        {
            if (TranslateContext.ParserData.PathfinderInfo == null)
            {
                TranslateContext.ParserData.PathfinderInfo = new PathfinderInfo(TranslateContext.ParserData);
            }
            PathfinderInfo info = TranslateContext.ParserData.PathfinderInfo;

            return(Get(info));
        }
        override protected MethodResult Get(PathfinderInfo info)
        {
            Element leniency = 2;

            Element player            = (Element)Parameters[0];
            Element scalar            = (Element)Parameters[1];
            Element defaultSpeed      = 5.5;
            Element nodeDistance      = info.DistanceToNext.GetVariable(player);
            Element timeSinceLastNode = new V_TotalTimeElapsed() - info.LastUpdate.GetVariable(player);

            Element isStuck = new V_Compare(
                nodeDistance - ((defaultSpeed * scalar * timeSinceLastNode) / leniency),
                Operators.LessThanOrEqual,
                0
                );

            isStuck = Element.Part <V_And>(IsPathfinding.Get(info, player), isStuck);
            return(new MethodResult(null, isStuck));
        }
        public override IWorkshopTree Get(ActionSet actionSet, IWorkshopTree[] parameterValues)
        {
            PathfinderInfo info = actionSet.Translate.DeltinScript.SetupPathfinder();

            Element leniency = 2;

            Element player            = (Element)parameterValues[0];
            Element scalar            = (Element)parameterValues[1];
            Element defaultSpeed      = 5.5;
            Element nodeDistance      = (Element)info.DistanceToNext.GetVariable(player);
            Element timeSinceLastNode = new V_TotalTimeElapsed() - (Element)info.LastUpdate.GetVariable(player);

            Element isStuck = new V_Compare(
                nodeDistance - ((defaultSpeed * scalar * timeSinceLastNode) / leniency),
                Operators.LessThanOrEqual,
                new V_Number(0)
                );

            return(Element.Part <V_And>(IsPathfinding.Get(info, player), isStuck));
        }
        override protected MethodResult Get(PathfinderInfo info)
        {
            if (((VarRef)Parameters[1]).Var is PathMapVar == false)
            {
                throw SyntaxErrorException.InvalidVarRefType(((VarRef)Parameters[1]).Var.Name, VarType.PathMap, ParameterLocations[1]);
            }

            Element    player  = (Element)Parameters[0];
            PathMapVar pathmap = (PathMapVar)((VarRef)Parameters[1]).Var;

            IndexedVar destination = IndexedVar.AssignInternalVarExt(TranslateContext.VarCollection, Scope, "Destination", TranslateContext.IsGlobal);

            TranslateContext.Actions.AddRange(destination.SetVariable((Element)Parameters[2]));

            DijkstraNormal algorithm = new DijkstraNormal(TranslateContext, pathmap, Element.Part <V_PositionOf>(player), destination.GetVariable());

            algorithm.Get();
            DijkstraBase.Pathfind(TranslateContext, info, algorithm.finalPath.GetVariable(), player, destination.GetVariable());
            return(new MethodResult(null, null));
        }
        override protected MethodResult Get(PathfinderInfo info)
        {
            Element player = (Element)Parameters[0];

            Element isPathfinding = IsPathfinding.Get(info, player);

            Element isSafe = Element.Part <V_Or>(
                Element.Part <V_Not>(isPathfinding),
                Element.Part <V_IsTrueForAny>(
                    info.Path.GetVariable(player),
                    new V_Compare(
                        Element.Part <V_DistanceBetween>(Element.Part <V_PositionOf>(player), new V_ArrayElement()),
                        Operators.LessThanOrEqual,
                        PathfinderInfo.MoveToNext
                        )
                    )
                );

            return(new MethodResult(null, isSafe));
        }
        protected override MethodResult Get(PathfinderInfo info)
        {
            if (((VarRef)Parameters[1]).Var is PathMapVar == false)
            {
                throw SyntaxErrorException.InvalidVarRefType(((VarRef)Parameters[1]).Var.Name, VarType.PathMap, ParameterLocations[1]);
            }

            IndexedVar players = IndexedVar.AssignInternalVarExt(TranslateContext.VarCollection, Scope, "Players", TranslateContext.IsGlobal);

            TranslateContext.Actions.AddRange(players.SetVariable((Element)Parameters[0]));

            PathMapVar pathmap = (PathMapVar)((VarRef)Parameters[1]).Var;

            IndexedVar destination = IndexedVar.AssignInternalVarExt(TranslateContext.VarCollection, Scope, "Destination", TranslateContext.IsGlobal);

            TranslateContext.Actions.AddRange(destination.SetVariable((Element)Parameters[2]));

            DijkstraMultiSource algorithm = new DijkstraMultiSource(TranslateContext, info, pathmap, players.GetVariable(), destination.GetVariable());

            algorithm.Get();
            return(new MethodResult(null, null));
        }
 public DijkstraMultiSource(ActionSet actionSet, PathfinderInfo pathfinderInfo, Element pathmapObject, Element players, Element destination) : base(actionSet, pathmapObject, destination, true)
 {
     this.pathfinderInfo = pathfinderInfo;
     this.players        = players;
 }
        override protected MethodResult Get(PathfinderInfo info)
        {
            Element player = (Element)Parameters[0];

            return(new MethodResult(null, info.NextPosition(player)));
        }
 protected abstract MethodResult Get(PathfinderInfo info);
 protected override MethodResult Get(PathfinderInfo info)
 {
     TranslateContext.Actions.AddRange(info.Path.SetVariable((Element)Parameters[1], (Element)Parameters[0]));
     return(new MethodResult(null, null));
 }