Add 'route-planning.md'

route-planning.md

@@ -0,0 +1,78 @@
+## Strategia planowania ruchu
+
+### Wykorzystane klasy
+
+AStar - Klasa zawierająca działanie algorytmu.
+AStarState - Klasa zawierająca reprezentację wierzchołka.
+
+### Pętla główna - pseudokod
+
+```
+Jeśli istnieją wierzchołki do odwiedzenia:
+    zwiększamy licznik operacji (stop w razie nieznalezienia rozwiązania po przekroczeniu liczny iteracji)
+    pobieramy pierwszy wierzchołek do odwiedzenia
+    jeśli natomiast jest wierzchołek o mniejszym koszcie to zajmiemy się nim najpierw
+    stop jeśli przekroczyliśmy maksymalną liczbę operacji
+    przenosimy wierzchołek z listy wierzchołków do odwiedzenia do tych już odwiedzonych
+    jeśli nasz aktualny wierzchołek jest końcowym kończymy algorytm
+```
+
+### Pętla główna - kod w python
+
+```
+        while len(toVisit)>0:
+            iterations=iterations+1
+            current = toVisit[0]
+            currentIndeks = 0
+            for indeks, item in enumerate(toVisit):
+                if item.g<current.g:
+                    current = item
+                    currentIndeks = indeks
+            if iterations>max:
+                return self.returnPath(current, grid)
+            visited.append(current)
+            toVisit.pop(currentIndeks)
+            if current==endNode:
+                return self.returnPath(current, grid)
+            #funkcjanastępnika
+```
+
+### Funkcja następnika - pseudokod
+
+```
+Dla listy możliwych ruchów generujemy wszystkie możliwe następniki:
+    sprawdzamy czy taki następnik nie wychodzi poza kratę
+    sprawdzamy czy nie wchodzi on przypadkiem na regał albo ścianę
+    jeśli nie nastąpił żaden z powyższych warunków dodajemy każdy taki następnik do listy
+Dla listy następników:
+    jeśli w odwiedzonych już istnieje taki wierzchołek to go ignorujemy
+    jeśli nie istnieje to obliczamy f, g i h oraz dodajemy taki wierzchołek do listy wierzchołków do odwiedzenia
+```
+
+### Funkcja następnika - kod w python
+
+```
+            for new in moves:
+                positions = (current.position[0]+new[0], current.position[1]+new[1])
+                if (positions[0] > (noRows - 1) or
+                    positions[0] < 0 or
+                    positions[1] > (noColumns - 1) or
+                    positions[1] < 0):
+                    continue
+                if grid[positions[0]][positions[1]]!=0:
+                    continue
+                children.append(AStarState(current, positions))
+            for child in children:
+                if len([visitedChild for visitedChild in visited if visitedChild==child])>0:
+                    continue
+                if child.position[0]<=(len(grid)-4) and child.position[0]>=3 and child.position[1]>=4 and child.position[1]<=(len(grid[0])-1):
+                    child.g = current.g + (10 * cost)
+                else:
+                    child.g = current.g + cost
+                child.h = (((child.position[0]-endNode.position[0]) ** 2) + ((child.position[1]-endNode.position[1]) ** 2))
+                child.f = child.g + child.h
+                if len([i for i in toVisit if child==i and child.g>i.g])>0:
+                    continue
+                toVisit.append(child)
+             children = []
+```