protected override void PostStop()
 {
     this._cancellable.CancelIfNotNull();
     this._cancellable = null;
     this._queue       = null;
     this._map         = null;
 }
 public OldEventsourcedScheduler(int maxQueuedMessages, int operationCountPerSnapshot)
 {
     this._maxQueuedMessages         = maxQueuedMessages;
     this._operationCountPerSnapshot = operationCountPerSnapshot;
     this._queue = new GenericPriorityQueue <FutureMessageNode, DateTimeOffset>(maxQueuedMessages);
     this._map   = new Dictionary <string, FutureMessageNode>(maxQueuedMessages);
 }
Beispiel #3
0
        private void Update()
        {
            var adjacencyRule = (AdjacencyRule)_baseMap.DistanceMeasurement;
            var openSet       = new GenericPriorityQueue <PositionNode, double>(Width * Height);

            foreach (var point in _baseMap.Walkable)
            {
                var newPoint = _baseMap[point] * -Magnitude;
                _goalMap[point] = newPoint;

                openSet.Enqueue(_nodes[point], newPoint.Value);
            }
            var edgeSet   = new HashSet <Coord>();
            var closedSet = new HashSet <Coord>();

            while (openSet.Count > 0) //multiple runs are needed to deal with islands
            {
                var minNode = openSet.Dequeue();
                closedSet.Add(minNode.Position);

                foreach (var openPoint in adjacencyRule.Neighbors(minNode.Position))
                {
                    if ((!closedSet.Contains(openPoint)) && _baseMap.BaseMap[openPoint] != GoalState.Obstacle)
                    {
                        edgeSet.Add(openPoint);
                    }
                }
                while (edgeSet.Count > 0)
                {
                    foreach (var coord in edgeSet.ToArray())
                    {
                        var current = _goalMap[coord].Value;
                        foreach (var openPoint in adjacencyRule.Neighbors(coord))
                        {
                            if (closedSet.Contains(openPoint) || _baseMap.BaseMap[openPoint] == GoalState.Obstacle)
                            {
                                continue;
                            }
                            var neighborValue = _goalMap[openPoint].Value;
                            var newValue      = current + _baseMap.DistanceMeasurement.Calculate(coord, openPoint);
                            if (newValue < neighborValue)
                            {
                                _goalMap[openPoint] = newValue;
                                openSet.UpdatePriority(_nodes[openPoint], newValue);
                                edgeSet.Add(openPoint);
                            }
                        }
                        edgeSet.Remove(coord);
                        closedSet.Add(coord);
                        openSet.Remove(_nodes[coord]);
                    }
                }
            }
        }
Beispiel #4
0
        /// <summary>
        /// Constructor. Takes a goal map where in all goals are treated as threats to be avoided,
        /// and a magnitude to use (defaulting to 1.2).
        /// </summary>
        /// <param name="baseMap">The underlying goal map to use.</param>
        /// <param name="magnitude">Magnitude to multiply by during calculation.</param>
        public FleeMap(GoalMap baseMap, double magnitude = 1.2)
        {
            _baseMap   = baseMap ?? throw new ArgumentNullException(nameof(baseMap));
            Magnitude  = magnitude;
            _goalMap   = new ArrayView <double?>(baseMap.Width, baseMap.Height);
            _nodes     = new ArrayView <PositionNode>(baseMap.Width, baseMap.Height);
            _openSet   = new GenericPriorityQueue <PositionNode, double>(baseMap.Width * baseMap.Height);
            _edgeSet   = new Queue <Point>();
            _closedSet = new BitArray(baseMap.Width * baseMap.Height);
            foreach (var pos in _nodes.Positions())
            {
                _nodes[pos] = new PositionNode(pos);
            }

            _baseMap.Updated += Update;

            // Necessary to ensure the FleeMap is valid immediately after construction
            Update();
        }
 protected override void PreStart()
 {
     this._queue = new GenericPriorityQueue <FutureMessageNode, DateTimeOffset>(this._defaultQueueSize);
     this._map   = new Dictionary <string, FutureMessageNode>(this._defaultQueueSize);
 }
Beispiel #6
0
 public SimplePriorityQueue()
 {
     _queue = new GenericPriorityQueue <SimpleNode, TPriority>(INITIAL_QUEUE_SIZE);
 }
Beispiel #7
0
    private static Path shortestPath(Tile a, Tile b, Map m)
    {
        //If runtime is too high, use a hash table to store indices
        dijkstraNode[] nodes   = new dijkstraNode[moveList.Count];
        index[]        indices = new index[moveList.Count];
        for (int i = 0; i < moveList.Count; ++i)
        {
            nodes[i].found    = false;
            nodes[i].dist     = 999;
            nodes[i].previous = -1;
            indices[i]        = new index(i);
        }
        int start = moveList.IndexOf(a);
        int end   = moveList.IndexOf(b);
        //<index,weight>
        GenericPriorityQueue <index, int> queue = new GenericPriorityQueue <index, int>(moveList.Count);

        nodes[start].dist = 0;
        for (int i = 0; i < moveList.Count; i++)
        {
            if (i == start)
            {
                queue.Enqueue(indices[i], 0);
            }
            else
            {
                queue.Enqueue(indices[i], 999);
            }
        }

        index tempi;
        int   x, y, r;

        while (queue.Count != 0)
        {
            //for(int k = 0; k<queue.Count; k++) {
            tempi = queue.Dequeue();
            nodes[tempi.i].found = true;
            if (tempi.i == end)
            {
                break;
            }
            x = moveList[tempi.i].getX();
            y = moveList[tempi.i].getY();
            //ideally we shorten this; maybe do some sin/cos stuff in UserMath
            //east
            r = moveList.IndexOf(m.findTile(x + 1, y));
            if (x < m.getMapWidth() - 1 && r != -1 && !nodes[r].found)
            {
                if (!nodes[r].found && nodes[r].dist > movementCosts[moveList[r].getType()] + nodes[tempi.i].dist)
                {
                    nodes[r].dist     = movementCosts[moveList[r].getType()] + nodes[tempi.i].dist;
                    nodes[r].previous = tempi.i;
                    queue.UpdatePriority(indices[r], nodes[r].dist);
                }
            }
            //north
            r = moveList.IndexOf(m.findTile(x, y + 1));
            if (r != -1 && !nodes[r].found && y < m.getMapHeight() - 1)
            {
                if (!nodes[r].found && nodes[r].dist > movementCosts[moveList[r].getType()] + nodes[tempi.i].dist)
                {
                    nodes[r].dist     = movementCosts[moveList[r].getType()] + nodes[tempi.i].dist;
                    nodes[r].previous = tempi.i;
                    queue.UpdatePriority(indices[r], nodes[r].dist);
                }
            }
            //west
            r = moveList.IndexOf(m.findTile(x - 1, y));
            if (r != -1 && !nodes[r].found && x > 0)
            {
                if (!nodes[r].found && nodes[r].dist > movementCosts[moveList[r].getType()] + nodes[tempi.i].dist)
                {
                    nodes[r].dist     = movementCosts[moveList[r].getType()] + nodes[tempi.i].dist;
                    nodes[r].previous = tempi.i;
                    queue.UpdatePriority(indices[r], nodes[r].dist);
                }
            }
            //south
            r = moveList.IndexOf(m.findTile(x, y - 1));
            if (r != -1 && !nodes[r].found && y > 0)
            {
                if (!nodes[r].found && nodes[r].dist > movementCosts[moveList[r].getType()] + nodes[tempi.i].dist)
                {
                    nodes[r].dist     = movementCosts[moveList[r].getType()] + nodes[tempi.i].dist;
                    nodes[r].previous = tempi.i;
                    queue.UpdatePriority(indices[r], nodes[r].dist);
                }
            }
        }        //end of while-loop
        Path ret = new Path();

        if (nodes[end].previous == -1)
        {
            return(null);
        }
        for (int i = end; i != start;)
        {
            ret.insertHead(moveList[i], movementCosts[moveList[i].getType()]);
            i = nodes[i].previous;
        }
        //To impelement; high runtimes might result in reworking this algorithm
        return(ret);
    }
Beispiel #8
0
        public static List <IPathNode> FindPath(IPathNode start, IPathNode finish)
        {
            if (start == finish)
            {
                return(new List <IPathNode>());
            }

            var frontier = new GenericPriorityQueue <IPathNode, int>(1000);

            frontier.Enqueue(start, 0);
            var              cameFrom  = new Dictionary <IPathNode, IPathNode>();
            var              costSoFar = new Dictionary <IPathNode, int>();
            IPathNode        current;
            IPathNode        next;
            List <IPathNode> neighbours;
            int              newCost;
            int              priority;

            cameFrom[start]  = null;
            costSoFar[start] = 0;


            while (frontier.Count > 0)
            {
                current = frontier.Dequeue();

                if (current == finish)
                {
                    break;
                }

                neighbours = current.GetNeighbours();

                for (int i = 0; i < neighbours.Count; i++)
                {
                    next    = neighbours[i];
                    newCost = costSoFar[current] + (next == finish || next.IsWalkable ? 1 : 10000);

                    if (!costSoFar.ContainsKey(next) || newCost < costSoFar[next])
                    {
                        if (costSoFar.ContainsKey(next))
                        {
                            costSoFar[next] = newCost;
                        }
                        else
                        {
                            costSoFar.Add(next, newCost);
                        }

                        priority = newCost + finish.GetHeuristic(next);
                        if (frontier.Contains(next))
                        {
                            frontier.UpdatePriority(next, priority);
                        }
                        else
                        {
                            frontier.Enqueue(next, priority);
                        }


                        cameFrom[next] = current;
                    }
                }
            }

            var path = new List <IPathNode>();

            if (cameFrom.ContainsKey(finish))
            {
                IPathNode last = finish;
                path.Add(finish);
                while (cameFrom[last] != start)
                {
                    path.Add(cameFrom[last]);
                    last = cameFrom[last];
                }

                path.Reverse();
            }

            return(path);
        }
Beispiel #9
0
 /// <summary>
 /// Instantiate a new Priority Queue
 /// </summary>
 /// <param name="comparer">The comparison function to use to compare TPriority values</param>
 public SimplePriorityQueue(Comparison <TPriority> comparer)
 {
     _queue            = new GenericPriorityQueue <SimpleNode, TPriority>(INITIAL_QUEUE_SIZE, comparer);
     _itemToNodesCache = new Dictionary <TItem, IList <SimpleNode> >();
     _nullNodesCache   = new List <SimpleNode>();
 }
Beispiel #10
0
        /// <summary>
        /// A* search
        /// </summary>
        /// <param name="allowReverse"></param>
        /// <param name="carsToIgnore"></param>
        /// <param name="consistLength"></param>
        protected async System.Threading.Tasks.Task Astar(bool allowReverse, HashSet <string> carsToIgnore, double consistLength, List <TrackTransition> bannedTransitions)
        {
            await Await.BackgroundSyncContext();

            cameFrom  = new Dictionary <RailTrack, RailTrack>();
            costSoFar = new Dictionary <RailTrack, double>();

            //var queue = new PriorityQueue<RailTrack>();
            var queue = new GenericPriorityQueue <RailTrackNode, double>(10000);

            queue.Enqueue(new RailTrackNode(start), 0.0);

            cameFrom.Add(start, start);
            costSoFar.Add(start, 0.0);

            RailTrack current = null;


            while (queue.Count > 0)
            {
                current = queue.Dequeue().track;

                RailTrack prev = null;
                cameFrom.TryGetValue(current, out prev);

                string debug = $"ID: {current.logicTrack.ID.FullID} Prev: {prev?.logicTrack.ID.FullID}";

                List <RailTrack> neighbors = new List <RailTrack>();

                if (current.outIsConnected)
                {
                    neighbors.AddRange(current.GetAllOutBranches().Select(b => b.track));
                }

                if (current.inIsConnected)
                {
                    neighbors.AddRange(current.GetAllInBranches().Select(b => b.track));
                }
                string branches = DumpNodes(neighbors, current);
                debug += "\n" + $"all branches: {branches}";

#if DEBUG2
                Terminal.Log(debug);
#endif

                foreach (var neighbor in neighbors)
                {
                    if (bannedTransitions != null && bannedTransitions.All(t => t.track == current && t.nextTrack == neighbor))
                    {
                        Terminal.Log($"{current.logicTrack.ID.FullID}->{neighbor.logicTrack.ID.FullID} banned");
                        continue;
                    }

                    //if non start/end track is not free omit it
                    if (neighbor != start && neighbor != goal && !neighbor.logicTrack.IsFree(carsToIgnore))
                    {
                        Terminal.Log($"{neighbor.logicTrack.ID.FullID} not free");
                        continue;
                    }

                    //if we could go through junction directly (without reversing)
                    bool isDirect = current.CanGoToDirectly(prev, neighbor);

                    if (!allowReverse && !isDirect)
                    {
                        Terminal.Log($"{neighbor.logicTrack.ID.FullID} reverse needed");
                        continue;
                    }

                    // compute exact cost
                    //double newCost = costSoFar[current] + neighbor.logicTrack.length;
                    double newCost = costSoFar[current] + neighbor.logicTrack.length / neighbor.GetAverageSpeed();

                    if (!isDirect)
                    {
                        // if we can't fit consist on this track to reverse, drop this neighbor
                        if (prev != null && !current.IsDirectLengthEnough(prev, consistLength))
                        {
                            Terminal.Log($"{neighbor.logicTrack.ID.FullID} not long enough to reverse");
                            continue;
                        }

                        //add penalty when we must reverse

                        //newCost += 2.0 * consistLength + 30.0;
                    }

                    // If there's no cost assigned to the neighbor yet, or if the new
                    // cost is lower than the assigned one, add newCost for this neighbor
                    if (!costSoFar.ContainsKey(neighbor) || newCost < costSoFar[neighbor])
                    {
                        // If we're replacing the previous cost, remove it
                        if (costSoFar.ContainsKey(neighbor))
                        {
                            costSoFar.Remove(neighbor);
                            cameFrom.Remove(neighbor);
                        }

                        //Terminal.Log($"neighbor {neighbor.logicTrack.ID.FullID} update {newCost}");

                        costSoFar.Add(neighbor, newCost);
                        cameFrom.Add(neighbor, current);
                        double priority = newCost + Heuristic(neighbor, goal)
                                          / 20.0f; //convert distance to time (t = s / v)
                        queue.Enqueue(new RailTrackNode(neighbor), priority);
                    }
                }
            }

            await Await.UnitySyncContext();
        }