com.badlogic.gdx.ai.pfa.Connection Java Examples

public Node(AStarMap map, int x, int y) {
    this.x = x;
    this.y = y;
    this.index = x * map.getHeight() + y;
    this.isWall = false;
    this.connections = new Array<Connection<Node>>();
}
 

public Triangle(Vector3 a, Vector3 b, Vector3 c, int triIndex, int meshPartIndex) {
	this.a = a;
	this.b = b;
	this.c = c;
	this.triIndex = triIndex;
	this.meshPartIndex = meshPartIndex;
	this.centroid = new Vector3(a).add(b).add(c).scl(1f / 3f);
	this.connections = new Array<Connection<Triangle>>();
}
 

protected void generateConnectionPath (N startNode, GraphPath<Connection<N>> outPath) {

		// Work back along the path, accumulating connections
		// outPath.clear();
		while (current.node != startNode) {
			outPath.add(current.connection);
			current = nodeRecords[graph.getIndex(current.connection.getFromNode())];
		}

		// Reverse the path
		outPath.reverse();
	}
 

@Override
public boolean searchConnectionPath (N startNode, N endNode, Heuristic<N> heuristic, GraphPath<Connection<N>> outPath) {

	// Perform AStar
	boolean found = search(startNode, endNode, heuristic);

	if (found) {
		// Create a path made of connections
		generateConnectionPath(startNode, outPath);
	}

	return found;
}
 

public AStartPathFinding(AStarMap map) {
    this.map = map;
    this.pathfinder = new IndexedAStarPathFinder<Node>(createGraph(map));
    this.connectionPath = new DefaultGraphPath<Connection<Node>>();
    this.heuristic = new Heuristic<Node>() {
        @Override
        public float estimate (Node node, Node endNode) {
            // Manhattan distance
            return Math.abs(endNode.x - node.x) + Math.abs(endNode.y - node.y);
        }
  };
}
 

@Override
public Array<Connection<FlatTiledNode>> getConnections (FlatTiledNode fromNode) {
	return fromNode.getConnections();
}
 

@Override
public Array<Connection<MyNode>> getConnections (MyNode fromNode) {
	return fromNode.getConnections();
}
 

public Array<Connection<MyNode>> getConnections () {
	return connections;
}
 

public HierarchicalTiledNode (int x, int y, int type, int index, int connectionCapacity) {
	super(x, y, type, new Array<Connection<HierarchicalTiledNode>>(connectionCapacity));
	this.index = index;
}
 

@Override
public Array<Connection<HierarchicalTiledNode>> getConnections (HierarchicalTiledNode fromNode) {
	return fromNode.getConnections();
}
 

public Array<Connection<N>> getConnections () {
	return this.connections;
}
 

public TiledNode (int x, int y, int type, Array<Connection<N>> connections) {
	this.x = x;
	this.y = y;
	this.type = type;
	this.connections = connections;
}
 

public FlatTiledNode (int x, int y, int type, int connectionCapacity) {
	super(x, y, type, new Array<Connection<FlatTiledNode>>(connectionCapacity));
}
 

@Override
@SuppressWarnings("unchecked")
public Array<Connection<Triangle>> getConnections(Triangle fromNode) {
	return (Array<Connection<Triangle>>) (Array<?>) sharedEdges.getValueAt(fromNode.triIndex);
}
 

public Array<Connection<Triangle>> getConnections() {
	return connections;
}
 

public Array<Connection<Node>> getConnections () {
    return connections;
}
 

@Override
public Array<Connection<Node>> getConnections(Node fromNode) {
    return fromNode.getConnections();
}