static void Main(string[] args) { var names = GetNames(); List <Patient> patients = new List <Patient>(); for (int i = 0; i < 1000; i++) { patients.Add(Patient.GenerateRandomPatient(names)); } PriortyQueue <Patient> toServe = new PriortyQueue <Patient>(patients); for (int i = 0; i < 10; i++) { System.Console.WriteLine("{0} is saved!", toServe.GetFirst().Name); toServe.Dequeue(); } System.Console.WriteLine("Unfortunately, everyone else died :("); }
public static TilePath DiscoverPath(Tilemap map, Vector3Int start, Vector3Int end) { //you will return this path to the user. It should be the shortest path between //the start and end vertices TilePath discoveredPath = new TilePath(); //TileFactory is how you get information on tiles that exist at a particular vector's //coordinates TileFactory tileFactory = TileFactory.GetInstance(); //This is the priority queue of paths that you will use in your implementation of //Dijkstra's algorithm PriortyQueue <TilePath> pathQueue = new PriortyQueue <TilePath>(); //You can slightly speed up your algorithm by remembering previously visited tiles. //This isn't strictly necessary. Dictionary <Vector3Int, int> discoveredTiles = new Dictionary <Vector3Int, int>(); //quick sanity check if (map == null || start == null || end == null) { return(discoveredPath); } //This is how you get tile information for a particular map location //This gets the Unity tile, which contains a coordinate (.Position) var startingMapLocation = map.GetTile(start); //And this converts the Unity tile into an object model that tracks the //cost to visit the tile. var startingTile = tileFactory.GetTile(startingMapLocation.name); startingTile.Position = start; //Any discovered path must start at the origin! discoveredPath.AddTileToPath(startingTile); //#1 This adds the starting tile to the PQ and we start off from there... pathQueue.Enqueue(discoveredPath); bool found = false; var endingMapLocation = map.GetTile(end); var endingTile = tileFactory.GetTile(endingMapLocation.name); endingTile.Position = end; TilePath pathFound = null; //#2 While the priority queue is not empty and while you have not reached your final tile while (found == false && pathQueue.IsEmpty() == false) { /* 1.Add starting location to a priority queue * 2.While the priority queue is not empty and while you have not reached your final tile: * Pop the top item off of the priority queue * If the item contains the final tile in the path, you are done. * If not, for each of the tile's neighbors (there should be 4 since we're using square tiles) * Create a new path with the additional tile. * If that path contains the final tile, you're done. * If not, add that path back into the Priority Queue. * 3.Return the path discovered in Step #2 back to the caller. */ //TODO: Implement Dijkstra's algorithm! //*Pop the top item off of the priority queue TilePath pathToCheck = pathQueue.Dequeue(); // Tile myTile = item.GetMostRecentTile(); //*If the item contains the final tile in the path, you are done. /* if (pathToCheck.Contains(endingTile)) * { * pathFound = pathToCheck; * found = true; * // break; * * } */ if (pathToCheck.GetMostRecentTile().Position == end) { discoveredPath = pathToCheck; found = true; } // *If not, for each of the tile's neighbors (there should be 4 since we're using square tiles) //*Create a new path with the additional tile. else { Tile recentTile = pathToCheck.GetMostRecentTile(); //call function getNeighbors -created on 04/13/2020 List <Tile> neighbors = getNeighbors(map, recentTile, tileFactory); // List<Tile> neighbors = findNeighbors(map, recentTile, tileFactory); for (int i = 0; i < neighbors.Count; i++) { TilePath newPath = new TilePath(pathToCheck); Tile thisneighbor = neighbors[i]; newPath.AddTileToPath(thisneighbor); // if (newPath.Contains(endingTile)) if (newPath.GetMostRecentTile().Position == end) { discoveredPath = newPath; found = true; break; } else { pathQueue.Enqueue(newPath); } } } //This line ensures that we don't get an infinite loop in Unity. //You will need to remove it in order for your pathfinding algorithm to work. // found = true; } // discoveredPath = pathFound; return(discoveredPath); }
private void computeConnection() { if (this.startNode.testCompatibility(this.endNode) == false) { this.connectionLength = -1; } else { if (this.startNode.getNodeLocation() == this.endNode.getNodeLocation()) { this.connectionLength = this.startNode.getNodeLocation().getLocationLength(); List <Location> toAdd = new List <Location>(); toAdd.Add(this.startNode.getNodeLocation()); this.connectionPath = new ConnectionPath(toAdd, this.connectionLength); } else { ConnectionPath discoveredPath = new ConnectionPath(); PriortyQueue <ConnectionPath> pathQueue = new PriortyQueue <ConnectionPath>(); Dictionary <Location, int> discoveredLocations = new Dictionary <Location, int>(); discoveredPath.addLocation(startNode.getNodeLocation()); discoveredLocations.Add(startNode.getNodeLocation(), 1); pathQueue.Enqueue(discoveredPath); bool found = false; int count = 0; while (found == false && pathQueue.IsEmpty() == false) { ConnectionPath current_path = new ConnectionPath(pathQueue.GetFirst()); pathQueue.Dequeue(); Location currentLocation = current_path.GetMostRecentLocation(); for (int i = 0; i < currentLocation.getAdjacentLocations().Count; i++) { ConnectionPath new_path = new ConnectionPath(current_path); Location neighborLocation = currentLocation.getAdjacentLocations()[i]; if (neighborLocation.getLocationLength() == -1) { continue; } if (neighborLocation.getLocationName() == this.endNode.getNodeLocation().getLocationName()) { new_path.addLocation(neighborLocation); discoveredPath = new_path; found = true; break; } else if (discoveredLocations.ContainsKey(neighborLocation) == false) { new_path.addLocation(neighborLocation); pathQueue.Enqueue(new_path); discoveredLocations.Add(neighborLocation, 1); count++; } } } this.connectionPath = discoveredPath; this.connectionLength = discoveredPath.getPathWeight(); } } }
public static TilePath DiscoverPath(Tilemap map, Vector3Int start, Vector3Int end) { //you will return this path to the user. It should be the shortest path between //the start and end vertices TilePath discoveredPath = new TilePath(); //TileFactory is how you get information on tiles that exist at a particular vector's //coordinates TileFactory tileFactory = TileFactory.GetInstance(); //This is the priority queue of paths that you will use in your implementation of //Dijkstra's algorithm PriortyQueue <TilePath> pathQueue = new PriortyQueue <TilePath>(); //You can slightly speed up your algorithm by remembering previously visited tiles. //This isn't strictly necessary. Dictionary <Vector3Int, int> discoveredTiles = new Dictionary <Vector3Int, int>(); //quick sanity check if (map == null || start == null || end == null) { return(discoveredPath); } //This is how you get tile information for a particular map location //This gets the Unity tile, which contains a coordinate (.Position) var startingMapLocation = map.GetTile(start); //And this converts the Unity tile into an object model that tracks the //cost to visit the tile. var startingTile = tileFactory.GetTile(startingMapLocation.name); startingTile.Position = start; //Any discovered path must start at the origin! discoveredPath.AddTileToPath(startingTile); //This adds the starting tile to the PQ and we start off from there... pathQueue.Enqueue(discoveredPath); bool found = false; while (found == false && pathQueue.IsEmpty() == false) { //TODO: Implement Dijkstra's algorithm! var path_ = new TilePath(pathQueue.Dequeue()); Tile recent = new Tile(path_.GetMostRecentTile()); if (recent.Position == end) { return(path_); } else { TilePath tempL = new TilePath(path_); Tile nextTile = new Tile(recent); TileBase up = map.GetTile(new Vector3Int(recent.Position.x, recent.Position.y + 1, recent.Position.z)); Tile uptemp = new Tile(tileFactory.GetTile(up.name)); TileBase down = map.GetTile(new Vector3Int(recent.Position.x, recent.Position.y - 1, recent.Position.z)); Tile downtemp = new Tile(tileFactory.GetTile(down.name)); TileBase left = map.GetTile(new Vector3Int(recent.Position.x - 1, recent.Position.y, recent.Position.z)); Tile lefttemp = new Tile(tileFactory.GetTile(left.name)); TileBase right = map.GetTile(new Vector3Int(recent.Position.x + 1, recent.Position.y, recent.Position.z)); Tile righttemp = new Tile(tileFactory.GetTile(right.name)); if (up != null) { Tile upT = new Tile(); upT.Position = new Vector3Int(recent.Position.x, recent.Position.y + 1, recent.Position.z); upT.Weight = uptemp.Weight; upT.Name = uptemp.Name; tempL.AddTileToPath(upT); if (upT.Position == end) { return(tempL); } pathQueue.Enqueue(tempL); tempL = new TilePath(path_); } if (down != null) { Tile downT = new Tile(); downT.Position = new Vector3Int(recent.Position.x, recent.Position.y - 1, recent.Position.z); downT.Weight = downtemp.Weight; downT.Name = downtemp.Name; tempL.AddTileToPath(downT); if (downT.Position == end) { return(tempL); } pathQueue.Enqueue(tempL); tempL = new TilePath(path_); } if (left != null) { Tile leftT = new Tile(); leftT.Position = new Vector3Int(recent.Position.x - 1, recent.Position.y, recent.Position.z); leftT.Weight = lefttemp.Weight; leftT.Name = lefttemp.Name; tempL.AddTileToPath(leftT); if (leftT.Position == end) { return(tempL); } pathQueue.Enqueue(tempL); tempL = new TilePath(path_); } if (right != null) { Tile rightT = new Tile(); rightT.Position = new Vector3Int(recent.Position.x + 1, recent.Position.y, recent.Position.z); rightT.Weight = righttemp.Weight; rightT.Name = righttemp.Name; tempL.AddTileToPath(rightT); if (rightT.Position == end) { return(tempL); } pathQueue.Enqueue(tempL); } } //This line ensures that we don't get an infinite loop in Unity. //You will need to remove it in order for your pathfinding algorithm to work. } return(discoveredPath); }
public static TilePath DiscoverPath(Tilemap map, Vector3Int start, Vector3Int end) { //you will return this path to the user. It should be the shortest path between //the start and end vertices TilePath discoveredPath = new TilePath(); //TileFactory is how you get information on tiles that exist at a particular vector's //coordinates TileFactory tileFactory = TileFactory.GetInstance(); //This is the priority queue of paths that you will use in your implementation of //Dijkstra's algorithm PriortyQueue <TilePath> pathQueue = new PriortyQueue <TilePath>(); //You can slightly speed up your algorithm by remembering previously visited tiles. //This isn't strictly necessary. Dictionary <Vector3Int, int> discoveredTiles = new Dictionary <Vector3Int, int>(); //quick sanity check if (map == null || start == null || end == null) { return(discoveredPath); } //This is how you get tile information for a particular map location //This gets the Unity tile, which contains a coordinate (.Position) var startingMapLocation = map.GetTile(start); //And this converts the Unity tile into an object model that tracks the //cost to visit the tile. var startingTile = tileFactory.GetTile(startingMapLocation.name); startingTile.Position = start; //Any discovered path must start at the origin! discoveredPath.AddTileToPath(startingTile); //This adds the starting tile to the PQ and we start off from there... pathQueue.Enqueue(discoveredPath); bool found = false; while (found == false && pathQueue.IsEmpty() == false) { //Get the next path from the queue TilePath Path = new TilePath(pathQueue.GetFirst()); pathQueue.Dequeue(); //Get newest added tile to process Tile Tile = new Tile(Path.GetMostRecentTile()); Vector3Int Position = new Vector3Int(Tile.Position.x, Tile.Position.y, Tile.Position.z); //Add neighbors of newest tile to list for processing List <Vector3Int> adjacentTiles = new List <Vector3Int>(); adjacentTiles.Add(new Vector3Int(Position.x, Position.y + 1, Position.z)); adjacentTiles.Add(new Vector3Int(Position.x, Position.y - 1, Position.z)); adjacentTiles.Add(new Vector3Int(Position.x + 1, Position.y, Position.z)); adjacentTiles.Add(new Vector3Int(Position.x - 1, Position.y, Position.z)); //For each loop processes each neighboring tile in list foreach (Vector3Int tile in adjacentTiles) { //Creates new path with current path as basis TilePath newPath = new TilePath(Path); Vector3Int newPosition = new Vector3Int(tile.x, tile.y, tile.z); //Grabs the data from our tile sprite in our tilemap var tileData = map.GetTile(newPosition); if (tileData == null) { continue; } //Associates the data with an actual tile var newTile = tileFactory.GetTile(tileData.name); newTile.Position = newPosition; //If at end add tile and finish up if (newTile.Position == end) { newPath.AddTileToPath(newTile); discoveredPath = newPath; found = true; break; } //If tile isn't end but hasnt been visited yet else if (discoveredTiles.ContainsKey(newPosition) == false) { newPath.AddTileToPath(newTile); pathQueue.Enqueue(newPath); discoveredTiles.Add(newPosition, 1); } } } return(discoveredPath); }
public static TilePath DiscoverPath(Tilemap map, Vector3Int start, Vector3Int end) { //you will return this path to the user. It should be the shortest path between //the start and end vertices TilePath discoveredPath = new TilePath(); //TileFactory is how you get information on tiles that exist at a particular vector's //coordinates TileFactory tileFactory = TileFactory.GetInstance(); //This is the priority queue of paths that you will use in your implementation of //Dijkstra's algorithm PriortyQueue <TilePath> pathQueue = new PriortyQueue <TilePath>(); //You can slightly speed up your algorithm by remembering previously visited tiles. //This isn't strictly necessary. Dictionary <Vector3Int, int> discoveredTiles = new Dictionary <Vector3Int, int>(); //quick sanity check if (map == null || start == null || end == null) { return(discoveredPath); } //This is how you get tile information for a particular map location //This gets the Unity tile, which contains a coordinate (.Position) var startingMapLocation = map.GetTile(start); //And this converts the Unity tile into an object model that tracks the //cost to visit the tile. var startingTile = tileFactory.GetTile(startingMapLocation.name); startingTile.Position = start; //Any discovered path must start at the origin! discoveredPath.AddTileToPath(startingTile); //This adds the starting tile to the PQ and we start off from there... pathQueue.Enqueue(discoveredPath); bool found = false; while (found == false && pathQueue.IsEmpty() == false) { // Pop the top item off of the priority queue TilePath current = new TilePath(pathQueue.Dequeue()); var tempTile = map.GetTile(start); var currentPosition = current.GetMostRecentTile().Position; if (currentPosition == end) { //If the item contains the final tile in the path, you are done. found = true; discoveredPath = current; } else { // If not, for each of the tile's neighbors (there should be 4 since we're using square tiles) Vector3Int up = new Vector3Int(currentPosition.x, currentPosition.y + 1, currentPosition.z); Vector3Int down = new Vector3Int(currentPosition.x, currentPosition.y - 1, currentPosition.z); Vector3Int left = new Vector3Int(currentPosition.x - 1, currentPosition.y, currentPosition.z); Vector3Int right = new Vector3Int(currentPosition.x + 1, currentPosition.y, currentPosition.z); Vector3Int[] adjacentTiles = new Vector3Int[] { up, down, left, right }; // Create a new path with the additional tile. for (int i = 0; i < adjacentTiles.Length; i++) { tempTile = map.GetTile(adjacentTiles[i]); if (tempTile != null) { Tile newTile = new Tile(tileFactory.GetTile(tempTile.name)); newTile.Position = adjacentTiles[i]; TilePath newPath = new TilePath(current); newPath.AddTileToPath(newTile); if (newTile.Position == end) { // If that path contains the final tile, you're done. found = true; discoveredPath = newPath; } else { // If not, add that path back into the Priority Queue. pathQueue.Enqueue(newPath); } } } } } return(discoveredPath); }
public static TilePath DiscoverPath(Tilemap map, Vector3Int start, Vector3Int end) { //you will return this path to the user. It should be the shortest path between //the start and end vertices TilePath discoveredPath = new TilePath(); //TileFactory is how you get information on tiles that exist at a particular vector's //coordinates TileFactory tileFactory = TileFactory.GetInstance(); //This is the priority queue of paths that you will use in your implementation of //Dijkstra's algorithm PriortyQueue <TilePath> pathQueue = new PriortyQueue <TilePath>(); //You can slightly speed up your algorithm by remembering previously visited tiles. //This isn't strictly necessary. List <Vector3Int> discoveredTiles = new List <Vector3Int>(); //quick sanity check if (map == null || start == null || end == null) { return(discoveredPath); } discoveredTiles.Add(start); //This is how you get tile information for a particular map location //This gets the Unity tile, which contains a coordinate (.Position) var startingMapLocation = map.GetTile(start); //And this converts the Unity tile into an object model that tracks the //cost to visit the tile. Tile startingTile = tileFactory.GetTile(startingMapLocation.name); startingTile.Position = start; // Temporary usage of discoveredPath discoveredPath.AddTileToPath(startingTile); //This adds the starting tile to the PQ and we start off from there... pathQueue.Enqueue(discoveredPath); while (pathQueue.IsEmpty() == false) { TilePath current = pathQueue.Dequeue(); Vector3Int currentPos = current.GetMostRecentTile().Position; if (currentPos == end) { discoveredPath = current; break; } for (int x = 1, y = 0; x + y != 0; y += x, x -= y, y -= Convert.ToInt32(x == -1)) { Vector3Int find = new Vector3Int(currentPos.x + x, currentPos.y + y, currentPos.z); if (!discoveredTiles.Contains(find)) { discoveredTiles.Add(find); TilePath next = new TilePath(current); var nextLocation = map.GetTile(find); if (nextLocation == null) { continue; } Tile nextTile = tileFactory.GetTile(nextLocation.name); nextTile.Position = find; next.AddTileToPath(nextTile); pathQueue.Enqueue(next); } } } return(discoveredPath); }
public static TilePath DiscoverPath(Tilemap map, Vector3Int start, Vector3Int end) { //you will return this path to the user. It should be the shortest path between //the start and end vertices TilePath discoveredPath = new TilePath(); //TileFactory is how you get information on tiles that exist at a particular vector's //coordinates TileFactory tileFactory = TileFactory.GetInstance(); //This is the priority queue of paths that you will use in your implementation of //Dijkstra's algorithm PriortyQueue <TilePath> pathQueue = new PriortyQueue <TilePath>(); //You can slightly speed up your algorithm by remembering previously visited tiles. //This isn't strictly necessary. Dictionary <Vector3Int, int> discoveredTiles = new Dictionary <Vector3Int, int>(); //quick sanity check if (map == null || start == null || end == null) { return(discoveredPath); } //This is how you get tile information for a particular map location //This gets the Unity tile, which contains a coordinate (.Position) var startingMapLocation = map.GetTile(start); //And this converts the Unity tile into an object model that tracks the //cost to visit the tile. var startingTile = tileFactory.GetTile(startingMapLocation.name); startingTile.Position = start; //Any discovered path must start at the origin! discoveredPath.AddTileToPath(startingTile); //This adds the starting tile to the PQ and we start off from there... pathQueue.Enqueue(discoveredPath); bool found = false; int count = -1; while (found == false && pathQueue.IsEmpty() == false) { //TODO: Implement Dijkstra's algorithm! //pop item off priority queue TilePath newPath = pathQueue.Dequeue(); //Tile nextTile = newPath.GetMostRecentTile(); //if item contains the final tile in the path, you are done if (newPath.GetMostRecentTile().Position == end) { discoveredPath = newPath; found = true; } else { Tile nextTile = newPath.GetMostRecentTile(); //discoveredTiles.Add(new Vector3Int(nextTile.Position.x, nextTile.Position.y, nextTile.Position.z), tileFactory.GetTile(nextTile.name)); List <Tile> neighborTiles = findNeighbors(map, nextTile, tileFactory); //the findneighbors helper funciton only gets the above, the other three are the same //for each of the neighbors(4 since using squares) for (int i = 0; i < neighborTiles.Count; i++) { //create a new path with the additional tile TilePath anotherPath = new TilePath(newPath); anotherPath.AddTileToPath(neighborTiles[i]); //for(int j = 0; j < discoveredTiles.Count; j++) //{ // if(neighborTiles[i].Position != discoveredTiles[j] && anotherPath.GetMostRecentTile().Position != end) // { // pathQueue.Enqueue(anotherPath); // } // else // { // discoveredPath = anotherPath; // found = true; // break; // } //} //if that path contains the final tile, done if (anotherPath.GetMostRecentTile().Position == end) { discoveredPath = anotherPath; found = true; break; } else { //add that back into priority Queue pathQueue.Enqueue(anotherPath); } } } // else; for each of the neighbors(4 since using squares) //create a new path with the additional tile //if that path contains the final tile, done //else add that back into priority Queue //return the path discovered back to caller //This line ensures that we don't get an infinite loop in Unity. //You will need to remove it in order for your pathfinding algorithm to work. //found = true; //if(pathQueue.Count >10000) //{ // break; //} } return(discoveredPath); }
public static TilePath DiscoverPath(Tilemap map, Tilemap objects, Vector3Int start, Vector3Int end) { //you will return this path to the user. It should be the shortest path between //the start and end vertices TilePath discoveredPath = new TilePath(); //TileFactory is how you get information on tiles that exist at a particular vector's //coordinates TileFactory tileFactory = TileFactory.GetInstance(); //This is the priority queue of paths that you will use in your implementation of //Dijkstra's algorithm PriortyQueue <TilePath> pathQueue = new PriortyQueue <TilePath>(); //You can slightly speed up your algorithm by remembering previously visited tiles. //This isn't strictly necessary. Dictionary <Vector3Int, int> discoveredTiles = new Dictionary <Vector3Int, int>(); if (objects == null) { Debug.Log("Objects layer is null"); } //quick sanity check if (map == null || objects == null || start == null || end == null) { return(discoveredPath); } //This is how you get tile information for a particular map location //This gets the Unity tile, which contains a coordinate (.Position) var startingMapLocation = map.GetTile(start); var startingMapObsticle = objects.GetTile(start); //And this converts the Unity tile into an object model that tracks the //cost to visit the tile. var startingTile = tileFactory.GetTile(startingMapLocation.name); if (startingMapObsticle != null) { var startingObject = tileFactory.GetTile(startingMapObsticle.name); startingTile.Position = start; startingTile.Weight = startingTile.Weight + startingObject.Weight; } else { int startingObjWeight = 0; startingTile.Position = start; startingTile.Weight = startingTile.Weight + startingObjWeight; Debug.Log(startingTile.Weight); } //Any discovered path must start at the origin! discoveredPath.AddTileToPath(startingTile); //This adds the starting tile to the PQ and we start off from there... pathQueue.Enqueue(discoveredPath); bool found = false; int count = 0; while (found == false && pathQueue.IsEmpty() == false) { //TODO: Implement Dijkstra's algorithm! // Dequeue Top, TilePath current_path = new TilePath(pathQueue.GetFirst()); pathQueue.Dequeue(); Tile current_tile = new Tile(current_path.GetMostRecentTile()); Vector3Int current_position = new Vector3Int(current_tile.Position.x, current_tile.Position.y, current_tile.Position.z); List <Vector3Int> adjacent_tiles = new List <Vector3Int>(); adjacent_tiles.Add(new Vector3Int(current_position.x, current_position.y + 1, current_position.z)); adjacent_tiles.Add(new Vector3Int(current_position.x, current_position.y - 1, current_position.z)); adjacent_tiles.Add(new Vector3Int(current_position.x + 1, current_position.y, current_position.z)); adjacent_tiles.Add(new Vector3Int(current_position.x - 1, current_position.y, current_position.z)); for (int i = 0; i < adjacent_tiles.Count; i++) { TilePath new_path = new TilePath(current_path); Vector3Int neighbor_position = new Vector3Int(adjacent_tiles[i].x, adjacent_tiles[i].y, adjacent_tiles[i].z); //Get Neighbor node and set equal to visited_node int objectWeight = 0; var visited_node_location = map.GetTile(neighbor_position); var visited_node_object = objects.GetTile(neighbor_position); if (visited_node_location == null) { continue; } if (visited_node_object != null) { var visited_object = tileFactory.GetTile(visited_node_object.name); objectWeight = visited_object.Weight; if (objectWeight == -1) { continue; } } var visited_node = tileFactory.GetTile(visited_node_location.name); if (visited_node.Weight == -1) { continue; } visited_node.Position = neighbor_position; visited_node.Weight = visited_node.Weight + objectWeight; if (visited_node.Position == end) { new_path.AddTileToPath(visited_node); discoveredPath = new_path; found = true; break; } else if (discoveredTiles.ContainsKey(neighbor_position) == false) { new_path.AddTileToPath(visited_node); pathQueue.Enqueue(new_path); discoveredTiles.Add(neighbor_position, 1); count++; } } } Debug.Log(discoveredPath.Weight); return(discoveredPath); }
public static TilePath DiscoverPath(Tilemap map, Vector3Int start, Vector3Int end) { //you will return this path to the user. It should be the shortest path between //the start and end vertices TilePath discoveredPath = new TilePath(); //TileFactory is how you get information on tiles that exist at a particular vector's //coordinates TileFactory tileFactory = TileFactory.GetInstance(); //This is the priority queue of paths that you will use in your implementation of //Dijkstra's algorithm PriortyQueue <TilePath> pathQueue = new PriortyQueue <TilePath>(); //You can slightly speed up your algorithm by remembering previously visited tiles. //This isn't strictly necessary. Dictionary <Vector3Int, int> discoveredTiles = new Dictionary <Vector3Int, int>(); //quick sanity check if (map == null || start == null || end == null) { return(discoveredPath); } //This is how you get tile information for a particular map location //This gets the Unity tile, which contains a coordinate (.Position) var startingMapLocation = map.GetTile(start); //var endingMapLocation = map.GetTile(end); //And this converts the Unity tile into an object model that tracks the //cost to visit the tile. var startingTile = tileFactory.GetTile(startingMapLocation.name); startingTile.Position = start; //var endingTile = tileFactory.GetTile(endingMapLocation.name); //endingTile.Position = end; //Any discovered path must start at the origin! discoveredPath.AddTileToPath(startingTile); //This adds the starting tile to the PQ and we start off from there... pathQueue.Enqueue(discoveredPath); bool found = false; while (found == false && pathQueue.IsEmpty() == false) { //TODO: Implement Dijkstra's algorithm! TilePath current_path = new TilePath(pathQueue.Dequeue()); Vector3Int position = current_path.GetMostRecentTile().Position; if (position == end) // If currentLocation == End location { discoveredPath = current_path; break; } Vector3Int next_down = position; Vector3Int next_up = position; Vector3Int next_right = position; Vector3Int next_left = position; next_down.y -= 1; next_up.y += 1; next_right.x += 1; next_left.x -= 1; Vector3Int[] next_poses = new Vector3Int[4]; next_poses[0] = next_down; next_poses[1] = next_up; next_poses[2] = next_right; next_poses[3] = next_left; for (int i = 0; i < 4; i++) { // Get the tile and set to position of X var next_position = map.GetTile(next_poses[i]); if (next_position != null) // check if fallen off edge of map { var new_tile = tileFactory.GetTile(next_position.name); new_tile.Position = next_poses[i]; // Now we make a brand new path based on our current one.(bullet 1) TilePath new_path = new TilePath(current_path); // Done // Add new_tile to new_path new_path.AddTileToPath(new_tile); // todo // does it contain end tile? if (next_poses[i] == end) { found = true; discoveredPath = new_path; break; } else { pathQueue.Enqueue(new_path); } } } //This line ensures that we don't get an infinite loop in Unity. //You will need to remove it in order for your pathfinding algorithm to work. //found = true; } return(discoveredPath); }