public Route getRoute(Solarsystem start, Solarsystem end, bool dontUsePing = false)
{
foreach (Route element in routelist)
{
if ((start == element.start) && (end == element.end))
{
return element;
}
}
if (dontUsePing)
{
Route startS = new Route();
startS.systems.Add(start);
Route result = searchRoute(start, end, startS, 0);
result.start = start;
result.end = end;
routelist.Add(result);
Route route2 = new Route();
route2.start = end;
route2.end = start;
route2.nodelist = InverseList(result.nodelist);
route2.systems = InverseList(result.systems);
routelist.Add(route2);
return result;
}
else
{
try
{
this.pingSolarsystem(start, start, end);
Route[] results = pingResponse[start][end];
Route best = null;
foreach (Route rt in results)
{
double length = 0;
foreach (Node nd in rt.nodelist)
{
length += nd.distance;
}
rt.distance = length;
if ((best == null) || (best.distance > rt.distance))
{
best = rt;
}
}
best.systems.Add(end);
return best;
}
catch (TrackingCanceledException)
{
return null;
}
}
}
private Route searchRoute(Solarsystem position, Solarsystem end, Route list, int depth)
{
Route result = null;
// Console.WriteLine("Bin im System: " + position);
if (depth < maxdepth)
// Parallel.ForEach(position.nodes, node =>
foreach (Node node in position.nodes)
{
// Console.WriteLine("Checke Node: " + node);
// bool stop = false;
Solarsystem other;
other = (node.pointa == position) ? node.pointb : node.pointa;
Route VList = new Route();
VList.nodelist = CloneList(list.nodelist);
VList.nodelist.Add(node);
VList.systems = CloneList(list.systems);
VList.systems.Add(other);
if (list.systems.Contains(other))
{
// Console.WriteLine("Bereits besucht");
// stop = true;
continue;
}
// if (!stop)
// {
if (other == end)
{
double distance = 0;
foreach (Node tmp in VList.nodelist)
{
distance += tmp.distance;
}
VList.distance = distance;
// Console.WriteLine("Ergebnis gefunden");
// result = VList;
return VList;
}
else
{
// Console.WriteLine("Suche Rekursiv");
Route search = searchRoute(other, end, VList, depth + 1);
if (search.distance != -1)
{
// result = search;
return search;
}
else
{
// Console.WriteLine("Ergebnis nicht gefunden");
}
// }
}
}
// });
if (result == null)
{
result = new Route();
result.distance = -1;
}
return result;
}
private bool Contains(List<Route> list, Route element)
{
if ((list == null) || (element == null))
{
return false;
}
foreach (Route check in list)
{
if ((check.start == element.start) && (check.end == element.end))
{
return true;
}
}
return false;
}
public void pingSolarsystem(Solarsystem current, Solarsystem source, Solarsystem destination, Solarsystem[] visited = null, Node[] visitedNode = null, int maxResults = 3, int depth = 0)
{
if (visited == null || visitedNode == null)
{
visited = new Solarsystem[0];
visitedNode = new Node[0];
//pingResponse = new Dictionary<Solarsystem, Dictionary<Solarsystem, Route[]>>();
}
if ((main != null) && (!main.run()))
{
return;
}
if (!pingResponse.ContainsKey(source))
{
pingResponse.Add(source, new Dictionary<Solarsystem, Route[]>());
}
if (pingResponse[source].ContainsKey(destination) && (pingResponse[source][destination].Length >= maxResults))
{
return;
}
if (depth > maxdepth)
{
throw new TrackingCanceledException();
}
if (current == destination)
{
try
{
Route route = new Route();
route.start = source;
route.end = destination;
route.systems = new List<Solarsystem>();
route.nodelist = new List<Node>();
foreach (Solarsystem system in visited)
{
route.systems.Add(system);
}
foreach (Node node in visitedNode)
{
route.nodelist.Add(node);
}
if (!pingResponse[source].ContainsKey(destination))
{
pingResponse[source].Add(destination, new Route[0]);
}
Route[] routes = new Route[pingResponse[source][destination].Length + 1];
copyArray(pingResponse[source][destination], routes);
routes[routes.Length - 1] = route;
pingResponse[source][destination] = routes;
}
catch
{
// Das ist sehr seltsam, dass hier was fliegt ...
}
}
else if (visited.Contains(current))
{
// Das System wurde bereits besucht ...
return;
}
else
{
//Trage das aktuelle System in die Liste, der besuchten Systeme ein
Solarsystem[] visited2 = new Solarsystem[visited.Length + 1];
copyArray(visited, visited2);
visited2[visited2.Length - 1] = current;
List<Node> nodelist = current.nodes;
bool error = false;
Parallel.ForEach(nodelist, node =>
// foreach (Node node in nodelist)
{
try
{
Solarsystem other = (node.pointa == current) ? node.pointb : node.pointa;
Node[] visitedNode2 = new Node[visitedNode.Length + 1];
copyArray(visitedNode, visitedNode2);
visitedNode2[visitedNode2.Length - 1] = node;
pingSolarsystem(other, source, destination, visited2, visitedNode2, maxResults, depth + 1);
//}
}
catch (TrackingCanceledException)
{
error = true;
}
});
if (error)
{
throw new TrackingCanceledException();
}
}
if (depth == 0)
{
// if (!pingResponse.ContainsKey(source) || !(pingResponse[source].ContainsKey(destination)) || !(pingResponse[source][destination].Length > 0))
// {
// throw new TrackingCanceledException();
// }
// else
// {
return;
// }
}
else
{
return;
}
}
private void handleData()
{
main.log("Erstelle Zufalls Karte ...");
generateMapData();
//Erstellen der Routen:
//main.modulmanager.nodetracking.generateData();
//Speichern der Map
saveMap();
main.log("Überprüfe erstellte Karte auf Korrektheit");
// Überprüfen ob jeder Spieler zu jedem Spieler reisen kann:
bool ok = true;
//main.log("Warnung: Überprüfungsfunktion deaktiviert! Diese Karte könnte nicht spielbar sein! Betrachten Sie sich die Datei created.map mit dem Mapeditor um das zu überprüfen");
List<Route> geprueft = new List<Route>();
int count = 0;
int countConnections = (int)((usersystems.Count * (usersystems.Count - 1)) / 2f);
foreach (Solarsystem system in usersystems)
{
if (!ok)
{
break;
}
foreach (Solarsystem system2 in usersystems)
{
bool have = false;
foreach (Route rt in geprueft)
{
if (((rt.start == system) && (rt.end == system2)) || ((rt.start == system2) && (rt.end == system)))
{
have = true;
break;
}
}
if (have)
{
continue;
}
Route route = new Route();
route.start = system;
route.end = system2;
geprueft.Add(route);
if (system != system2)
{
bool sysok = false;
try
{
main.modulmanager.nodetracking.pingSolarsystem(system, system, system2, null, null, 1);
/* if (test == null)
{
sysok = true;
count++;
main.log("Überprüfung zu " + (((float)count / countConnections) * 100) + "% abgeschlossen");
}
else
{
sysok = false;
}
*/
}
catch (TrackingCanceledException)
{
sysok = true;
count++;
main.log("Überprüfung zu " + (((float)count / countConnections) * 100) + "% abgeschlossen");
}
if (!sysok)
{
ok = false;
Console.WriteLine("Keine Verbindung zwischen Spieler-Systemen (" + system.name + "->" + system2.name + ")");
break;
}
}
}
}
if (ok)
{
foreach (Solarsystem system in systemList)
{
if (system.planets != null)
foreach (Planet planet in system.planets)
{
game.addPlanet(planet);
}
}
main.log("Map-Datei geladen");
}
else
{
if (recreated < 3)
{
recreated++;
systemList = loadedMap.solarsystems;
usersystems.Clear();
foreach (Solarsystem system in systemList)
{
if (system.userstart)
{
usersystems.Add(system);
}
}
main.modulmanager.nodetracking.setRoutelist(new List<Route>());
main.log("Karte nicht spielbar, erstelle neue Karte ...");
handleData();
}
else
{
main.log("Kartenerstellung abgebrochen!");
}
}
}
public void travel(List<Ship> ships, Route route)
{
int fleet = findFreeFleet();
Solarsystem start = route.start;
Solarsystem end = route.end;
List<TravelData> fleetData = new List<TravelData>();
double speed = double.MaxValue;
foreach (Ship ship in ships)
{
if (ship.speed < speed) { speed = ship.speed; }
}
TravelData neu = new TravelData();
neu.destination = end;
neu.fleet = fleet;
neu.origin = start;
neu.route = route;
neu.speed = speed;
neu.ship = ships;
neu.distance = route.distance;
neu.timeRemaining = route.distance / speed;
travelList.Add(neu);
}
