private NodePath RunDijkstra(DefinitionNodeGrid definitionNodeGrid, Point2 gridStart, Point2 gridEnd, out bool succes)
{
var dijkstraAlgorithm = new DijkstraAlgorithm(definitionNodeGrid.NodeCount);
var start = definitionNodeGrid.NodeGrid.ToIndex(gridStart.X, gridStart.Y);
var end = definitionNodeGrid.NodeGrid.ToIndex(gridEnd.X, gridEnd.Y);
var pathfindingNetwork = new DijkstraNodeGrid(definitionNodeGrid, 5);
var pathRequest = PathRequest.Create(Substitute.For <IPathfinder <IPath> >(), start, end, PathfindaxCollisionCategory.Cat1);
return(dijkstraAlgorithm.FindPath(pathfindingNetwork, pathRequest, out succes));
}
public void TestDijkstra()
{
var vertices = new int[] { 1, 2, 3, 4, 5, 6 };
var edges = new int[,]
{
{ -1, 7, 9, -1, -1, 14 },
{ 7, -1, 10, 15, -1, -1 },
{ 8, 10, -1, 11, -1, 2 },
{ -1, 15, 11, -1, 6, -1 },
{ -1, -1, -1, 6, -1, 9 },
{ 14, -1, 2, -1, 9, -1}
};
var dijkstra = new DijkstraAlgorithm<int>(vertices, edges);
var path = dijkstra.FindPath(0, 4);
CollectionAssert.AreEqual(path, new int[] { 1, 3, 6, 5 });
}
public void TestDijkstra()
{
var vertices = new int[] { 1, 2, 3, 4, 5, 6 };
var edges = new int[, ]
{
{ -1, 7, 9, -1, -1, 14 },
{ 7, -1, 10, 15, -1, -1 },
{ 8, 10, -1, 11, -1, 2 },
{ -1, 15, 11, -1, 6, -1 },
{ -1, -1, -1, 6, -1, 9 },
{ 14, -1, 2, -1, 9, -1 }
};
var dijkstra = new DijkstraAlgorithm <int>(vertices, edges);
var path = dijkstra.FindPath(0, 4);
CollectionAssert.AreEqual(path, new int[] { 1, 3, 6, 5 });
}
public bool FindPath()
{
_algorithm.StartFindPath(_nodeNetwork, _definitionNodeGrid.NodeArray, _pathRequest.PathStart);
return(_algorithm.FindPath(_nodeNetwork, _definitionNodeGrid.NodeGrid.Array, _pathRequest.PathEnd, _pathRequest.AgentSize, _pathRequest.CollisionCategory));
}
private void Run()
{
Defaults.Load();
MeasureTime(() =>
{
Console.WriteLine("Reading network file...");
_streets = OsmStreetSystem.LoadSystem("K:\\OsmData\\schleswig-holstein-latest.sn");
Console.WriteLine("Finished.");
});
GC.Collect();
var start = _streets.Waypoints[3444465853];
var end = _streets.Waypoints[620793260];
Console.WriteLine();
Console.WriteLine($"Trying to find path from {start.Id} to {end.Id}");
Console.WriteLine($"Direct distance: {start.DistanceTo(end):##.000} km");
Console.WriteLine();
Console.WriteLine("Using Dijkstra's allgorithm.");
var dijkstra = new DijkstraAlgorithm();
var astar = new AStarAlgorithm();
Console.WriteLine(" --------- DIJKSTRA ----------");
for (int i = 0; i < 3; i++)
{
MeasureTime(() =>
{
Console.WriteLine($"[{i}] Looking for a path in the graph....");
var p = dijkstra.FindPath(start, end);
Console.WriteLine($"Finished in {dijkstra.Steps} steps.");
Console.WriteLine($"Inspected {dijkstra.InspectedNodes}, visited {dijkstra.VisitedNodes}");
if (p != null)
{
Console.WriteLine($"Found a path. {p.Waypoints.Count} waypoints. {p.Length:##.000} km.");
}
else
{
Console.WriteLine("No path found.");
}
});
}
Console.WriteLine(" --------- A-STAR ----------");
for (int i = 0; i < 3; i++)
{
MeasureTime(() =>
{
Console.WriteLine($"[{i}] Looking for a path in the graph....");
var p = astar.FindPath(start, end);
Console.WriteLine($"Finished in {astar.Steps} steps.");
Console.WriteLine($"Inspected {astar.InspectedNodes}, visited {astar.VisitedNodes}");
if (p != null)
{
Console.WriteLine($"Found a path. {p.Waypoints.Count} waypoints. {p.Length:##.000} km.");
}
else
{
Console.WriteLine("No path found.");
}
});
}
Console.ReadLine();
}
IEnumerator GenerateLevel()
{
while (!loaded)
{
if (gX * gY > 1)
{
InitializeGrid(gX, gY);
yield return(null);
int r1Q = Random.Range(1, 4);
int r2Q = Random.Range(1, 4);
if (r1Q == r2Q)
{
r2Q++;
if (r2Q == 5)
{
r2Q = 1;
}
}
bool r1Assigned = false;
do
{
r1Assigned = AssignRandomRoom(1, r1Q);
} while (!r1Assigned);
bool r2Assigned = false;
do
{
r2Assigned = AssignRandomRoom(2, r2Q);
} while (!r2Assigned);
end.occupied = false;
yield return(null);
for (int i = 0; i < gX; i++)
{
for (int j = 0; j < gY; j++)
{
grid [i, j].weight = Random.Range(0, 50);
}
}
yield return(null);
start.weight = 0;
path = DijkstraAlgorithm.FindPath(start, end, grid, gX, gY);
roomsToPlace = new List <Arrangement> (0);
List <Node> pathOrig = new List <Node> (0);
foreach (Node n in path)
{
pathOrig.Add(n);
}
for (int i = 0; i < pathOrig.Count - 1; i++)
{
if (path.Contains(pathOrig [i]))
{
if (roomsToPlace.Count == 0)
{
roomsToPlace.Add(PlaceRoom(path [0], Arrangement.pathFailure, true));
}
roomsToPlace.Add(PlaceRoom(path [0], roomsToPlace [roomsToPlace.Count - 1].pathExitPt, true));
yield return(null);
}
}
roomsToPlace.Add(PlaceRoom(end, roomsToPlace [roomsToPlace.Count - 1].pathExitPt, false));
yield return(null);
InstantiateRooms(roomsToPlace);
yield return(null);
roomsToPlace.Clear();
for (int i = 0; i < sideRooms; i++)
{
if (openDoors.Count > 0)
{
DoorInfo door = openDoors [Random.Range(0, openDoors.Count)];
if (InBounds((int)door.loc.x, (int)door.loc.y))
{
Arrangement r = PlaceRoom(grid [(int)(door.loc.x), (int)(door.loc.y)], door.loc - door.face, false);
if (r != null)
{
roomsToPlace.Add(r);
InstantiateRooms(roomsToPlace);
roomsToPlace.Clear();
}
else
{
openDoors.Remove(door);
i--;
}
yield return(null);
}
}
else
{
break;
}
}
RemoveExcessNavmesh();
DoorInfo[] dGrp = FindObjectsOfType <DoorInfo> ();
for (int i = dGrp.Length - 1; i >= 0; i--)
{
if (dGrp [i].pair != null)
{
dGrp [i].pair.GetComponent <RoomInfo> ().AddToNeighborList(dGrp [i].gameObject);
dGrp [i].GetComponent <RoomInfo> ().AddToNeighborList(dGrp [i].pair.gameObject);
if (!dGrp [i].MarkForRemoval)
{
if (!dGrp [i].locked)
{
dGrp [i].PlaceDoorObject(unlockedDoor, gridScale);
}
}
yield return(null);
}
else
{
dGrp [i].PlaceDoorObject(sealedDoor, gridScale);
}
}
for (int i = dGrp.Length - 1; i >= 0; i--)
{
if (dGrp [i].MarkForRemoval)
{
Destroy(dGrp [i]);
}
}
}
GameObject[] Hpickups = GameObject.FindGameObjectsWithTag("Health");
GameObject[] Apickups = GameObject.FindGameObjectsWithTag("Ammo");
List <GameObject> picks = new List <GameObject> ();
foreach (GameObject g in Hpickups)
{
picks.Add(g);
}
foreach (GameObject g in Apickups)
{
picks.Add(g);
}
for (int i = 0; i < 3; i++)
{
if (picks.Count < 1)
{
break;
}
GameObject lockboxPos = picks [Random.Range(0, picks.Count)];
GameObject lockbox = Instantiate(lockBoxObj);
lockbox.transform.position = lockboxPos.transform.position;
picks.Remove(lockboxPos);
Destroy(lockboxPos);
}
for (int i = 0; i < 3; i++)
{
if (picks.Count < 1)
{
break;
}
GameObject lockpickPos = picks [Random.Range(0, picks.Count)];
GameObject lockpick = Instantiate(lockPickObj);
lockpick.transform.position = lockpickPos.transform.position;
picks.Remove(lockpickPos);
Destroy(lockpickPos);
}
loaded = true;
}
StopCoroutine(GenerateLevel());
}
IEnumerator GenerateLevel()
{
while (!loaded)
{
if (gX * gY > 1)
{
InitializeGrid(gX, gY);
yield return(null);
int r1Q = Random.Range(1, 4);
int r2Q = Random.Range(1, 4);
if (r1Q == r2Q)
{
r2Q++;
if (r2Q == 5)
{
r2Q = 1;
}
}
bool r1Assigned = false;
do
{
r1Assigned = AssignRandomRoom(1, r1Q);
} while (!r1Assigned);
bool r2Assigned = false;
do
{
r2Assigned = AssignRandomRoom(2, r2Q);
} while (!r2Assigned);
end.occupied = false;
yield return(null);
for (int i = 0; i < gX; i++)
{
for (int j = 0; j < gY; j++)
{
grid [i, j].weight = Random.Range(0, 50);
}
}
yield return(null);
start.weight = 0;
path = DijkstraAlgorithm.FindPath(start, end, grid, gX, gY);
roomsToPlace = new List <Arrangement> (0);
List <Node> pathOrig = new List <Node> (0);
foreach (Node n in path)
{
pathOrig.Add(n);
}
for (int i = 0; i < pathOrig.Count - 1; i++)
{
if (path.Contains(pathOrig [i]))
{
if (roomsToPlace.Count == 0)
{
roomsToPlace.Add(PlaceRoom(path [0], Arrangement.pathFailure, true));
}
roomsToPlace.Add(PlaceRoom(path [0], roomsToPlace [roomsToPlace.Count - 1].pathExitPt, true));
yield return(null);
}
}
roomsToPlace.Add(PlaceRoom(end, roomsToPlace [roomsToPlace.Count - 1].pathExitPt, false));
yield return(null);
InstantiateRooms(roomsToPlace);
yield return(null);
roomsToPlace.Clear();
bool rLAssigned = false;
Node lockRoom;
if (openDoors.Count > 0)
{
do
{
lockRoom = grid[Random.Range(0, gX), Random.Range(0, gY)];
if (!lockRoom.occupied)
{
rLAssigned = true;
}
} while (!rLAssigned);
lockRoom.weight = 0;
lockRoom.roomType = 3;
DoorInfo d = openDoors [Random.Range(0, openDoors.Count)];
Node hallRoom = grid[(int)d.loc.x, (int)d.loc.y];
path = DijkstraAlgorithm.FindPath(hallRoom, lockRoom, grid, gX, gY);
roomsToPlace = new List <Arrangement> (0);
pathOrig = new List <Node> (0);
foreach (Node n in path)
{
pathOrig.Add(n);
}
for (int i = 0; i < pathOrig.Count - 1; i++)
{
if (path.Contains(pathOrig [i]))
{
if (roomsToPlace.Count == 0)
{
roomsToPlace.Add(PlaceRoom(path [0], Arrangement.pathFailure, true));
}
roomsToPlace.Add(PlaceRoom(path [0], roomsToPlace [roomsToPlace.Count - 1].pathExitPt, true));
yield return(null);
}
}
roomsToPlace.Add(PlaceRoom(lockRoom, roomsToPlace [roomsToPlace.Count - 1].pathExitPt, false));
yield return(null);
InstantiateRooms(roomsToPlace);
yield return(null);
roomsToPlace.Clear();
}
for (int i = 0; i < sideRooms; i++)
{
if (openDoors.Count > 0)
{
DoorInfo door = openDoors [Random.Range(0, openDoors.Count)];
if (InBounds((int)door.loc.x, (int)door.loc.y))
{
Arrangement r = PlaceRoom(grid [(int)(door.loc.x), (int)(door.loc.y)], door.loc - door.face, false);
if (r != null)
{
roomsToPlace.Add(r);
InstantiateRooms(roomsToPlace);
roomsToPlace.Clear();
}
else
{
openDoors.Remove(door);
i--;
}
yield return(null);
}
}
else
{
break;
}
}
RemoveExcessNavmesh();
DoorInfo[] dGrp = FindObjectsOfType <DoorInfo> ();
for (int i = dGrp.Length - 1; i >= 0; i--)
{
if (dGrp [i].pair != null && dGrp[i] != null)
{
dGrp [i].pair.GetComponent <RoomInfo> ().AddToNeighborList(dGrp [i].gameObject);
dGrp [i].GetComponent <RoomInfo> ().AddToNeighborList(dGrp [i].pair.gameObject);
if (!dGrp [i].MarkForRemoval)
{
if (!dGrp[i].locked)
{
dGrp [i].PlaceDoorObject(unlockedDoor, gridScale);
}
else
{
dGrp [i].PlaceDoorObject(lockedDoor, gridScale);
}
}
yield return(null);
}
}
for (int i = dGrp.Length - 1; i >= 0; i--)
{
if (dGrp [i].MarkForRemoval)
{
Destroy(dGrp [i]);
}
}
}
loaded = true;
}
StopCoroutine(GenerateLevel());
}
