# A-Stern Implementierung



## Eichelhäer (16. Okt 2016)

Hallo,

habe nach langer Zeit mal wieder Zeit fürs programmieren gefunden und möchte nochmal was wissen zum A-Stern Algorithmus:

Hier zunächst mal meine KnotenKlasse:


```
public class Knoten {

    private int x,y;
    private Knoten elternknoten;
    private double f_kosten;
    private double g_kosten;
    private double h_kosten;
   
    public Knoten(int x,int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public Knoten getElternknoten() {
        return elternknoten;
    }

    public double getF_kosten() {
        return f_kosten;
    }

    public double getG_kosten() {
        return g_kosten;
    }

    public double getH_kosten() {
        return h_kosten;
    }
```
und meine AStern Klasse:

```
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.TreeSet;

public class AStern {

    public List<Knoten> path(Knoten startKnoten,Knoten zielKnoten){
       
        TreeSet<Knoten> openList = new TreeSet<Knoten>();
        HashSet<Knoten> closedList = new HashSet<Knoten>();
        openList.add(startKnoten);
        while(!openList.isEmpty()){
            Knoten current = openList.first();
            if(current == zielKnoten){
                ArrayList<Knoten> path = new ArrayList<Knoten>();
                Knoten temp = zielKnoten;
                while(temp!=null){
                    path.add(0,temp);
                    temp = temp.getElternknoten();
                }
                return path;
            }
            closedList.add(current);
            Knoten[] nachbarn = getNachbarn(current);
            for(Knoten test : nachbarn){
               
            }
        }
        return null;
    }
   
    public Knoten[] getNachbarn(Knoten current){
        Knoten[] nachbar = new Knoten[8];
        nachbar[0] = new Knoten(current.getX()-1,current.getY());
        nachbar[1] = new Knoten(current.getX()+1,current.getY());
        nachbar[2] = new Knoten(current.getX()-1,current.getY()-1);
        nachbar[3] = new Knoten(current.getX()+1,current.getY()+1);
        nachbar[4] = new Knoten(current.getX()-1,current.getY());
        nachbar[5] = new Knoten(current.getX()+1,current.getY());
        nachbar[6] = new Knoten(current.getX()+1,current.getY()-1);
        nachbar[7] = new Knoten(current.getX()-1,current.getY()+1);
        return nachbar;
    }
}
```

Ich weiss hier in dem for-Loop nicht weiter. Eigentlich muss man doch hier von den NachbarKnoten den Knoten mit den geringsten Kosten herausfinden und das weiss ich irgendwie nicht. Ich denke mal, dass man die Schätzkosten mit dem Paythagoras ausrechnen kann aber mehr weiss ich dann auch nicht.

Ich hoffe mein Code ist bis hierher einigermaßen pasabel, wenn nicht bitte sagen und mich auf den(die) Fehler hinweisen.

Wäre für Hilfe dankbar

Gruß Eichelhaer


----------



## Eichelhäer (17. Okt 2016)

Ich hab jetzt mal weitergemacht, so wie ich es verstanden habe, mit dem Ergebnis, dass ein Fenster aufpoppt und nix passiert, weder mein aus Rechtecken bestehendes Spielfeld wird angezeigt noch wird irgendeine Fehlermeldung ausgegeben.

Das steht jetzt in der erweiterten for-Schleife:


```
if(closedList.contains(k))continue;
                double gcost = current.gcost+getDistance(current,k);
                if(openList.contains(k)&&gcost>=k.gcost)continue;
                k.setEltern(current);
                k.setGcost(gcost);
                double f = gcost + getDistance(k,ziel);
                openList.remove(k);
                k.setFcost(f);
                openList.add(k);
```

Jemand eine Erklärung dafür?


----------



## Eichelhäer (28. Apr 2017)

Hat sich erledigt.


----------



## Jardcore (28. Apr 2017)

Ich würde empfehlen diese Video anzuschauen:


----------

