public static void RunExample()
{
//First, we create the priority queue.
SimplePriorityQueue<string> priorityQueue = new SimplePriorityQueue<string>();
//Now, let's add them all to the queue (in some arbitrary order)!
priorityQueue.Enqueue("4 - Joseph", 4);
priorityQueue.Enqueue("2 - Tyler", 0); //Note: Priority = 0 right now!
priorityQueue.Enqueue("1 - Jason", 1);
priorityQueue.Enqueue("4 - Ryan", 4);
priorityQueue.Enqueue("3 - Valerie", 3);
//Change one of the string's priority to 2. Since this string is already in the priority queue, we call UpdatePriority() to do this
priorityQueue.UpdatePriority("2 - Tyler", 2);
//Finally, we'll dequeue all the strings and print them out
while(priorityQueue.Count != 0)
{
string nextUser = priorityQueue.Dequeue();
Console.WriteLine(nextUser);
}
//Output:
//1 - Jason
//2 - Tyler
//3 - Valerie
//4 - Joseph
//4 - Ryan
//Notice that when two strings with the same priority were enqueued, they were dequeued in the same order that they were enqueued.
}
/// <summary>
/// Generar el árbol SPF de la topología en un proyecto, tomando el parámetro como punto de origen
/// </summary>
/// <param name="idRouterOrigen"></param>
/// <param name="idProyecto"></param>
/// <returns></returns>
public static SimplePriorityQueue<NodoDijkstra> GenerarRutas(NodoDijkstra idRouterOrigen, int idProyecto)
{
idRouterOrigen.nMinDistancia = 0.0;
SimplePriorityQueue<NodoDijkstra> routerQueue = new SimplePriorityQueue<NodoDijkstra>();
routerQueue.Enqueue(idRouterOrigen, 1);
while (routerQueue.Count > 0)
{
NodoDijkstra currentRouter = routerQueue.Dequeue();
//Visita cada enlace adyacente al router u
foreach (var enlace in currentRouter.listaEnlaces)
{
NodoDijkstra vecino = new NodoDijkstra(enlace.idRouterB, idProyecto);
double nPesoBandwidth = enlace.nBandwidth;
double nDistanciaTotal = currentRouter.nMinDistancia + nPesoBandwidth;
if (nDistanciaTotal < vecino.nMinDistancia)
{
routerQueue.Remove(vecino);
vecino.nMinDistancia = nDistanciaTotal;
vecino.idRouterPrevio = currentRouter;
routerQueue.Enqueue(vecino, 1);
}
}
}
return routerQueue;
}
public AStarSearch(WeightedGraph<Position> graph, Position start, Position goal)
{
var frontier = new SimplePriorityQueue<Position>();
frontier.Enqueue(start, 0);
cameFrom[start] = start;
costSoFar[start] = 0;
while (frontier.Count > 0)
{
var current = frontier.Dequeue();
if(current.Equals(goal))
{
break;
}
foreach (var next in graph.Neighbors(current))
{
int newCost = costSoFar[current] + graph.Cost(current, next);
if (!costSoFar.ContainsKey(next) || newCost < costSoFar[next])
{
costSoFar[next] = newCost;
int priority = newCost + Heuristic(next, goal);
frontier.Enqueue(next, priority);
cameFrom[next] = current;
}
}
}
}
public Queue<Vector2> GetPath(Node start, Node goal)
{
List<Node> closedSet = new List<Node>(); // The set of nodes already evaluated
SimplePriorityQueue<Node> openSet = new SimplePriorityQueue<Node>(); // The set of tentative nodes to be evaluated
openSet.Enqueue(start, 0);
Dictionary<Node, Node> came_from = new Dictionary<Node, Node>();
Dictionary<Node, float> g_score = new Dictionary<Node, float>();
Dictionary<Node, float> f_score = new Dictionary<Node, float>();
foreach (Node node in graph.nodes.Values)
{
g_score[node] = Mathf.Infinity;
f_score[node] = Mathf.Infinity;
}
g_score[start] = 0f;
f_score[start] = heuristic_cost_estimate(start, goal);
while(openSet.Count > 0)
{
Node current = openSet.Dequeue();
if(current == goal )
{
return reconstruct_path(came_from, current);
}
closedSet.Add(current);
foreach(Node neighbour in current.edges.Keys)
{
if (closedSet.Contains(neighbour))
continue;
float tentative_g_score = g_score[current] + dist_between(current, neighbour); // length of this path.
if (openSet.Contains(neighbour) && tentative_g_score >= g_score[neighbour])
{
continue;
}
came_from[neighbour] = current;
g_score[neighbour] = tentative_g_score;
f_score[neighbour] = g_score[neighbour] + heuristic_cost_estimate(neighbour, goal);
openSet.Enqueue(neighbour, f_score[neighbour]);
}
}
// Failed to find a path.
return null;
}
public Room a_star(Room room)
{
Node current = new Node(room);
current.updateCosts();
Node next = null;
//main loop
while (current.getFinal() > GRADE_THRESHOLD)
{
//create all nodes for search in a priority queue.
createNeighbourNodes(current, room.doorPlacement);
//retrieve "closest node"
next = priorityQueue.Dequeue();
current = next;
}
return(current._room);
}
private bool Search() //main function
{
while (frontier.Count != 0) //while there are nodes left to check
{
Node current = frontier.Dequeue(); //fetches the node with the best (lowest) movement cost which wasnt checked
current.State = NodeState.Closed; //marks it as checked ("closed")
if (current.Location.Equals(this.finish)) //if end was reached, break
{
return(true);
}
foreach (Node n in GetNearbyNodes(current)) //fetches adjecent nodes to the one currently tested
{
frontier.Enqueue(n, n.F); //adds each to the frontier
}
}
return(false);
}
public Dictionary <int, StructuredAlias> .ValueCollection generateAliasOnTheFly()
{
mainMap = ParameterManager.Instance.MapToPlay;
gridType = ParameterManager.Instance.GridType;
SimilarMapsQueue = new SimplePriorityQueue <TileObject[, ]>();
K_CollisionSet = MapEvaluator.BuildKCollisionVec(mainMap, gridType, ParameterManager.Instance.StartCell, Mathf.Max(ParameterManager.Instance.minStepsSolution, ParameterManager.Instance.maxStepsSolution));
GenerateAndTestAliasMaps();
Dictionary <int, StructuredAlias> dic = new Dictionary <int, StructuredAlias>();
int i = UnityEngine.Random.Range(3, 7); //try to change
while (i > 0)
{
dic.Add(i, new StructuredAlias(SimilarMapsQueue.Dequeue()));
i--;
}
return(dic.Values);
}
public override IList <GridNode> Search(GridNode start, GridNode goal,
Motility motility)
{
Dictionary <GridNode, GridNode> parentMap = new Dictionary <GridNode, GridNode>();
SimplePriorityQueue <GridNode> frontier = new SimplePriorityQueue <GridNode>();
frontier.Enqueue(start, start.PathCost);
while (frontier.Count > 0)
{
GridNode current = frontier.Dequeue();
if (current == goal)
{
break;
}
foreach (GridNode neighbor in current.Neighbors)
{
IPathfindingEdge edge = current.JoiningEdge(neighbor);
//if (!IsTraversable(edge, motility)) continue; // TODO: Make this unnecessary
float newCost = current.PathCost + edge.Weight;
float neighborCost = neighbor.PathCost;
bool containsKey = parentMap.ContainsKey(neighbor);
if (containsKey && (newCost >= neighborCost))
{
continue;
}
neighbor.PathCost = newCost;
parentMap[neighbor] = current; // UPSERT dictionary function
float priority = newCost;
frontier.Enqueue(neighbor, priority);
}
}
IList <GridNode> path = ReconstructPath(parentMap, start, goal);
return(path);
}
private bool FindPath(Cell start, Cell goal)
{
frontier.Clear();
cameFrom.Clear();
costSoFar.Clear();
frontier.Enqueue(start, 0);
cameFrom[start] = start;
costSoFar[start] = 0;
while (frontier.Count > 0)
{
var current = frontier.Dequeue();
if (current == goal)
{
return(true);
}
foreach (var next in GetNeighbors(current, goal))
{
int newCost = costSoFar[current] + 1;
if (!costSoFar.ContainsKey(next) || newCost < costSoFar[next])
{
costSoFar[next] = newCost;
int priority = newCost + Heuristic(next, goal);
frontier.Enqueue(next, priority);
cameFrom[next] = current;
}
}
}
return(false);
}
public int Solve()
{
Init();
while (priorityQueue.Count > 0)
{
int place = priorityQueue.Dequeue();
List <int> neighbours = GetNeighbourPlaces(place);
foreach (int neighbour in neighbours)
{
int routeMinH = placeDatas[place].RouteMinH;
int routeMaxH = placeDatas[place].RouteMaxH;
if (placeDatas[neighbour].H < routeMinH)
{
routeMinH = placeDatas[neighbour].H;
}
if (placeDatas[neighbour].H > routeMaxH)
{
routeMaxH = placeDatas[neighbour].H;
}
int routeDiff = Math.Abs(routeMaxH - routeMinH);
if (routeDiff < placeDatas[neighbour].RouteHeightDiff)
{
placeDatas[neighbour].RouteHeightDiff = routeDiff;
placeDatas[neighbour].PreviousPlace = place;
placeDatas[neighbour].RouteMinH = routeMinH;
placeDatas[neighbour].RouteMaxH = routeMaxH;
priorityQueue.Enqueue(neighbour, routeDiff);
}
}
}
return(GetTotalHeightDifference());
}
public static Stack <TileNode> Dijkstra(TileGraph tg, TileNode start, TileNode end)
{
frontier = new SimplePriorityQueue <TileNode, float>();
frontier.Enqueue(start, 0f);
node_dict = DijkstraInitialDictLoad(start, tg);
List <TileNode> Expanded = new List <TileNode>();
TileNode v;
TileNode other;
float edge_weight;
float dist_to_node;
float cost_so_far;
while (frontier.Count > 0)
{
v = frontier.Dequeue();
cost_so_far = node_dict[v].dist;
Expanded.Add(v);
//List<Edge> experiment = tg.getAdjacentEdges(v) as List<Edge>;
foreach (Edge adj_edge in tg.getAdjacentEdges(v))
{
other = adj_edge.getNeighbor(v);
edge_weight = adj_edge.weight;
dist_to_node = node_dict[other].dist;
if (cost_so_far + edge_weight < dist_to_node)
{
node_dict[other].dist = cost_so_far + edge_weight;
node_dict[other].parent = v;
}
if (!Expanded.Any(node => node.isEqual(other)) && !frontier.Any(node => node.isEqual(other)))
{
frontier.Enqueue(other, node_dict[other].dist);
}
}
}
Path = NodeDictToPath(node_dict, start, end);
return(Path);
}
private static List <MessagePrioritiesModel> PriorityQueueToList(SimplePriorityQueue <string> senderQueue)
{
List <MessagePrioritiesModel> senderPriorities = new List <MessagePrioritiesModel>();
while (senderQueue.Count != 0)
{
string first = senderQueue.First;
float priority = senderQueue.GetPriority(first);
MessagePrioritiesModel newMessagePriorities = new MessagePrioritiesModel()
{
categoryName = first,
categoryPriority = priority
};
senderPriorities.Add(newMessagePriorities);
senderQueue.Dequeue();
}
return(senderPriorities);
}
static void StartTurn()
{
if (units.Count > 0)
{
TacticsMove unitTurn = units.Dequeue();
if (unitTurn.dead)
{
StartTurn();
}
else
{
unitTurn.BeginTurn();
}
}
/*else
* {
* turnKey.Dequeue();
* }*/
}
/// <summary>
/// Start algorytmu
/// </summary>
public void Start()
{
SimplePriorityQueue <Node> queue = new SimplePriorityQueue <Node>();
// Korzeń drzewa trafia na początek kolejki.
Node root = new Node(matrix, new List <Tuple <int, int> >(), -1, 0, 0);
MatrixReduction(root);
queue.Enqueue(root, root.LowerBound);
bool leafReached = false;
while (queue.Count > 0 && !leafReached)
{
Node poppedNode = queue.Dequeue();
if (poppedNode.Level == size - 1)
{
// Doszliśmy do liścia => tworzymy połączenie z miastem startowym.
poppedNode.Path.Add(new Tuple <int, int>(poppedNode.ID, 0));
GeneratePath(poppedNode);
finalDistance = poppedNode.LowerBound;
leafReached = true;
}
else
{
// Przetwarzamy każde dziecko danego węzła.
for (int i = 0; i < poppedNode.Matrix.GetLength(0); i++)
{
if (poppedNode.Matrix[poppedNode.ID, i] != int.MaxValue)
{
Node child = new Node(poppedNode.Matrix, poppedNode.Path, poppedNode.ID, i,
poppedNode.Level + 1);
MatrixReduction(child);
child.LowerBound += poppedNode.LowerBound + poppedNode.Matrix[poppedNode.ID, i];
queue.Enqueue(child, child.LowerBound);
}
}
}
}
}
public override List <int> findPath(int start, int goal)
{
SimplePriorityQueue <int> frontier = new SimplePriorityQueue <int>();
Dictionary <int, int> visitedFrom = new Dictionary <int, int>();
Dictionary <int, int> costSoFar = new Dictionary <int, int>();
frontier.Enqueue(start, 0);
visitedFrom[start] = -1;
costSoFar[start] = 0;
while (frontier.Count > 0)
{
int current = frontier.Dequeue();
if (current == goal)
{
break;
}
List <int> neighbours = navGraph.neighbours(current);
foreach (int next in neighbours)
{
int nextCost = costSoFar[current];
if (!costSoFar.ContainsKey(next) || nextCost < costSoFar[next])
{
frontier.Enqueue(next, nextCost + guessCost(next, goal));
visitedFrom[next] = current;
costSoFar[next] = nextCost;
}
}
}
List <int> path = new List <int>();
int nxt = goal;
while (nxt != start)
{
path.Insert(0, nxt);
nxt = visitedFrom[nxt];
}
//Debug.Log ("giuydskijhdsakjh");
return(path);
}
public static Tuple <Point, Queue <RobotAction> > RouteToClosestCell(Point start, HashSet <Point> targets, Map map)
{
var dist = new Dictionary <Point, int>();
var prev = new Dictionary <Point, Point>();
var Q = new SimplePriorityQueue <Point, int>();
dist[start] = 0;
Q.Enqueue(start, 0);
while (Q.Count > 0)
{
var u = Q.Dequeue();
if (targets.Contains(u))
{
return(GetActions(start, u, prev));
}
var alt = dist[u] + 1;
foreach (var v in map.Neighbors(u))
{
if (!dist.ContainsKey(v) || alt < dist[v])
{
dist[v] = alt;
prev[v] = u;
if (Q.Contains(v))
{
Q.UpdatePriority(v, alt);
}
else
{
Q.Enqueue(v, alt);
}
}
}
}
;
return(null);
}
public Carryer SpawnGiverToGenerator(ItemOrder io)
{
List <Node> entrances = GetAdjRoadTiles();
if (entrances.Count == 0)
{
return(null);
}
Node start = entrances[0];
SimplePriorityQueue <Generator> queue = FindGeneratorToAccept(io);
for (int i = 0; queue.Count > 0 && i < 5 && !ActiveSmartWalker; i++)
{
Structure strg = queue.Dequeue();
List <Node> exits = strg.GetAdjRoadTiles();
if (exits.Count == 0)
{
continue;
}
Queue <Node> path = pathfinder.FindPath(start, exits, "GiverCart");
if (path.Count == 0)
{
continue;
}
GameObject go = world.SpawnObject("Walkers", "GiverCart", start);
Carryer c = go.GetComponent <Carryer>();
c.world = world;
c.Order = io;
c.Origin = this;
c.Destination = strg;
c.Activate();
c.SetPath(path);
return(c);
}
return(null);
}
/// <summary>
/// Performs whatever actions in the queue it can.
/// </summary>
public void performActions(Ecosystem eco)
{
// the queue for the next turn
SimplePriorityQueue <Action> nextQueue = new SimplePriorityQueue <Action>();
while (actionQueue.Count > 0)
{
Action nextAction = actionQueue.Dequeue();
// if action is not possible, then ignore it (don't add it to the queue)
if (nextAction.isPossible(this))
{
// ignore actions that the creature doesn't have enough resources to perform
if (nextAction.enoughResources(this))
{
// if there is time left for an action, perform it
if (nextAction.timeCost <= remainingTurnTime)
{
//Debug.Log("performing " + nextAction.name);
nextAction.performWrapper(this, eco);
}
else
{
// put actions that take too long on the next turn's queue
nextQueue.Enqueue(nextAction, nextAction.priority);
}
}
}
}
// actionQueue is now the queue for next turn
actionQueue = nextQueue;
// keep action queue a manageable size by clearing it every few steps, and clearing it if its size gets too big
if (actionClearCount > actionClearInterval || actionQueue.Count >= actionClearSize)
{
actionClearCount = 0;
actionQueue.Clear();
}
actionClearCount++;
//Debug.Log("Queue size: " + actionQueue.Count);
}
/// <summary>
/// A generic A* algorithm implemented using Priority Queues
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="startTile"></param>
/// <param name="endTile"></param>
/// <param name="IsValidNeighbour"></param>
/// <param name="Heuristic"></param>
/// <returns></returns>
public static Dictionary <T, Cost <T> > FindPath <T>(T startTile, T endTile,
Func <T, bool> IsInvalidNeighbour, Func <T, T, float> Heuristic, bool flag)
where T : class, IWieghtedNode <T>
{
SimplePriorityQueue <T, float> frontier = new SimplePriorityQueue <T, float>();
frontier.Enqueue(startTile, 0);
Dictionary <T, Cost <T> > comeFrom = new Dictionary <T, Cost <T> >();
comeFrom[startTile] = new Cost <T>(null, 0);
while (frontier.Count != 0)
{
T current = frontier.Dequeue();
if (current == endTile)
{
break;
}
Debug.Log(current);
foreach (T next in current.GetNeighboursList(flag))
{
// Ignore impassable tiles
if (IsInvalidNeighbour(next))
{
continue;
}
float newCost = comeFrom[current].cost + next.WalkingCost(current); // cost in graph
if (!comeFrom.ContainsKey(next) || newCost < comeFrom[next].cost)
{
// Heuristic to find cost to arrive to end
float priority = newCost + Heuristic(next, endTile);
frontier.Enqueue(next, priority);
comeFrom[next] = new Cost <T>(current, newCost);
}
}
}
return(comeFrom);
}
public void Kruskal()
{
SimplePriorityQueue <Edge> pq = new SimplePriorityQueue <Edge>();
//add all the edges to priority queue,
//sort the edges on weights
for (int i = 0; i < allEdges.Count; i++)
{
pq.Enqueue(allEdges[i], allEdges[i].weight);
}
//create a parent []
int[] parent = new int[vertices];
//MakeSet
MakeSet(parent);
List <Edge> mst = new List <Edge>();
int index = 0;
//process vertices - 1 edges
while (index < vertices - 1)
{
Edge edge = pq.Dequeue();
//check if adding this edge creates a cycle
int x_set = Find(parent, edge.source);
int y_set = Find(parent, edge.destination);
if (x_set == y_set)
{
//ignore, will create cycle
}
else
{
//add it to our final result
mst.Add(edge);
index++;
Unite(parent, x_set, y_set);
}
}
//print MST
Console.WriteLine("Minimum Spanning Tree: ");
PrintGraph(mst);
}
public double Prim(long pointCount, long[][] points)
{
double path = 0;
double[] cost = new double[pointCount];
SimplePriorityQueue <long, double> priorityQ = new SimplePriorityQueue <long, double>();
for (int I = 0; I < pointCount; I++)
{
cost[I] = int.MaxValue;
priorityQ.Enqueue(I, int.MaxValue);
}
cost[0] = 0;
long v = 0;
priorityQ.UpdatePriority(0, 0);
while (priorityQ.Count != 0)
{
v = priorityQ.Dequeue();
if (cost[v] > path)
{
path = cost[v];
}
for (int i = 0; i < pointCount; i++)
{
if (i == v || !priorityQ.Contains(i))
{
continue;
}
double dist = RealDist(points[v][0], points[v][1], points[i][0], points[i][1]);
if (cost[i] > dist)
{
priorityQ.UpdatePriority(i, dist);
cost[i] = dist;
}
}
}
return(path);
}
private IEnumerator Active()
{
while (priority_queue.Count != 0)
{
Dictionary <Node, float> dic = priority_queue.First;
foreach (var v in dic)
{
current = Convert.ToInt32(v.Key.name);
distance = -v.Value;
break;
}
priority_queue.Dequeue();
if (d[current] < distance)
{
continue;
}
foreach (var v in graph.nodeList[current].nodeDic)
{
heuristic = Vector3.Distance(GameObject.Find(v.Key.name.ToString()).transform.position, endNode.transform.position);
int next = Convert.ToInt32(v.Key.name);
float nextDistance = distance + v.Value + heuristic;
if (nextDistance < d[next])
{
d[next] = nextDistance + heuristic;
priority_queue.Enqueue(Make_pair(graph.nodeList[next], -nextDistance), -nextDistance);
p[next] = current;
}
}
yield return(null);
}
StartCoroutine(DrawPath());
}
public List <Tile> FindPath(Tile start, Tile goal)
{
var cameFrom = new Dictionary <Tile, Tile>();
var costSoFar = new Dictionary <Tile, int>();
cameFrom[start] = null;
costSoFar[start] = 0;
var frontier = new SimplePriorityQueue <Tile>();
frontier.Enqueue(start, 0);
while (frontier.Count > 0)
{
var current = frontier.Dequeue();
if (current.IsEqualTo(goal))
{
break;
}
foreach (var tile in current.Neighbors)
{
var next = tile.GetComponent <Tile>();
var newCost = costSoFar[current] + next.Cost;
if (costSoFar.ContainsKey(next) && newCost >= costSoFar[next])
{
continue;
}
costSoFar[next] = newCost;
var priority = newCost + Heuristic(goal, next) * next.Cost;
frontier.Enqueue(next, priority);
cameFrom[next] = current;
}
}
return(GetPath(cameFrom, goal));
}
public async void Perform()
{
Console.WriteLine("\tStarted A*-based solver.");
// add root as a first element (frontier)
openSetexp.Enqueue(PlainBoard.GetBulbsLayer(), 0);
while (openSetexp.Count > 0)
{
var currentBulbLayer = openSetexp.Dequeue();
var currentBoard = new Board(PlainBoard);
currentBoard.PutBulbsLayer(currentBulbLayer);
if (currentBoard.ValidateSolution())
{
currentBoard.Visits = this.Visits;
solutions.Add(currentBoard);
break;
}
Visits += 1;
var successors = currentBoard.GetSuccessors();
foreach (var successorBulbLayer in successors)
{
var successorBoard = new Board(PlainBoard);
successorBoard.PutBulbsLayer(successorBulbLayer);
openSetexp.Enqueue(successorBulbLayer, (float)(successorBoard.GetProfit() + 0.01 * successorBoard.GetNumberOfLitFields()));
}
}
foreach (var board in solutions)
{
Console.WriteLine("A* solution: ", Color.Orchid);
Console.WriteLine("Visits:" + board.Visits, Color.Orchid);
board.Draw();
}
}
public void UCSearch(int v, int g, bool[] visited, ref int[] parent)
{
SimplePriorityQueue<int, int> open = new SimplePriorityQueue<int, int>(); // Orders elements in an ascending order by weight.
int[] cost = new int[size]; // Stores the least cost for all nodes starting with the start node until the goal node.
for (int i = 0; i < size; i++)
{
cost[i] = 0;
}
open.Enqueue(v, 0);
while (open.Count > 0)
{
int x = open.Dequeue();
visited[x] = true; // We mark the visited node here since UCS only expands the node with the least cost
if (x == g)
{
return;
}
for (int i = 0; i < adj[x].Count; i++)
{
if (!open.Contains(adj[x][i]) && !visited[adj[x][i]]) // Adding nodes with their costs too the Queue
{
parent[adj[x][i]] = x;
cost[adj[x][i]] = cost[x] + weight[x][i];
open.Enqueue(adj[x][i], cost[adj[x][i]]);
}
else if (open.Contains(adj[x][i])) // Updates the cost of a node in case a new path is found
{
int temp = cost[adj[x][i]];
cost[adj[x][i]] = Math.Min(cost[adj[x][i]], (cost[x] + weight[x][i]));
if (cost[adj[x][i]] < temp) // If the new path has a smaller cost, then update the node and push it back to Queue
{
parent[adj[x][i]] = x; // Update the parent in case a less-cost path is found.
open.Remove(adj[x][i]);
open.Enqueue(adj[x][i], cost[adj[x][i]]);
}
}
}
} // End of while
} // End of UCSearch function
void GenerateHoles(int amount)
{
SimplePriorityQueue <KeyValuePair <Vector3Int, int>, int> holesData = new SimplePriorityQueue <KeyValuePair <Vector3Int, int>, int>();
for (int i = 0; i < amount; i++)
{
Vector3Int center = new Vector3Int(prng.Next(0, voxelMap.Width),
prng.Next(0, voxelMap.Height),
prng.Next(i * voxelMap.Depth / amount, (i + 1) * voxelMap.Depth / amount));
int size = prng.Next(8000, 16000);
holesData.Enqueue(new KeyValuePair <Vector3Int, int>(center, size), center.z);
}
// TODO: parallelyze work here (and take care of thread safety of voxelMap)
while (holesData.Count > 0)
{
KeyValuePair <Vector3Int, int> data = holesData.Dequeue();
Debug.Log("Generating cave at " + data.Key);
GenerateIrregularCaveInMap(data.Key, data.Value);
}
}
private void RenderThread()
{
while (_loadQueue.Count > 0)
{
Chunk newChunkScript = _loadQueue.Dequeue();
if (newChunkScript != null)
{
Debug.Log("Rendering next chunk");
try
{
newChunkScript.GenerateBlocks();
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
}
_rendering = false;
}
void UCSearch(City root, City destiny, List <City> cities)
{
SimplePriorityQueue <City> Frontier = new SimplePriorityQueue <City>();
root.PathCost = 0;
Frontier.Enqueue(root, 0);
float sum;
while (Frontier.Count != 0)
{
sum = Frontier.GetPriority(Frontier.First);
City parent = (City)Frontier.Dequeue();
tbResult.Text += ("\n Expando el nodo de: " + parent.CityName + " Llevando un costo actual de: " + sum);
tbOrder.Text += ("\n" + parent.CityName + " Costo: " + sum + "\n ↓");
if (parent == destiny)
{
tbResult.Text += ("\n Llegue al destino con un costo total de: " + sum);
break;
}
cities.Add(parent);
foreach (var tempRute in parent.Rutes)
{
if (!cities.Contains(tempRute.DestinationCity))
{
if (!Frontier.Contains(tempRute.DestinationCity))
{
Frontier.Enqueue(tempRute.DestinationCity, sum + tempRute.Cost);
}
else
{
if (Frontier.GetPriority(tempRute.DestinationCity) > sum + tempRute.Cost)
{
Frontier.TryUpdatePriority(tempRute.DestinationCity, sum + tempRute.Cost);
}
}
}
}
}
}
public WeightedGraph SpanningTree()
{
var tree = new WeightedGraph();
var edges = new SimplePriorityQueue <Edge, int>();
var startNode = _nodes.Values.First();
//C : min,B
foreach (var edge in startNode.GetEdges())
{
edges.Enqueue(edge, edge.GetWeight());
}
//A
tree.AddNode(startNode.GetLabel());
while (tree.GetCountNode() < GetCountNode())
{
//C
var minEdge = edges.Dequeue();
if (tree.ContainsNode(minEdge.To()))
{
continue;
}
//C
tree.AddNode(minEdge.To());
//A->C
tree.AddEdge(minEdge.From(), minEdge.To(), minEdge.GetWeight());
//C
var nextNode = Get(minEdge.To());
foreach (var edge in nextNode.GetEdges())
{
if (!tree.ContainsNode(edge.To()))
{
edges.Enqueue(edge, edge.GetWeight());
}
}
}
return(tree);
}
private void RenderThread()
{
while (_loadQueue.Count > 0)
{
Chunk newChunkScript = _loadQueue.Dequeue();
if (newChunkScript != null)
{
// Errors in threads need to be manually caught and sent to the main thread
try
{
newChunkScript.GenerateBlocks();
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
}
_rendering = false;
}
public Dictionary <int, int> MainAlgorithm(int source)
{
SimplePriorityQueue <int> priorityQueue = new SimplePriorityQueue <int>();
InitiateLenghts(source);
priorityQueue.Enqueue(source, 0);
while (priorityQueue.Any())
{
int operatedVertex = priorityQueue.First();
priorityQueue.Dequeue();
foreach (var item in calculatedGraph.vertices[operatedVertex].outgoingEdges)
{
int newLenght = lenghts[operatedVertex] + item.Value;
if (lenghts[item.Key] > newLenght)
{
lenghts[item.Key] = newLenght;
priorityQueue.Enqueue(item.Key, newLenght);
}
}
}
return(lenghts);
}
public AStarSearch(WorldMap worldMap, Tile <TileData> start, Tile <TileData> goal, NeighborFunction getNeighbors)
{
SimplePriorityQueue <Tile <TileData>, float> frontier = new SimplePriorityQueue <Tile <TileData>, float>();
frontier.Enqueue(start, 0f);
cameFrom[start] = start;
costSoFar[start] = 0;
while (frontier.Count > 0)
{
Tile <TileData> current = frontier.Dequeue();
if (current == goal)
{
reachedDestination = true;
break;
}
foreach (Tile <TileData> next in getNeighbors(worldMap, current))
{
float newCost = costSoFar[current] + worldMap.GetCost(current, next);
if (costSoFar.ContainsKey(next) && !(newCost < costSoFar[next]))
{
continue;
}
costSoFar[next] = newCost;
float priority = newCost + Heuristic(next, goal);
frontier.Enqueue(next, priority);
cameFrom[next] = current;
}
}
Debug.Log("Destination Unreached");
}
// TODO: use a population map to guide randomness
private IEnumerable <Road> CreateRoads()
{
// Algorithm from http://nothings.org/gamedev/l_systems.html
var potentialRoads = new SimplePriorityQueue <Road>();
var acceptedRoads = new List <Road>();
var StartX = Rand.Next(20, EngineConsts.MAP_WIDTH - 20);
var StartY = Rand.Next(20, EngineConsts.MAP_HEIGHT - 20);
var Length = Rand.NextDouble() * 15 + 10;
var Angle = Math.PI / 2 * Rand.Next(0, 4);
var r1 = new Road(0, StartX, StartY, Length, Angle, 5, 0, 0);
var r2 = new Road(0, StartX, StartY, Length, Angle + Math.PI, 5, 0, 0);
potentialRoads.Enqueue(r1, 0);
potentialRoads.Enqueue(r2, 0);
while (potentialRoads.Count > 0)
{
Road road = potentialRoads.First;
float prio = potentialRoads.GetPriority(road);
potentialRoads.Dequeue();
if (CheckLocalConstraints(road, acceptedRoads, out Road newRoad))
{
acceptedRoads.Add(newRoad);
ProjectRoadToMap(newRoad);
foreach (Road rq in SolveGlobalGoals(newRoad))
{
if (rq != null)
{
potentialRoads.Enqueue(rq, prio + 1);
}
}
}
}
return(acceptedRoads);
}
public void LoadChunks(int n, bool async = true)
{
int s = chunkLoadingList.Count;
for (int i = 0; i < Math.Min(n - s, chunkLoadQueue.Count); i++)
{
ChunkIndex ci = chunkLoadQueue.Dequeue();
if (Chunks.ContainsKey(ci))
{
i--;
}
else
{
if (world.Player.ChunkID.Distance(world.Size, ci) < World.LoadDistance)
{
Chunk c = chunkPool.GetObject();
c.ChunkID = ci;
chunkLoadingList.Add(ci);
if (async)
{
Task t = Task.Factory.StartNew(() =>
{
LoadChunk(ci, c);
});
}
else
{
LoadChunk(ci, c);
}
}
else
{
i--;
}
}
}
}
/// <summary>
/// Generar y retornar el árbol SPF de la topología en un proyecto, tomando el parámetro como punto de origen
/// </summary>
/// <param name="idRouterOrigen"></param>
/// <param name="idProyecto"></param>
/// <param name="minBW"></param>
/// <returns></returns>
public static List<NodoDijkstra> GenerarRutas(NodoDijkstra idRouterOrigen, int idProyecto, double minBW, int nTipoMetrica = 2, int idAfinidad = 0)
{
idRouterOrigen.nMinDistancia = 0.0;
SimplePriorityQueue<NodoDijkstra> routerQueue = new SimplePriorityQueue<NodoDijkstra>();
routerQueue.Enqueue(idRouterOrigen, 1);
//mantiene el registro de todos los nodos de la topologia por el que se pasa
List<NodoDijkstra> routerList = new List<NodoDijkstra>();
routerList.Add(idRouterOrigen);
while (routerQueue.Count > 0)
{
NodoDijkstra currentRouter = routerQueue.Dequeue();
//Visita cada enlace adyacente al router u
foreach (var enlace in currentRouter.listaEnlacesDijkstra)
{
int idRouterVecino = 0;
//Fix: Asegurandose de que se use el id del router adyacente en el enlace
if (enlace.idRouterB != currentRouter.idRouter)
{
idRouterVecino = enlace.idRouterB;
//enlace.target = enlace.targetB;
}
else
{
idRouterVecino = enlace.idRouterA;
//enlace.target = enlace.targetA;
}
//NodoDijkstra vecino = new NodoDijkstra(idRouterVecino, idProyecto);
NodoDijkstra vecino = enlace.target;
double nPesoBandwidth = 0;
switch(nTipoMetrica) //ignore var name, aqui va lo del tipo de peso
{
case 1: //Pesos Administrativos
nPesoBandwidth = enlace.nPesoAdministrativo;
break;
case 2: //Minima Cantidad de Saltos
nPesoBandwidth = 1;
break;
case 3: // 1/BW Reservado
nPesoBandwidth = 1.00 / (enlace.nBandwidth - enlace.nBandwidthDisponible);
break;
case 4: // 1/BW Disponible
nPesoBandwidth = 1.00 / enlace.nBandwidthDisponible;
break;
default:
nPesoBandwidth = 1;
break;
}
double nDistanciaTotal = currentRouter.nMinDistancia + nPesoBandwidth;
//Aqui ocurre el filtro por afinidad
if (idAfinidad == 0) //No afinidad definida
{
//En este if ocurre el filtro por BW disponible
if (nDistanciaTotal < vecino.nMinDistancia && minBW < enlace.nBandwidth) //Constraint check
{
if (routerQueue.Contains(vecino))
routerQueue.Remove(vecino);
vecino.nMinDistancia = nDistanciaTotal;
vecino.idRouterPrevio = currentRouter;
enlace.nBandwidthDisponible -= minBW; //reservar el BW en el enlace
routerQueue.Enqueue(vecino, 1);
}
}
else //Afinidad definida
{
if (idAfinidad == enlace.idAfinidad) //Afinidad check
{
//En este if ocurre el filtro por BW disponible
if (nDistanciaTotal < vecino.nMinDistancia && minBW < enlace.nBandwidth) //Constraint check
{
if (routerQueue.Contains(vecino))
routerQueue.Remove(vecino);
vecino.nMinDistancia = nDistanciaTotal;
vecino.idRouterPrevio = currentRouter;
enlace.nBandwidthDisponible -= minBW; //reservar el BW en el enlace
routerQueue.Enqueue(vecino, 1);
}
}
}
//Agrega el router (bueno, los 2) al registro
int indexTarget = routerList.FindIndex(n => n.idRouter == vecino.idRouter);
if (indexTarget != -1)
routerList[indexTarget] = vecino;
else
routerList.Add(vecino);
int indexSource = routerList.FindIndex(n => n.idRouter == currentRouter.idRouter);
if (indexSource != -1)
routerList[indexSource] = currentRouter;
else
routerList.Add(currentRouter);
}
}
return routerList;
}
public Path_AStar(World world, Tile tileStart, Tile tileEnd)
{
// Check to see if we have a valid tile graph
if(world.tileGraph == null) {
world.tileGraph = new Path_TileGraph(world);
}
// A dictionary of all valid, walkable nodes.
Dictionary<Tile, Path_Node<Tile>> nodes = world.tileGraph.nodes;
// Make sure our start/end tiles are in the list of nodes!
if(nodes.ContainsKey(tileStart) == false) {
Debug.LogError("Path_AStar: The starting tile isn't in the list of nodes!");
return;
}
if(nodes.ContainsKey(tileEnd) == false) {
Debug.LogError("Path_AStar: The ending tile isn't in the list of nodes!");
return;
}
Path_Node<Tile> start = nodes[tileStart];
Path_Node<Tile> goal = nodes[tileEnd];
// Mostly following this pseusocode:
// https://en.wikipedia.org/wiki/A*_search_algorithm
List<Path_Node<Tile>> ClosedSet = new List<Path_Node<Tile>>();
/* List<Path_Node<Tile>> OpenSet = new List<Path_Node<Tile>>();
OpenSet.Add( start );
*/
SimplePriorityQueue<Path_Node<Tile>> OpenSet = new SimplePriorityQueue<Path_Node<Tile>>();
OpenSet.Enqueue( start, 0);
Dictionary<Path_Node<Tile>, Path_Node<Tile>> Came_From = new Dictionary<Path_Node<Tile>, Path_Node<Tile>>();
Dictionary<Path_Node<Tile>, float> g_score = new Dictionary<Path_Node<Tile>, float>();
foreach(Path_Node<Tile> n in nodes.Values) {
g_score[n] = Mathf.Infinity;
}
g_score[ start ] = 0;
Dictionary<Path_Node<Tile>, float> f_score = new Dictionary<Path_Node<Tile>, float>();
foreach(Path_Node<Tile> n in nodes.Values) {
f_score[n] = Mathf.Infinity;
}
f_score[ start ] = heuristic_cost_estimate( start, goal );
while( OpenSet.Count > 0 ) {
Path_Node<Tile> current = OpenSet.Dequeue();
if(current == goal) {
// We have reached our goal!
// Let's convert this into an actual sequene of
// tiles to walk on, then end this constructor function!
reconstruct_path(Came_From, current);
return;
}
ClosedSet.Add(current);
foreach(Path_Edge<Tile> edge_neighbor in current.edges) {
Path_Node<Tile> neighbor = edge_neighbor.node;
if( ClosedSet.Contains(neighbor) == true )
continue; // ignore this already completed neighbor
float movement_cost_to_neighbor = neighbor.data.movementCost * dist_between(current, neighbor);
float tentative_g_score = g_score[current] + movement_cost_to_neighbor;
if(OpenSet.Contains(neighbor) && tentative_g_score >= g_score[neighbor])
continue;
Came_From[neighbor] = current;
g_score[neighbor] = tentative_g_score;
f_score[neighbor] = g_score[neighbor] + heuristic_cost_estimate(neighbor, goal);
if(OpenSet.Contains(neighbor) == false) {
OpenSet.Enqueue(neighbor, f_score[neighbor]);
}
} // foreach neighbour
} // while
// If we reached here, it means that we've burned through the entire
// OpenSet without ever reaching a point where current == goal.
// This happens when there is no path from start to goal
// (so there's a wall or missing floor or something).
// We don't have a failure state, maybe? It's just that the
// path list will be null.
}
/// <summary>
/// Finds a path through the puzzle originating from startNode and ending at endNode, going across from left to right.
/// Based on A* pathfinding algorithm, it theoretically is supposed to find the shortest possible path, but this is thus far untested/unproven.
///
/// First uses buildGraph to determine all possible and relevant edges between each tile/node, then uses a mostly standard A* algorithm, until
/// an orange tile is encountered and the rules change (because of "scents"). Every time an orange tile is encountered, a nested A*-based loop (referred to as the "orange loop")
/// is ran (but with orange-scented rules) which essentially starts at the orange tile and seeks any tile that will remove the orange scent, or the endNode.
/// Every tile encountered that exits the orange loop is added to the main open set (the open set of the normal A* loop) with their cost to get there through the orange loop.
///
/// </summary>
/// <returns>Returns a list of all possible paths to the endNode, and the shortest one, or the one with the least tree height, is to be considered the answer</returns>
public List<PathTreeNode> solve()
{
resetGraphEdges();
buildGraph();
//A*-based pathfinding algorithm
List<Node> closedSet = new List<Node>();
SimplePriorityQueue<Node> openSet = new SimplePriorityQueue<Node>();
List<Node> closedOrangeSet = new List<Node>();
SimplePriorityQueue<Node> openOrangeSet;
List<PathTreeNode> Leaves = new List<PathTreeNode>();
if(startNode.edges.Count == 0)
{
return Leaves;
}
startNode.g = 0;
openSet.Enqueue(startNode, 0);
PathTreeNode root = new PathTreeNode(startNode.row, -1);
Leaves.Add(root);
while (openSet.Count > 0)
{
Node current = openSet.Dequeue();
PathTreeNode currentStep = null;
Predicate<PathTreeNode> matchingCurrentPos = aStep => aStep.row == currentStep.row && aStep.col == currentStep.col;
if (current == endNode)
{
return Leaves;
}
if(current.edges.Count == 0)
{
continue;
}
foreach (PathTreeNode leaf in Leaves)
{
if(leaf.row == current.row && leaf.col == current.col)
{
if(currentStep == null || currentStep.height > leaf.height)
{
currentStep = leaf;
}
}
}
if (currentStep != null)
{
Leaves.RemoveAll(matchingCurrentPos);
}
if(current.color == 1)
{
openOrangeSet = new SimplePriorityQueue<Node>();
openOrangeSet.Enqueue(current, current.f);
currentStep.isOrangeStep = true;
Leaves.Add(currentStep);
while(openOrangeSet.Count > 0)
{
Node currentOrange = openOrangeSet.Dequeue();
PathTreeNode currentOrangeStep = null;
Predicate<PathTreeNode> matchingCurrentOrangePos = aStep => aStep.isOrangeStep && aStep.row == currentOrangeStep.row && aStep.col == currentOrangeStep.col;
if (currentOrange.edges.Count == 0)
{
continue;
}
foreach (PathTreeNode leaf in Leaves)
{
if (leaf.isOrangeStep && leaf.row == currentOrange.row && leaf.col == currentOrange.col)
{
if (currentOrangeStep == null || currentOrangeStep.height > leaf.height)
{
currentOrangeStep = leaf;
}
}
}
if (currentOrangeStep != null)
{
Leaves.RemoveAll(matchingCurrentOrangePos);
}
closedOrangeSet.Add(currentOrange);
foreach (Edge toOrangeNeighbor in currentOrange.edges)
{
if (closedSet.Contains(toOrangeNeighbor.childNode) || closedOrangeSet.Contains(toOrangeNeighbor.childNode))
{
continue;
}
if (toOrangeNeighbor.childNode.col == cols)
{
toOrangeNeighbor.childNode.row = currentOrange.row;
}
int currentOrangeG = currentOrange.g + Math.Abs((toOrangeNeighbor.childNode.row - currentOrange.row) + (toOrangeNeighbor.childNode.col - currentOrange.col)) + toOrangeNeighbor.childNode.weight;
if (openSet.Contains(toOrangeNeighbor.childNode) && toOrangeNeighbor.childNode.g < currentOrangeG)
{
continue;
}
PathTreeNode aNextStep;
if ((toOrangeNeighbor.isScented && !toOrangeNeighbor.isOrangeScented) || toOrangeNeighbor.childNode == endNode)
{
toOrangeNeighbor.childNode.f = currentOrangeG + heuristic(toOrangeNeighbor.childNode.col);
toOrangeNeighbor.childNode.g = currentOrangeG;
openSet.Enqueue(toOrangeNeighbor.childNode, toOrangeNeighbor.childNode.f);
aNextStep = new PathTreeNode(toOrangeNeighbor.childNode.row, toOrangeNeighbor.childNode.col, currentOrangeStep);
Leaves.Add(aNextStep);
continue;
}
if(toOrangeNeighbor.childNode.color == 4)
{
continue;
}
if (!openOrangeSet.Contains(toOrangeNeighbor.childNode))
{
toOrangeNeighbor.childNode.f = currentOrangeG + heuristic(toOrangeNeighbor.childNode.col);
openOrangeSet.Enqueue(toOrangeNeighbor.childNode, toOrangeNeighbor.childNode.f);
}
else if (currentOrangeG >= toOrangeNeighbor.childNode.g)
{
continue;
}
toOrangeNeighbor.childNode.g = currentOrangeG;
toOrangeNeighbor.childNode.f = currentOrangeG + heuristic(toOrangeNeighbor.childNode.col);
openOrangeSet.UpdatePriority(toOrangeNeighbor.childNode, toOrangeNeighbor.childNode.f);
aNextStep = new PathTreeNode(toOrangeNeighbor.childNode.row, toOrangeNeighbor.childNode.col, currentOrangeStep, true);
Leaves.Add(aNextStep);
}
}
Predicate<PathTreeNode> isOrangeStepLeaf = aStep => aStep.isOrangeStep;
Leaves.RemoveAll(isOrangeStepLeaf);
closedSet.Add(current);
}
else
{
closedSet.Add(current);
foreach (Edge toNeighbor in current.edges)
{
if (closedSet.Contains(toNeighbor.childNode))
{
continue;
}
if(current.col == -1)
{
current.row = toNeighbor.childNode.row;
}
else if(toNeighbor.childNode.col == cols)
{
toNeighbor.childNode.row = current.row;
}
int currentG = current.g + Math.Abs((toNeighbor.childNode.row - current.row) + (toNeighbor.childNode.col - current.col)) + toNeighbor.childNode.weight;
PathTreeNode aNextStep;
if (!openSet.Contains(toNeighbor.childNode))
{
toNeighbor.childNode.f = currentG + heuristic(toNeighbor.childNode.col);
openSet.Enqueue(toNeighbor.childNode, toNeighbor.childNode.f);
}
else if (currentG >= toNeighbor.childNode.g)
{
continue;
}
toNeighbor.childNode.g = currentG;
toNeighbor.childNode.f = currentG + heuristic(toNeighbor.childNode.col);
openSet.UpdatePriority(toNeighbor.childNode, toNeighbor.childNode.f);
aNextStep = new PathTreeNode(toNeighbor.childNode.row, toNeighbor.childNode.col, currentStep);
Leaves.Add(aNextStep);
}
}
}
return Leaves;
}
/// <summary>
/// Performs an A* search following the Node Array A* implementation
/// </summary>
public Path FindPath(IMap map, int start, int target)
{
this.isGoal = nodeId => nodeId == target;
this.calculateHeuristic = nodeId => map.GetHeuristic(nodeId, target);
this.map = map;
var heuristic = calculateHeuristic(start);
var startNode = new AStarNode(start, 0, heuristic, CellStatus.Open);
var openQueue = new SimplePriorityQueue<int>();
openQueue.Enqueue(start, startNode.F);
// The open list lookup is indexed by the number of nodes in the graph/map,
// and it is useful to check quickly the status of any node that has been processed
var nodeLookup = new AStarNode?[map.NrNodes];
nodeLookup[start] = startNode;
while (openQueue.Count != 0)
{
var nodeId = openQueue.Dequeue();
var node = nodeLookup[nodeId].Value;
if (isGoal(nodeId))
{
return ReconstructPath(nodeId, nodeLookup);
}
ProcessNeighbours(nodeId, node, nodeLookup, openQueue);
// Close the node. I hope some day the will implement something
// like the records in F# with the "with" keyword
nodeLookup[nodeId] = new AStarNode(node.Parent, node.G, node.H, CellStatus.Closed);
}
// No path found. We could return a null, but since I read the book "Code Complete" I decided
// its best to return an empty path, and I'll return a -1 as PathCost
// TODO: Additionally, all those magic numbers like this -1 should be converted to explicit,
// clearer constants
return new Path(new List<int>(), -1);
}
