Intersector.intersectSegmentPolygon scheint unterschiedliche Ergebnisse zu liefern ⇐ Java

[Anonymous]

Also beschloss ich, mein eigenes Wegfindungstool zu entwickeln. Allerdings scheint es ein wenig schwierig zu sein, Knoten zu finden, die mit dem Start- und Endpunkt verbunden sind. Wenn ich jedoch die Debug-Zeilen zeichne und somit einen Teil des Prozesses woanders aufrufe, scheint es in Ordnung zu sein?
Also für das, was dafür relevant ist, habe ich die folgenden (vereinfachten) Klassen erstellt:

Code: Select all

public class Node {
private Map connectedNodes = new HashMap();
private Polygon polygon;
private TileType type;
private Vector2 position;

public Node(TileType type, float x, float y){
this.type = type;
position = new Vector2(x+ TILE_WIDTH/2f,y+TILE_HEIGHT/2f); //Center of the polygon

float[] poly = new float[]{
TILE_WIDTH/2f,0,
0,TILE_HEIGHT/4f,
TILE_WIDTH/2f,TILE_HEIGHT/2f,
TILE_WIDTH,TILE_HEIGHT/4f
};

polygon = new Polygon(poly);
polygon.setPosition(position.x - TILE_WIDTH/2f,position.y - TILE_HEIGHT/4f);
}

public void addConnectedNode(Node node, float distance){
connectedNodes.put(node, distance);
}

public Map getConnectedNodes(){
return connectedNodes;
}

public Polygon getPolygon(){
return polygon;
}

public Vector2 getPosition(){
return position;
}

public boolean isMoveable(){
return type.isMoveable();
}

@Override
public boolean equals(Object o) {
if (o == null || getClass() != o.getClass()) return false;
Node node = (Node) o;
return Objects.equals(position, node.position);
}
}

Code: Select all

public class NodeMap {
private Set moveableNodes = new HashSet();
private Set nonMoveableNodes = new HashSet();
private Zone zone;

public void addConnectedNodes(Node node1) {
for(Node node2 : moveableNodes) {
if(!node1.equals(node2) && isStraightLine(node1, node2)){
float distance = node1.getPosition().dst(node2.getPosition());
node1.addConnectedNode(node2, distance);
}
}
}

public boolean isStraightLine(Node node1, Node node2) {
for(Node nonMoveable : nonMoveableNodes){
if(Intersector.intersectSegmentPolygon(node1.getPosition(), node2.getPosition(), nonMoveable.getPolygon())){
return false;
}
}

return true;
}
}

Code: Select all

public class Pathfinder {
private final NodeMap nodeMap;

public Pathfinder(NodeMap nodeMap){
this.nodeMap = nodeMap;
}

private Node createNode(Vector2 position){
Node node = new Node(TileType.GROUND, position.x, position.y);

nodeMap.addConnectedNodes(node);

return node;
}

public Path pathFromTo(Vector2 a, Vector2 b){
Node start = createNode(a);
Node goal = createNode(b);
/*
*
* implement futher pathfinding logic
*
*/
}
}

Wenn ich jedoch den Code so ausführe, um die Debug-Zeilen zu zeichnen:

Code: Select all

        Node start = new Node(TileType.GROUND, coords[0][0].x, coords[0][0].y);

for(Node node : nodeMap.getMoveableNodes()){
if(nodeMap.isStraightLine(start, node)){
drawDebugLine(start.getPosition(), node.getPosition(), viewport.getCamera().combined);
start.addConnectedNode(node, 5);
System.out.println(node.getPosition());
}
}

debugRenderer.setColor(Color.RED);
drawDebugCircle(start.getPosition(), viewport.getCamera().combined);
drawDebugCircle(goal.getPosition(), viewport.getCamera().combined);
debugRenderer.setColor(Color.WHITE);

Dann generiert es alles perfekt.
Ich bin also ein bisschen ratlos, was hier vor sich geht, die Methode isStraightLine scheint unterschiedliche Ergebnisse zu liefern, während sie die gleiche Eingabe empfängt. (Ich habe dies durch Debuggen überprüft)

Und sie verwenden dieselbe Instanz von Pathfinder.
Jede Hilfe wäre dankbar, da ich mir seit einem Tag darüber den Kopf zerbreche, was der Unterschied ist.