From 6102da73fa9ab3852194d923ed034dfdcec0f6b9 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Sat, 16 Feb 2019 14:17:12 +0100
Subject: [PATCH] Finish 3.1.2

---
 Projektgruppe_175/src/game/map/GameMap.java | 37 +++++++++++++++----
 doc/Dokumentation.tex                       | 41 +++++++++++++++++----
 2 files changed, 63 insertions(+), 15 deletions(-)

diff --git a/Projektgruppe_175/src/game/map/GameMap.java b/Projektgruppe_175/src/game/map/GameMap.java
index 41c5c5f..66da120 100644
--- a/Projektgruppe_175/src/game/map/GameMap.java
+++ b/Projektgruppe_175/src/game/map/GameMap.java
@@ -154,15 +154,26 @@ public class GameMap {
     private void generateEdges() {
 
     	List<Node<Castle>> castleNodes = castleGraph.getNodes();
-    	/*
-    	for (int i = 0; i < castleNodes.size(); i++) {
-    		if (i == castleNodes.size() - 1)
-    			castleGraph.addEdge(castleNodes.get(i), castleNodes.get(0));
-    		else
-    			castleGraph.addEdge(castleNodes.get(i), castleNodes.get(i+1));
-    	}*/
+    	
+    	if (castleNodes.isEmpty())
+    		return;
+    	
+    	// Stage 1
+    	List<Node<Castle>> remainingCastles = new ArrayList<Node<Castle>>(castleNodes);
+    	Node<Castle> castleToConnect = remainingCastles.remove(0);
+    	while (!remainingCastles.isEmpty()) {
+    		
+    		Node<Castle> nearestCastle = nearestCastle(castleToConnect, remainingCastles);
+    		
+    		castleGraph.addEdge(castleToConnect, nearestCastle);
+    		
+    		castleToConnect = nearestCastle;
+    		remainingCastles.remove(castleToConnect);
+    		
+    	}
 
-    	final double radius = 300.0;
+    	// Stage 2
+    	final double radius = 170.0;
     	
     	for (Node<Castle> cast : castleNodes) {
     		for (Node<Castle> c : allCastlesInRadius(cast, castleNodes, radius))
@@ -171,6 +182,16 @@ public class GameMap {
     
     }
     
+    private Node<Castle> nearestCastle(Node<Castle> castle, List<Node<Castle>> allCastles) {
+    	
+    	return allCastles.stream()
+    			.min((x, y) -> Double.compare(
+    					castle.getValue().distance(x.getValue()),
+    					castle.getValue().distance(y.getValue())))
+    			.get();
+    	
+    }
+    
     private List<Node<Castle>> allCastlesInRadius(Node<Castle> castle, List<Node<Castle>> allCastles, double r) {
     	
     	return allCastles.stream()
diff --git a/doc/Dokumentation.tex b/doc/Dokumentation.tex
index cafd0e0..50c667c 100644
--- a/doc/Dokumentation.tex
+++ b/doc/Dokumentation.tex
@@ -36,7 +36,25 @@
 	\end{algorithm}
 
 	% Erklärung des Algorithmus
-	
+	Der Algorithmus ist in zwei Schritte aufgeteilt:
+	\begin{itemize}
+		\item Minimale Verbindung von allen Burgen
+		\item Ästhetische Verbesserung der Kanten
+	\end{itemize}
+
+	Die minimale Verbindung aller Burgen erfolgt, indem
+	sichergestellt wird, dass jede Burg mit einer anderen
+	verbunden ist und dass alle Burgen in einer gemeinsamen
+	Verbindung zusammenhängen. Der Algorithmus fängt bei
+	einer bestimmten Start-Burg an und verbindet diese Burg
+	mit der nächstliegenden Burg, die noch nicht verbunden
+	wurde. Daraufhin wird das gleiche mit der nächsten,
+	übernächsten, usw. Burg getan, bis die letzte Burg erreicht
+	wurde. Zu diesem Zeitpunkt sind alle Burgen durch eine
+	Linie verbunden.
+
+	Die Ästhetische Verbesserung erfolgt, indem alle Burgen
+	im Umkreis einer Burg durch eine Kante verbunden werden.
 
 	\subsection{Überprüfung der Erreichbarkeit aller Knoten}
 
@@ -68,21 +86,30 @@
 		\end{algorithmic}
 	\end{algorithm}
 
+	Der Algorithmus verwendet zwei unterschiedliche Datentypen:
+	
+	\begin{itemize}
+		\item HashSet wird verwendet, um die bisher
+		besuchten Knoten zu speichern.
+		\item ArrayDeque wird verwendet, um die nächsten
+		Knoten, die besucht werden, zu speichern.
+	\end{itemize}
+
 	Der Algorithmus sammelt sozusagen alle Knoten, die 
 	aufgrund von momentanen Erkenntnissen erreichbar
-	sind, in der Liste \texttt{nextVisitNodes}. Hingegen sind
-	alle Knoten, die schon erreicht worden sind, in der Liste
+	sind, in der ArrayDeque \texttt{nextVisitNodes}. Hingegen sind
+	alle Knoten, die schon erreicht worden sind, in dem HashSet
 	\texttt{allVisitedNodes} gespeichert. 
 	
-	Der Algorithmus geht die Liste \texttt{nextVisitNodes}
+	Der Algorithmus geht die ArrayDeque \texttt{nextVisitNodes}
 	solange durch, bis diese leer ist. In jeder Iteration wird
 	das erste Element der Liste aus der Liste entfernt. 
-	Zunächst wird dieses Element der Liste \texttt{allVisitedNodes} 
+	Zunächst wird dieses Element dem HashSet \texttt{allVisitedNodes} 
 	hinzugefügt. Daraufhin
 	werden die Nachbarn dieses Elements herausgefunden. Diejenigen
-	Nachbarn, die schon in der Liste \texttt{allVisitedNodes}
+	Nachbarn, die schon in dem HashSet \texttt{allVisitedNodes}
 	vorhanden sind, werden verworfen. Die restlichen Nachbarn
-	werden der Liste \texttt{nextVisitNodes} hinzugefügt.
+	werden der ArrayDeque \texttt{nextVisitNodes} hinzugefügt.
 
 	\subsection{Wege finden}