Einem A*-Pfad folgen

Eichelhäer

Bekanntes Mitglied
Hallo,

mal wieder geht's um den A* nach sehr langer Arbeit daran, habe ich ihn jetzt endlich fertiggestellt.

Leider hat sich wieder ein neues Problem aufgetan.
Ich möchte nun, dass sich Einheiten ( mir reicht auch schon mal eine einzige ) als eine Art Figur, entlang des ermittelten Pfades bewegen.

Das ist allerdings alles nicht so einfach wie ich dachte. Zwar möchte ich schon wissen wie das funktioniert, allerdings tauchen mehrere Probleme auf.

1. Wie genau muss das Spielfeld aufgebaut sein, um Einheiten überhaupt wie gewohnt mit der üblichen Formel zu bewegen?
2. Mein A* verwendet Nachbarn, die genau 1x1 sind. Wie verhindert man dann Performanceprobleme bei größeren Spielfeldern?
3. (Analog zu 2 ) Gibt es noch andere Ansätze die zum Erfolg führen?

Nun nochmal etwas konkreteres:

Ich habe meinen Pfad in einer Liste, der via Mausklick auf das Spielfeld generiert und gezeichnet wird.

Das heißt ich kann auf jedes Element der Pfadliste zugreifen.
Natürlich weiß ich, dass ich nun meiner Einheit einfach nur die Position von den Elementen aus dem Pfad zuweisen müsste, allerdings klappt das nicht so ganz.
Denn, nachdem die Einheit das Ende des ersten Pfadelements der Liste erreicht hat, stürzt das gesamte Programm ab, ohne Fehlermeldung in der Konsole, aber mit Fehlermeldung von Windows.
Normalerweise lernt man ja aus Fehlern, aber wenn man nicht weiß, was genau der Fehler ist, wird es schwierig.

Also nochmal zusammengefasst:

In einer Methode move() soll eine Einheit entlang des ermittelten Pfades grafisch bis zum Ziel bewegt werden. Wie erreicht man das?

Hier mal meine fehlerhafte move()-Methode:
Code:
public void move(){
       
        if(Mouse.right){
            int startx = x / size;
            int starty = y / size;
            int endx = (Mouse.mousex-(Mouse.mousex%size))/size;
            int endy = (Mouse.mousey-(Mouse.mousey%size))/size;
           
            path = findPath(startx,starty,endx,endy);
        }
       
       
        if(path!=null){
            if(path.size() > 0){
                Node node = path.get(path.size()-1);
                x = node.i*size;
                y = node.j*size;
               
            }
        }
    }

Wie ordnet man die Positionen des Pfades besser den Positionen der Einheit zu und warum stürtzt das gesamte Programm ab?

Gruß Eichelhäer
 

Eichelhäer

Bekanntes Mitglied
X,Y,path und size sind global deklarierte und initialisierte Variablen dieser Klasse, also ich kann in jeder Methode der Klasse darauf zugreifen.
 

Eichelhäer

Bekanntes Mitglied
Das ist ja das Problem. Es kommt keine Fehlermeldung in Eclipse auch nicht beim Debugging, sondern WINDOWS beendet die JVM.

Das ist der entsprechende Codeteil. Erst wenn ich versuche den x-bzw y-Werten die Pfadkoordinaten zuzuweisen stürzt alles ab. Ohne das läuft alles prima.
 

Eichelhäer

Bekanntes Mitglied
Wenn Sie mir wirklich helfen wollen, werde ich ihnen den Code (3 Dateien) persönlich senden, ABER nicht hier posten. Geben Sie mir hierfür eine E-Mail Adresse oder Skype Namen.
 

VfL_Freak

Top Contributor

mrBrown

Super-Moderator
Mitarbeiter
Als was sind x und y denn deklariert?
Benutzt du irgendein Framework?
Welche Fehlermeldung kommt von Windows?
 

Eichelhäer

Bekanntes Mitglied
Hallo nochmal,
ich weiß jetzt woran es liegt.
Hier mal die überarbeitete move()-Methode:
Code:
path = findPath(0,0,14,14);
       
        
  endx = (Mouse.mousex-(Mouse.mousex%size))/size;
  endy = (Mouse.mousey-(Mouse.mousey%size))/size;

        if(path!=null){
            if(path.size() > 0){
                Collections.reverse(path);
                Node node = path.get(k);
                if(node.j*size > y)y++;
                if(node.j*size < y)y--;
                if(node.i*size > x)x++;
                if(node.i*size < x)x--;
                if(y == node.j*size && x == node.i*size)k++;
                if(k == path.size())k=path.size()-1;
                System.out.println(k);
            }
           
        }

Das läuft optimal. Die Einheit folgt dem Pfad wie gewünscht.
Das Problem liegt bei den Einheitskoordinaten.
Ich möchte nämlich per Mausklick bestimmen können, wo sich die Einheit hinbewegen soll.
Nun hat das Spielfeld, das als 2-dimensionales Array definiert ist, 15 Spalten und 15 Zeilen.
Der path möchte nur Kachelkoordinaten, während die Koordinaten der Einheit absolut sind.
Ich möchte sowas in der Art machen, dass ich dem path die Koordinaten der Einheit gebe, sodass sich die Länge des Pfades verkürzt, sobald ich das jeweils nächste Element aus path passiere, um ausgehend vom gerade passierten Pfadelement einen neuen Pfad berechnen zu können, eben wie man es aus diversen Spielen kennt.
Dazu muss ich für den path die Koordinaten der Einheit zur Laufzeit umrechnen in Kachelkoordinaten, sonst bekomme ich eine OutOfBoundsException, da das Spielfeld nur Werte zwischen 0 und 15 annehmen kann.
Wie macht man das?

Gruß Eichelhäer
 

VfL_Freak

Top Contributor
Moin,
Wie macht man das?
Keine Ahnung :cool:

Aber was mir in Deinem Text auffällt:
2-dimensionales Array definiert ist, 15 Spalten und 15 Zeilen
bekomme ich eine OutOfBoundsException, da das Spielfeld nur Werte zwischen 0 und 15 annehmen kann
bei jeweils 15 Spalten und Zeilen darf das Spieldfeld aber nur Werte zwischen 0 und 14 (!!) annehmen, daher vermutlich die OoB-Exception ...

Gruß Klaus
 

Eichelhäer

Bekanntes Mitglied
Ja das ist natürlich korrekt, aber selbst wenn das Array 15 Werte annehmen könnte würde es nicht gehen, da die Kacheln auf meinem Spielfeld 32x32 groß sind und wenn ich dem path die absolute Koordinate der Einheit geben würde, wäre bei 1 Schluss, denn path meint die nächste Kachel, während die Einheit absolute Koordinaten hat.
 

mrBrown

Super-Moderator
Mitarbeiter
ich weiß jetzt woran es liegt.
Und woran liegt es, das die JVM ohne Fehlermeldung abstürzt?

Ja das ist natürlich korrekt, aber selbst wenn das Array 15 Werte annehmen könnte würde es nicht gehen, da die Kacheln auf meinem Spielfeld 32x32 groß sind und wenn ich dem path die absolute Koordinate der Einheit geben würde, wäre bei 1 Schluss, denn path meint die nächste Kachel, während die Einheit absolute Koordinaten hat.
Wenn eine Kachel 32x32 ist, dann einfach die absoluten werte durch 15 teilen, dann hast du die Kachel. Von Kachel zu Koordinaten dann mal 15.
 

Eichelhäer

Bekanntes Mitglied
Ok, ich weiß leider nicht exakt was in der JVM passiert, so gut kenne ich mich auch wieder nicht aus, aber was im Quellcode passiert schon eher.
Also gehen wir mal kurz die von mir gepostete Methode move() durch:

1. Zeile: der Pfad wird ausgehend von der startx-bzw. startyposition 0 bis zur endx-bzw. endyposition ermittelt und gezeichnet. Im Prinzip ist es bei mir schlicht und ergreifend so, dass mein Spielfeld ein zweidimensionales Array ist, mit 15 Spalten und 15 Zeilen und nur beim Zeichnen die einzelnen Element auf 32x32, durch Multiplikation, gebracht werden und ich eigentlich nur ein 15x15 Pixel großes Spielfeld habe, bei dem der A* praktisch nur die einzelnen Pixel verwendet. Ich skaliere dieses kleine Spielfeld beim Zeichnen einfach nur.

2. Zeile: mithilfe der beiden Variablen endx bzw. endy rechne ich zur Laufzeit die absoluten Mauskoordinaten um in Kachelkoordinaten. Die size-Variable bezieht sich auf die 32x32 großen Kacheln.

3. Zeile: hier überprüfe ich einfach nur ob ein Pfad existiert und
4. Zeile: ob eine Laufvariable k kleiner ist als die Länge des Pfades. Also if(k<path.size())... .
5.Zeile: hier drehe ich die Liste um, also ich fange nicht beim Index path.size()-1 an sondern, was denke ich einfacher ist aber im Endeffekt keine Rolle spielt, bei 0.
6.Zeile: jetzt hole ich mir mithilfe der Laufvariablen k das erste Element der Liste und
7. 8. 9. 10. Zeile: überprüfe z.B. ob der x-Wert dieses Elements größer ist als der x-Wert der bewegten Einheit, wenn dem so ist erhöhe ich die absolute Position in Pixeln um eins und, wenn
11. Zeile: diese Position dann genau so groß ist wie der x-Wert des k-ten Elements der path-Liste dann erhöhe ich k um eins. Das geschieht eben solange wie eben k < die Länge der pathListe ist.

Da mein Ziel nun eigentlich ist beliebig oft auf dem Spielfeld umherzulaufen, habe ich mir gedacht, dass direkt vor der Erhöhung von k, der Pfad um ein Element kleiner wird, bis die startposition genau die endposition ist, sodass ich den Pfad immer wieder und beliebig oft berechnen kann.
UND HIER LIEGT MEIN PROBLEM,
Bisher habe ich versucht startx- bzw. starty abhängig von der absoluten Position der Einheit zu verändern und genau da müsste ich von der absoluten- in die Kachelkoordinate umrechnen und jeder meiner Versuche das zu tun führte zum Absturz der JVM mit dem Windowsfehler usw. .

Also, jetzt habe ich alles, so hoffe ich, gut erklärt und frage nochmal:

Wie muss man die startposition abhängig von den bereits gegebenen Variablen anpassen ?
 

mrBrown

Super-Moderator
Mitarbeiter
Also gehen wir mal kurz die von mir gepostete Methode move() durch:

1. Zeile: der Pfad wird ausgehend von der startx-bzw. startyposition 0 bis zur endx-bzw. endyposition ermittelt und gezeichnet. Im Prinzip ist es bei mir schlicht und ergreifend so, dass mein Spielfeld ein zweidimensionales Array ist, mit 15 Spalten und 15 Zeilen und nur beim Zeichnen die einzelnen Element auf 32x32, durch Multiplikation, gebracht werden und ich eigentlich nur ein 15x15 Pixel großes Spielfeld habe, bei dem der A* praktisch nur die einzelnen Pixel verwendet. Ich skaliere dieses kleine Spielfeld beim Zeichnen einfach nur.

2. Zeile: mithilfe der beiden Variablen endx bzw. endy rechne ich zur Laufzeit die absoluten Mauskoordinaten um in Kachelkoordinaten. Die size-Variable bezieht sich auf die 32x32 großen Kacheln.

3. Zeile: hier überprüfe ich einfach nur ob ein Pfad existiert und
4. Zeile: ob eine Laufvariable k kleiner ist als die Länge des Pfades. Also if(k<path.size())... .
5.Zeile: hier drehe ich die Liste um, also ich fange nicht beim Index path.size()-1 an sondern, was denke ich einfacher ist aber im Endeffekt keine Rolle spielt, bei 0.
6.Zeile: jetzt hole ich mir mithilfe der Laufvariablen k das erste Element der Liste und
7. 8. 9. 10. Zeile: überprüfe z.B. ob der x-Wert dieses Elements größer ist als der x-Wert der bewegten Einheit, wenn dem so ist erhöhe ich die absolute Position in Pixeln um eins und, wenn
11. Zeile: diese Position dann genau so groß ist wie der x-Wert des k-ten Elements der path-Liste dann erhöhe ich k um eins. Das geschieht eben solange wie eben k < die Länge der pathListe ist.

Das ist nicht der von dir gepostete Code.
In deinem Code gibt es keine Schleifen mit Laufvariable k


Bisher habe ich versucht startx- bzw. starty abhängig von der absoluten Position der Einheit zu verändern und genau da müsste ich von der absoluten- in die Kachelkoordinate umrechnen und jeder meiner Versuche das zu tun führte zum Absturz der JVM mit dem Windowsfehler usw. .
Was hast du denn versucht?
Mit einfachem Rechner bringt man die JVM nicht zum Absturz...
 

Eichelhäer

Bekanntes Mitglied
Ahh ok sorry,
Code:
int k = 0;
public void move(){
       
        if(Mouse.right){
            endx = (Mouse.mousex-(Mouse.mousex%w))/w;
            endy = (Mouse.mousey-(Mouse.mousey%h))/h;
        }
       
        path = findPath(startx,starty,endx,endy);
       
        if(path!=null){
           
            if(k < path.size()){
                Node node = path.get(k);
                if(node.j*h > y)y++;
                if(node.j*h < y)y--;
                if(node.i*w > x)x++;
                if(node.i*w < x)x--;
                if(x == node.i*w && y == node.j*h){
                    k++;
                }
            }
        }
    }

Das ist jetzt der aktualisierte Code. Sorry nochmal.
Zu meinen Versuchen:
Zum einen habe ich versucht abhängig von der Einheitenposition startx bzw. starty zu erhöhen bzw. zu vermindern und zum anderen kurz vor der Erhöhung von k, das passierte Element der path-List mittels remove zu entfernen.
Beides ging schief und alles stürzte ab.
 

Eichelhäer

Bekanntes Mitglied
Ach ja noch was vergessen:
Ich muss die Liste jetzt nicht mehr umdrehen das hat sich erledigt.
Und außerdem habe ich gerade was verstanden und erfolgreich umgesetzt, nämlich wie man ein Spielfeld performant umsetzt, deshalb stehen jetzt hier w und h drin. Die beiden Variablen werden abhängig von der Fenstergröße und den Spalten und Zeilen des Spielfeldes berechnet. Das heißt je größer die Werte der Spalten bzw. Zeilen sind, desto kleiner sind die Kacheln, die gezeichnet auf dem Bildschirm erscheinen.
 

Eichelhäer

Bekanntes Mitglied
Der erste Codeversuch:
Code:
public void move(){
       
        if(Mouse.right){
            endx = (Mouse.mousex-(Mouse.mousex%w))/w;
            endy = (Mouse.mousey-(Mouse.mousey%h))/h;
        }
       
        path = findPath(startx,starty,endx,endy);
       
        if(path!=null){
           
            if(k < path.size()){
                Node node = path.get(k);
                if(node.j*h > y)y++;
                if(node.j*h < y)y--;
                if(node.i*w > x)x++;
                if(node.i*w < x)x--;
                if(x == node.i*w && y == node.j*h){
                    startx = node.i;
                    starty = node.j;
                    k++;
                }
            }
        }
    }

Führt dazu, dass sich die Einheit auf das erste Element des Pfades bewegt und sich dann nicht mehr weiter bewegt. Kein Windows Fehler.

Zweiter Versuch:
Code:
public void move(){
       
        if(Mouse.right){
            endx = (Mouse.mousex-(Mouse.mousex%w))/w;
            endy = (Mouse.mousey-(Mouse.mousey%h))/h;
        }
       
        path = findPath(startx,starty,endx,endy);
       
        if(path!=null){
           
            if(k < path.size()){
                Node node = path.get(k);
                if(node.j*h > y)y++;
                if(node.j*h < y)y--;
                if(node.i*w > x)x++;
                if(node.i*w < x)x--;
                if(x == node.i*w && y == node.j*h){
                    path.remove(k);
                    k++;
                }
            }
        }
    }

Es passiert nix d.h. kein Element des Pfades wird gelöscht und
Hhhhhhh ich muss grad lachen, weil ich es jetzt nicht mehr schaffe gewollt diesen Totalabsturz herbeizuführen, ich weiß nicht mehr was ich da gemacht hatte, aber es lag an startx und starty soviel ist sicher.
Egal.
 

Eichelhäer

Bekanntes Mitglied
Sooo, ich poste jetzt hier mal den gesamten Code. Es sind zwei relevante Klassen:

Code:
package main;

import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Level{
   
    public int x;
    public int y;
   
    public int k;
   
    public int w;
    public int h;
   
    public int cols = 50;
    public int rows = 50;
   
    public int startx;
    public int starty;
   
    public Node[][] grid = new Node[cols][rows];
   
    List<Node> openList = new ArrayList<Node>();
    List<Node> closedList = new ArrayList<Node>();
    List<Node> path = new ArrayList<Node>();
   
    Node start;
    Node end;
    Node node;
   
    public Level(int WIDTH,int HEIGHT){

        w = WIDTH / cols;
        h = HEIGHT / rows;
       
        for(int i = 0;i<cols;i++){
            for(int j = 0;j<rows;j++){
                grid[i][j] = new Node(i,j);
            }
        }
       
        for(int i = 0;i<cols;i++){
            for(int j = 0;j<rows;j++){
                grid[i][j].addNeighbours(grid);
            }
        }
    }
   
    public ArrayList<Node> findPath(int sx,int sy,int ex,int ey){
       
        start = grid[sx][sy];
        end = grid[ex][ey];
       
        openList.add(start);
       
        while(openList.isEmpty()==false){
           
            int winner = 0;
            for(int i = 0;i <openList.size();i++){
                if(openList.get(i).f < openList.get(winner).f){
                    winner = i;
                }
            }
           
            Node current = openList.get(winner);
            openList.remove(current);
            closedList.add(current);
           
            if(current == end){
                ArrayList<Node> path = new ArrayList<Node>();
                Node tmp = current;
                path.add(tmp);
                while(tmp.previous!=null){
                    path.add(tmp.previous);
                    tmp = tmp.previous;
                }
                openList.clear();
                closedList.clear();
                Collections.reverse(path);
                return path;
            }
           
            List<Node> neighbours = current.neighbours;
           
            for(Node neighbour : neighbours){
                int cost = current.g + heuristic(current,neighbour);
                if(openList.contains(neighbour) && cost < neighbour.g){
                    openList.remove(neighbour);
                }
                if(closedList.contains(neighbour) && cost < neighbour.g){
                    closedList.remove(neighbour);
                }
                if(openList.contains(neighbour) == false && closedList.contains(neighbour) == false && neighbour.obstacle == false){
                    neighbour.g = cost;
                    openList.add(neighbour);
                    neighbour.f = neighbour.g + neighbour.h;
                    neighbour.previous = current;
                }
            }
        }
       
        return null;
    }
   
    public void render(Graphics g){
        if(Mouse.right){
        int endx = (Mouse.mousex-(Mouse.mousex%w))/w;
        int endy = (Mouse.mousey-(Mouse.mousey%h))/h;
       
        path = findPath(0,0,endx,endy);
        }
        if(path!=null){
            if(path.size() > k){
                node = path.get(k);
                if(node.j*h > y)y++;
                if(node.j*h < y)y--;
                if(node.i*w > x)x++;
                if(node.i*w < x)x--;
                if(x == node.i*w && y == node.j*h){
                    k++;
                }
            }
        }
       
        for(int i = 0;i<cols;i++){
            for(int j = 0;j<rows;j++){
               
                if(grid[i][j].obstacle){
                    g.setColor(Color.BLACK);
                    g.fillRect(grid[i][j].i*w,grid[i][j].j*h,w,h);
                }
                if(!grid[i][j].obstacle){
                    g.setColor(Color.BLACK);
                    g.drawRect(grid[i][j].i*w,grid[i][j].j*h,w,h);
                }
            }
        }
       
        for(int i = 0;i<openList.size();i++){
            g.setColor(Color.GREEN);
            g.fillRect(openList.get(i).i*w,openList.get(i).j*h,w,h);
        }
       
        for(int i = 0;i<closedList.size();i++){
            g.setColor(Color.RED);
            g.fillRect(closedList.get(i).i*w,closedList.get(i).j*h,w,h);
        }
       
        for(int i = 0;i<path.size();i++){
            g.setColor(Color.BLUE);
            g.fillRect(path.get(i).i*w,path.get(i).j*h,w,h);
        }
       
        g.setColor(Color.CYAN);
        g.fillRect(x,y,w,h);
    }
   
    public int heuristic(Node A,Node B){
        // 4-Direction-Manhattendistance
        int dx = Math.abs(A.i-B.i);
        int dy = Math.abs(A.j-B.j);
        return 1 * (dx + dy);
       
        // 8-Direction-Chebyshevdistance
        //int dx = Math.abs(A.i-B.i);
        //int dy = Math.abs(A.j-B.j);
        //return 1 * (dx + dy) + ( 1 - 2 * 1) * Math.min(dx,dy);
       
        // 8-Direction-Octiledistance
        //int dx = Math.abs(A.i-B.i);
        //int dy = Math.abs(A.j-B.j);
        //return 1 * (dx + dy) + ( Math.sqrt(2) - 2 * 1) * Math.min(dx,dy);
       
        // Euclidiandistance
        //int dx = Math.abs(A.i-B.i);
        //int dy = Math.abs(A.j-B.j);
        //return 1 * Math.sqrt(dx * dx + dy * dy);
    }
}


package main;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Node{
public int i;
public int j;
public int g;
public int h;
public int f;
public List<Node> neighbours;
public Node previous;
public boolean obstacle;
public Random random = new Random();

public Node(int i,int j) {
this.i = i;
this.j = j;
this.g = 0;
this.h = 0;
this.f = 0;
this.previous = null;
this.obstacle = false;
this.neighbours = new ArrayList<Node>();

if(random.nextInt(100) < 10){
this.obstacle = true;
}
}

public List<Node> addNeighbours(Node[][] grid){

int i = this.i;
int j = this.j;

if(i < 50 - 1){
neighbours.add(grid[i+1][j]);
}
if(i > 0){
neighbours.add(grid[i-1][j]);
}
if(j < 50 - 1){
neighbours.add(grid[j+1]);
}
if(j > 0){
neighbours.add(grid[j-1]);
}

return neighbours;

}
}

Dieser Code ist z.B. in ECLIPSE ausführbar.
Jetzt nochmal zu dem Totalabsturz:
Wenn man in der render Methode der Level Klasse die bestehende Zeile durch:

path = findPath(x,y,endx,endy);

ersetzt, kommt z.B. ein Totalabsturz.

Und noch was: Bevor jemand fragen sollte warum ich den A* in der render - Methode aufrufe, kann ich nur sagen, dass das für diese kleine Testapplikation völlig ausreichend ist und ich erst später ein vernünftigeres GameLoop implementieren werde. Es geht mir hierbei erstmal nur rein um die Funktionalität des Algorithmus.

Nochmal zu meiner ursprünglichen Frage, wie erreiche ich, dass wenn ich ein Feld anklicke die Einheit dorthin "fährt" und während der "Fahrt" ein durch erneutem Klick ein neuer Pfad ermittelt werden kann und das beliebig oft und die Einheit stets den aktuell erzeugten neuen Pfad "abfährt" ??????????
 

mrBrown

Super-Moderator
Mitarbeiter
Und noch was: Bevor jemand fragen sollte warum ich den A* in der render - Methode aufrufe, kann ich nur sagen, dass das für diese kleine Testapplikation völlig ausreichend ist und ich erst später ein vernünftigeres GameLoop implementieren werde. Es geht mir hierbei erstmal nur rein um die Funktionalität des Algorithmus.

Nochmal zu meiner ursprünglichen Frage, wie erreiche ich, dass wenn ich ein Feld anklicke die Einheit dorthin "fährt" und während der "Fahrt" ein durch erneutem Klick ein neuer Pfad ermittelt werden kann und das beliebig oft und die Einheit stets den aktuell erzeugten neuen Pfad "abfährt" ??????????

Indem du die Pfadberechnung jetzt schon auslagerst, und nicht erst später ;)

Du berechnest beim Klicken den aktuellen Pfad, speicherst den, und alle x ms bewegst du die Figur auf das nächste Feld des Pfades.
Beim Klicken auf ein neues Feld einfach nur den Pfad neu berechnen und speichern.
 

Eichelhäer

Bekanntes Mitglied
Aha, der Vfl_Freak kann auch normal kommunizieren:)... Egal. ....
Der Code den du zitiert hast führt ja zu dem relativ krassen Fehler. Wenn du nun die eigentliche Bewegung betrachtest stellst du fest, dass die einzelnen Elemente des Pfades im Prinzip bloß die Kachelpositionen des grids darstellen, während x und y die absoluten Pixelkoordinaten sind. So. Nun passiert bei dem Fehler folgendes: Die findPath Methode ist abhängig vom grid und will deshalb nur Kachelkoordinaten, mit x und y übergebe ich aber absolute Koordinaten. Die findPath Methode erhält nach der Erhöhung von x bzw. y den Wert 1 für x bzw. y und meint dann damit aber tatsächlich die Kachelposition (hier: 1,0) . Das wäre alles nicht so schlimm wenn ich meine drawRect Methode anpassen würde. Wenn ich das NICHT tue, dann kommt es zu einem Konflikt zwischen absoluten und Kachelkoordinaten und genau das löst den Fehler beim Zeichnen aus und ich habe tatsächlich keine Ahnung wie die drawRect Methode intern arbeitet.

Ich hoffe du verstehst was ich da versucht habe zu erklären.
Wennnicht frag einfach nochmal.
 

Eichelhäer

Bekanntes Mitglied
Ach und noch was prinzipielles an die Adresse von Vfl_Freak:
Wenn du etwas an meiner Frage nicht verstehst, ist das kein Problem, aber tatsächlich hast du fünf mal geantwortet und hast mir damit auf überhaupt keine Art und Weise irgendwie weiterhelfen können.
Im Grunde genommen waren deine fünf zu diesem Thema gegebenen Antworten für mich total überflüssig
und alles andere als konstruktiv für mein Thema.
Also, für das nächste Mal: Erst lesen dann denken und dann posten.
 

Eichelhäer

Bekanntes Mitglied
An MrBrown:
Hmm... . Eigentlich nicht. Denn x wird z.B. eins und offensichtlich befindet sich der Wert eins im sichtbaren Bereich denke ich.
Also:
x und y sind 0 der path wird erzeugt k ist 0 , k wird erhöht, das Element des Pfades wird mit der absoluten Position x bzw. y verglichen und x wird inkrementiert. x wird an drawRect übergeben dann Absturz.
 

Eichelhäer

Bekanntes Mitglied
Hallo,
ich mache es kurz, ich habe es so wie ich wollte.
Es lag daran, dass das Spielfeld zur Laufzeit bekannt sein muss und das ist alles.
Damit ist dieses Thema geschlossen.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
E Rendering order auf einem ismetrischen Grid Spiele- und Multimedia-Programmierung 8
P Wie kann ich einem Programm hinter eine GUI verstecken? Spiele- und Multimedia-Programmierung 12
J (Libgdx) animation nur einmal in einem Event aufrufen Spiele- und Multimedia-Programmierung 1
B Programmieren wie der Befehl /ban in Minecraft geblockt wird aber nicht /ban mit einem Argument Spiele- und Multimedia-Programmierung 1
P selectedItem aus einem Methodenerstellten JPanel auslesen. Spiele- und Multimedia-Programmierung 5
O Problem beim Aufrufen des Spiels von einem Menü Spiele- und Multimedia-Programmierung 7
G Entity Verwaltung in einem 2D Spiel Spiele- und Multimedia-Programmierung 1
G Collision Detection in einem 2D Sandbox Game. Spiele- und Multimedia-Programmierung 2
G Auf einem Stick bewegen Spiele- und Multimedia-Programmierung 5
windl MP3-Tags von einem Inputstream auslesen Spiele- und Multimedia-Programmierung 5
U DPI von einem Bild definieren Spiele- und Multimedia-Programmierung 5
X Erklärung zu einem Tic Tac Toe Spiel Spiele- und Multimedia-Programmierung 1
C Hilfe bei einem Mosaikspiel Spiele- und Multimedia-Programmierung 16
M [JOGL] Maus über einem gezeichnetem Objekt abfragen? Spiele- und Multimedia-Programmierung 5
P Winkel von einem Punkt zum anderen berechnen Spiele- und Multimedia-Programmierung 9
X Kleines Problem mit Java Reflections und einem eigenen Eventhandler Spiele- und Multimedia-Programmierung 1
S Java3D: Primitives zu einem Objekt kombinieren Spiele- und Multimedia-Programmierung 7
Fl4sh1 Datum und Uhrzeit von einem Ereignis ausgeben lassen Spiele- und Multimedia-Programmierung 3
P Frage zu einem Projekt "Einarmiger Bandit" 3 Walzen / 9 Zeichnungen BLUEJ Spiele- und Multimedia-Programmierung 10
K Grundsätzlicher Spieleaufbau an (m)einem Beispiel Spiele- und Multimedia-Programmierung 4
S Problem mit Sichtfeld/Licht in einem Raster Spiele- und Multimedia-Programmierung 5
M Farbwerte für Flächen aus einem Bild erkennen Spiele- und Multimedia-Programmierung 3
A Drehen von einem Image Spiele- und Multimedia-Programmierung 4
F Bot updaten von einem Browser game Spiele- und Multimedia-Programmierung 7
W Java3D: Kanten die hinter einem Objekt liegen werden gezeigt Spiele- und Multimedia-Programmierung 2
B Reset bei einem Spiel Spiele- und Multimedia-Programmierung 16
C auf einem PC kein mp3 unter Java Spiele- und Multimedia-Programmierung 6
A Steuerung des Bewegungsflusses bei einem Netzwerkspiel Spiele- und Multimedia-Programmierung 18
R Mehrere Shader in einem Program Spiele- und Multimedia-Programmierung 8
B Generierung einer Wertetabelle aus einem Bild Spiele- und Multimedia-Programmierung 3
Z Kugeln aufgrund von Daten aus einem Array verschieben Spiele- und Multimedia-Programmierung 2
S Probleme mit JMenu in einem JFrame mit BufferStrategy Spiele- und Multimedia-Programmierung 2
K Kanten anzeigen lassen in einem Shape3D-Objekt Spiele- und Multimedia-Programmierung 4
A Interaktion von J3D in einem Applet Spiele- und Multimedia-Programmierung 4
N In einem Kasten springende Bälle programmieren...Hilfe Spiele- und Multimedia-Programmierung 7
H Speichern und Öffnen von einem Zeichenprogramm Spiele- und Multimedia-Programmierung 4
A Wie kann ich die Dateigröße aus einem tiff auslesen? Spiele- und Multimedia-Programmierung 2
hdi mehrere Threads/Tasks in einem synchronisieren -> TaskPoo Spiele- und Multimedia-Programmierung 36
N Farberkennung und -ersetzung in einem Bild Spiele- und Multimedia-Programmierung 2
F Umsetzung von einem Partikelsystem Spiele- und Multimedia-Programmierung 4
J Java3D Rotationsproblem bei einem 3D-Maennchen Spiele- und Multimedia-Programmierung 3
B Frage zur Spielsteuerung bei einem rundenbasiertes Spiel Spiele- und Multimedia-Programmierung 5
K Seitenlänge aus einem Würfel lesen Spiele- und Multimedia-Programmierung 3
K Einzelne Pixel in einem Bild lesen Spiele- und Multimedia-Programmierung 5
T Kollisionsabfrage von einem Stein mit einem Ball Spiele- und Multimedia-Programmierung 5
G Einen gif oder jpg Datei aus einem Graphics Objekt o. JFrame Spiele- und Multimedia-Programmierung 2
A 3D Gegenstand in einem 2D Koordinatensystem darstellen. Spiele- und Multimedia-Programmierung 3
K Hilfe bei Grafikeinbindung in einem Spiel Spiele- und Multimedia-Programmierung 6
D Image.getGraphics() in einem Frame Spiele- und Multimedia-Programmierung 4
G Bufferimage bei einem Frame Spiele- und Multimedia-Programmierung 4
I Zweite Kamera in einem SimpleUniverse Spiele- und Multimedia-Programmierung 6
E A*-Pfad malen Spiele- und Multimedia-Programmierung 6
X Android Slick AE Image Pfad Spiele- und Multimedia-Programmierung 3
A ein Auto seinen Weg folgen lassen Spiele- und Multimedia-Programmierung 3

Ähnliche Java Themen

Neue Themen


Oben