Refactoring

KellerKing · Dec 19, 2020 · aea4dfd · aea4dfd
1 parent 8dfdf89
commit aea4dfd
Show file tree

Hide file tree

Showing 25 changed files with 188 additions and 255 deletions.
diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,3 @@
 .vs
-.\AStar\bin\
+AStar\bin
 AStar/obj/
diff --git a/.vs/AStar/v16/.suo b/.vs/AStar/v16/.suo
diff --git a/.vscode/launch.json b/.vscode/launch.json
diff --git a/AStar/AStar.csproj b/AStar/AStar.csproj
@@ -48,17 +48,17 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Konstanten\ZielsuchErgebnis.cs" />
-    <Compile Include="Logik\AStar.cs" />
     <Compile Include="Controller.cs" />
     <Compile Include="Konstanten\Feldtyp.cs" />
     <Compile Include="FeldFormatierer.cs" />
     <Compile Include="Helper.cs" />
+    <Compile Include="Logik\PathscoreBerechner.cs" />
+    <Compile Include="Logik\ZielChecker.cs" />
     <Compile Include="Transferobjekte\PathScoreDTO.cs" />
     <Compile Include="UI Elemente\MeinRadioButton.cs">
       <SubType>Component</SubType>
     </Compile>
     <Compile Include="RandomMapGenerator.cs" />
-    <Compile Include="Transferobjekte\ListenUpdateDTO.cs" />
     <Compile Include="MainForm.cs">
       <SubType>Form</SubType>
     </Compile>

diff --git a/AStar/Controller.cs b/AStar/Controller.cs
@@ -1,8 +1,7 @@
-using System;
+using AStar.Logik;
+using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 
@@ -11,8 +10,8 @@ namespace AStar
   class Controller
   {
     private List<Feld> m_Spielfeld;
-    private List<Feld> m_OpenList = new List<Feld>(); //Bekommt Felder die geprüft werden müssen
-    private List<Feld> m_ClosedList = new List<Feld>(); //Bereits begangene Felder
+    private List<Feld> m_OpenList = new List<Feld>();
+    private List<Feld> m_ClosedList = new List<Feld>(); 
     private MainForm m_MainForm;
 
     public Controller(MainForm mainForm)
@@ -23,13 +22,13 @@ public Controller(MainForm mainForm)
 
     private void InitForm()
     {
-      var felderProAchse = 12;
-      m_Spielfeld = ViewModelCreator.GetSpielfeld(felderProAchse); //TODO: Feldgröße automatisch berechnen
-      var lastField = m_Spielfeld.First(feld => feld.X == felderProAchse - 1 && feld.Y == felderProAchse - 1);
-      var radButtons = ViewModelCreator.GetRadioButtons(lastField.Width + lastField.Location.X, lastField.Y, 20);
+      var felderProAchse = 16;
+      m_Spielfeld = ViewModelCreator.GetSpielfeld(felderProAchse); 
+      var lastField = m_Spielfeld.First(feld => feld.myPosX == felderProAchse - 1 && feld.myPosY == felderProAchse - 1);
+      var radButtons = ViewModelCreator.GetRadioButtons(lastField.Width + lastField.Location.X, lastField.myPosY, 20);
       var uiButtons = ViewModelCreator.GetButtons(radButtons.Last().Location.X, radButtons.Last().Location.Y, 40);
 
-      var formSize = Helper.CalculateWindowSize(Convert.ToInt32(Math.Sqrt(m_Spielfeld.Count)), 20, 25); //TODO Naming und Klasse mit Groeßsen.
+      var formSize = Helper.CalculateWindowSize(Convert.ToInt32(Math.Sqrt(m_Spielfeld.Count)), 20, 25); 
 
       SetzeUIFelder(uiButtons, formSize, radButtons);
       ConnectEvents(uiButtons);
@@ -57,20 +56,12 @@ private void ConnectEvents(List<Button> uiButtons)
       m_MainForm.BtnZufaelligesSpielfedClicked += SetZufaelligesFeld;
     }
 
-    private void SetZufaelligesFeld()
-    {
-      //TODO: Oder auch nur als ref
-      m_Spielfeld = RandomMapGenerator.GenerateRandomMap(new List<Feld>(m_Spielfeld), 50);
-    }
+    private void SetZufaelligesFeld() => RandomMapGenerator.GenerateRandomMap(m_Spielfeld, 50);
+
+    private void StatusFeldSetzen(Feld currentFeld, Feldtyp currentFeldtyp) => FeldFormatierer.SetSpecialFeld(m_Spielfeld, currentFeld, currentFeldtyp);
+
+    private void BtnClearClicked() => Application.Restart();
 
-    private void StatusFeldSetzen(Feld currentFeld, Feldtyp currentFeldtyp)
-    {
-      FeldFormatierer.SetSpecialFeld(m_Spielfeld, currentFeld, currentFeldtyp);
-    }
-    private void BtnClearClicked()
-    {
-      Application.Restart();
-    }
 
     private async void BtnZumZielClicked()
     {
@@ -79,11 +70,16 @@ private async void BtnZumZielClicked()
 
       if (startfeld == null || zielfeld == null) return;
 
-      //TODO: Wie geht es weiter ? 
-      var zielsucheErgebnis = await Task.Run(() => Pfadfinder.GeheKomplettenWeg(m_Spielfeld, m_OpenList, m_ClosedList, startfeld, zielfeld));
+      var zielsucheErgebnis = await Task.Run(() => Pfadfinder.FindeWegZumZiel(m_Spielfeld, m_OpenList, m_ClosedList, startfeld, zielfeld));
+
+      await Task.Run(() => ZielChecker.FormatiereFallsPfadGefunden(zielsucheErgebnis));
+
+      var neustartAntwort = m_MainForm.ZeigeSpielBeendenDialog(zielsucheErgebnis.Ausgabetext);
 
-      MessageBox.Show(zielsucheErgebnis.Ausgabetext); //TODO: Hier das dann auslagern
-      Application.Restart();
+      if (neustartAntwort == DialogResult.Yes)
+        Application.Exit();
+      else
+        Application.Restart();
     }
   }
 }
diff --git a/AStar/FeldFormatierer.cs b/AStar/FeldFormatierer.cs
@@ -16,7 +16,7 @@ public static void SetSpecialFeld(List<Feld> spielfeld, Feld currentFeld, Feldty
       {
         FormatiereAlsStandardfeld(currentFeld);
       }
-      else
+      else //Wenn Startfeld oder Zielfeld gestzt werden muss geschaut werden ob es die schon gibt, und wenn ja das alte erst entfernen
       {
         var oldSpecialFeld = spielfeld.FirstOrDefault(feld => feld.Feldtyp == currentFeldtyp);
 
@@ -28,7 +28,7 @@ public static void SetSpecialFeld(List<Feld> spielfeld, Feld currentFeld, Feldty
       }
     }
 
-    public static void FormatiereStartOderZielfeld(Feld currentFeld, Feldtyp currentFeldtyp) //TODO: Komplettes Rework 
+    public static void FormatiereStartOderZielfeld(Feld currentFeld, Feldtyp currentFeldtyp)  
     {
       currentFeld.Feldtyp = currentFeldtyp;
 
@@ -60,7 +60,7 @@ public static void FormatiereFinalenPfad(List<Feld> derPfad)
       derPfad.ForEach(feld =>
       {
         feld.BackColor = Color.Blue;
-        feld.Feldtyp = Feldtyp.Pfad;
+        feld.Feldtyp = Feldtyp.FinalerPfad;
       });
     }
   }

diff --git a/AStar/Helper.cs b/AStar/Helper.cs
@@ -1,9 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace AStar
 {
@@ -19,23 +16,52 @@ public static Tuple<int, int> CalculateWindowSize(int anzahlFelderProAchse, int
 
     public static bool IsFeldDiagonalZumVorgaenger(Feld feld)
     {
-      var vorgaengerX = feld.Vorgaenger.X;
-      var vorgaengerY = feld.Vorgaenger.Y;
+      var vorgaengerX = feld.Vorgaenger.myPosX;
+      var vorgaengerY = feld.Vorgaenger.myPosY;
 
-      if (vorgaengerX == feld.X - 1 && vorgaengerY == feld.Y - 1) return true;
-      else if (vorgaengerX == feld.X + 1 && vorgaengerY == feld.Y - 1) return true;
-      else if (vorgaengerX == feld.X + 1 && vorgaengerY == feld.Y + 1) return true;
-      else if (vorgaengerX == feld.X - 1 && vorgaengerY == feld.Y + 1) return true;
+      if (vorgaengerX == feld.myPosX - 1 && vorgaengerY == feld.myPosY - 1) return true;
+      else if (vorgaengerX == feld.myPosX + 1 && vorgaengerY == feld.myPosY - 1) return true;
+      else if (vorgaengerX == feld.myPosX + 1 && vorgaengerY == feld.myPosY + 1) return true;
+      else if (vorgaengerX == feld.myPosX - 1 && vorgaengerY == feld.myPosY + 1) return true;
       else return false;
     }
 
-    public static void ResetSpielfeld(List<Feld> m_Spielfeld) //TODO: Muss ich das wirklich mit Return machen, oder mache ich alles mit byRef
+
+    public static List<Feld> GetBetretbareUmliegendeFelder(List<Feld> spielfeld, Feld currentFeld)
+    {
+      var currentFieldX = currentFeld.myPosX;
+      var currentFieldY = currentFeld.myPosY;
+
+      var maxX = Math.Min(spielfeld.Max(f => f.myPosX), currentFieldX + 1);
+      var minX = Math.Max(currentFieldX - 1, 0);
+
+      var maxY = Math.Min(spielfeld.Max(f => f.myPosY), currentFieldY + 1);
+      var minY = Math.Max(currentFieldY - 1, 0);
+
+      var nearestFields = spielfeld.Where(f => f.myPosX >= minX && f.myPosX <= maxX &&
+                                          f.myPosY >= minY && f.myPosY <= maxY).ToList();
+
+      return nearestFields.Where(f => f.Feldtyp != Feldtyp.Hindernis &&
+                                      f.Feldtyp != Feldtyp.AktuellesFeld).ToList();
+    }
+
+    public static void SetVorgaenger(Feld currentFeld, Feld vorgaengerFeld)
     {
-      foreach (var feld in m_Spielfeld)
+      currentFeld.Vorgaenger = vorgaengerFeld;
+    }
+
+
+    public static List<Feld> GetFinalenPfad(Feld lastFeld)
+    {
+      List<Feld> output = new List<Feld>();
+
+      while (lastFeld.Vorgaenger != null)
       {
-        feld.BackColor = Color.AliceBlue;
-        feld.Feldtyp = Feldtyp.Normal;
+        output.Add(lastFeld);
+        lastFeld = lastFeld.Vorgaenger;
       }
+      return output;
     }
+
   }
 }
diff --git a/AStar/Konstanten/Feldtyp.cs b/AStar/Konstanten/Feldtyp.cs
@@ -1,11 +1,11 @@
 namespace AStar
 {
-    public enum Feldtyp
-    {
-        Zielfeld,
-        AktuellesFeld,
-        Hindernis,
-        Pfad,
-        Normal
-    }
+  public enum Feldtyp
+  {
+    Zielfeld,
+    AktuellesFeld,
+    Hindernis,
+    Normal,
+    FinalerPfad
+  }
 }
diff --git a/AStar/Logik/AStar.cs b/AStar/Logik/AStar.cs