AI/route-planning.md

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 = []