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); //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); }
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, 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); }