372 lines
13 KiB
Java
372 lines
13 KiB
Java
package mindustry.ai;
|
|
|
|
import arc.*;
|
|
import mindustry.annotations.Annotations.*;
|
|
import arc.struct.*;
|
|
import arc.func.*;
|
|
import arc.math.geom.*;
|
|
import arc.util.*;
|
|
import arc.util.ArcAnnotate.*;
|
|
import arc.util.async.*;
|
|
import mindustry.game.EventType.*;
|
|
import mindustry.game.*;
|
|
import mindustry.gen.*;
|
|
import mindustry.world.*;
|
|
import mindustry.world.meta.*;
|
|
|
|
import static mindustry.Vars.*;
|
|
|
|
public class Pathfinder implements Runnable{
|
|
private static final long maxUpdate = Time.millisToNanos(4);
|
|
private static final int updateFPS = 60;
|
|
private static final int updateInterval = 1000 / updateFPS;
|
|
private static final int impassable = -1;
|
|
|
|
/** tile data, see PathTileStruct */
|
|
private int[][] tiles;
|
|
/** unordered array of path data for iteration only. DO NOT iterate ot access this in the main thread.*/
|
|
private Array<PathData> list = new Array<>();
|
|
/** Maps teams + flags to a valid path to get to that flag for that team. */
|
|
private PathData[][] pathMap = new PathData[Team.all().length][PathTarget.all.length];
|
|
/** Grid map of created path data that should not be queued again. */
|
|
private GridBits created = new GridBits(Team.all().length, PathTarget.all.length);
|
|
/** handles task scheduling on the update thread. */
|
|
private TaskQueue queue = new TaskQueue();
|
|
/** current pathfinding thread */
|
|
private @Nullable Thread thread;
|
|
|
|
public Pathfinder(){
|
|
Events.on(WorldLoadEvent.class, event -> {
|
|
stop();
|
|
|
|
//reset and update internal tile array
|
|
tiles = new int[world.width()][world.height()];
|
|
pathMap = new PathData[Team.all().length][PathTarget.all.length];
|
|
created = new GridBits(Team.all().length, PathTarget.all.length);
|
|
list = new Array<>();
|
|
|
|
for(int x = 0; x < world.width(); x++){
|
|
for(int y = 0; y < world.height(); y++){
|
|
tiles[x][y] = packTile(world.rawTile(x, y));
|
|
}
|
|
}
|
|
|
|
//special preset which may help speed things up; this is optional
|
|
preloadPath(state.rules.waveTeam, PathTarget.enemyCores);
|
|
|
|
start();
|
|
});
|
|
|
|
Events.on(ResetEvent.class, event -> stop());
|
|
|
|
Events.on(TileChangeEvent.class, event -> updateTile(event.tile));
|
|
}
|
|
|
|
/** Packs a tile into its internal representation. */
|
|
private int packTile(Tile tile){
|
|
return PathTile.get(tile.cost, tile.getTeamID(), (byte)0, !tile.solid() && tile.floor().drownTime <= 0f);
|
|
}
|
|
|
|
/** Starts or restarts the pathfinding thread. */
|
|
private void start(){
|
|
stop();
|
|
thread = Threads.daemon(this);
|
|
}
|
|
|
|
/** Stops the pathfinding thread. */
|
|
private void stop(){
|
|
if(thread != null){
|
|
thread.interrupt();
|
|
thread = null;
|
|
}
|
|
queue.clear();
|
|
}
|
|
|
|
public int debugValue(Team team, int x, int y){
|
|
if(pathMap[team.id][PathTarget.enemyCores.ordinal()] == null) return 0;
|
|
return pathMap[team.id][PathTarget.enemyCores.ordinal()].weights[x][y];
|
|
}
|
|
|
|
/** Update a tile in the internal pathfinding grid. Causes a complete pathfinding reclaculation. */
|
|
public void updateTile(Tile tile){
|
|
if(net.client()) return;
|
|
|
|
int x = tile.x, y = tile.y;
|
|
|
|
tile.getLinkedTiles(t -> {
|
|
if(Structs.inBounds(t.x, t.y, tiles)){
|
|
tiles[t.x][t.y] = packTile(t);
|
|
}
|
|
});
|
|
|
|
//can't iterate through array so use the map, which should not lead to problems
|
|
for(PathData[] arr : pathMap){
|
|
for(PathData path : arr){
|
|
if(path != null){
|
|
synchronized(path.targets){
|
|
path.targets.clear();
|
|
path.target.getTargets(path.team, path.targets);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
queue.post(() -> {
|
|
for(PathData data : list){
|
|
updateTargets(data, x, y);
|
|
}
|
|
});
|
|
}
|
|
|
|
/** Thread implementation. */
|
|
@Override
|
|
public void run(){
|
|
while(true){
|
|
if(net.client()) return;
|
|
try{
|
|
|
|
queue.run();
|
|
|
|
//total update time no longer than maxUpdate
|
|
for(PathData data : list){
|
|
updateFrontier(data, maxUpdate / list.size);
|
|
}
|
|
|
|
try{
|
|
Thread.sleep(updateInterval);
|
|
}catch(InterruptedException e){
|
|
//stop looping when interrupted externally
|
|
return;
|
|
}
|
|
}catch(Throwable e){
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Gets next tile to travel to. Main thread only. */
|
|
public Tile getTargetTile(Tile tile, Team team, PathTarget target){
|
|
if(tile == null) return null;
|
|
|
|
PathData data = pathMap[team.id][target.ordinal()];
|
|
|
|
if(data == null){
|
|
//if this combination is not found, create it on request
|
|
if(!created.get(team.id, target.ordinal())){
|
|
created.set(team.id, target.ordinal());
|
|
//grab targets since this is run on main thread
|
|
IntArray targets = target.getTargets(team, new IntArray());
|
|
queue.post(() -> createPath(team, target, targets));
|
|
}
|
|
return tile;
|
|
}
|
|
|
|
int[][] values = data.weights;
|
|
int value = values[tile.x][tile.y];
|
|
|
|
Tile current = null;
|
|
int tl = 0;
|
|
for(Point2 point : Geometry.d8){
|
|
int dx = tile.x + point.x, dy = tile.y + point.y;
|
|
|
|
Tile other = world.tile(dx, dy);
|
|
if(other == null) continue;
|
|
|
|
if(values[dx][dy] < value && (current == null || values[dx][dy] < tl) && !other.solid() && other.floor().drownTime <= 0 &&
|
|
!(point.x != 0 && point.y != 0 && (world.solid(tile.x + point.x, tile.y) || world.solid(tile.x, tile.y + point.y)))){ //diagonal corner trap
|
|
current = other;
|
|
tl = values[dx][dy];
|
|
}
|
|
}
|
|
|
|
if(current == null || tl == impassable) return tile;
|
|
|
|
return current;
|
|
}
|
|
|
|
/** @return whether a tile can be passed through by this team. Pathfinding thread only.*/
|
|
private boolean passable(int x, int y, Team team){
|
|
int tile = tiles[x][y];
|
|
return PathTile.passable(tile) || (PathTile.team(tile) != team.id && PathTile.team(tile) != (int)Team.derelict.id);
|
|
}
|
|
|
|
/**
|
|
* Clears the frontier, increments the search and sets up all flow sources.
|
|
* This only occurs for active teams.
|
|
*/
|
|
private void updateTargets(PathData path, int x, int y){
|
|
if(!Structs.inBounds(x, y, path.weights)) return;
|
|
|
|
if(path.weights[x][y] == 0){
|
|
//this was a previous target
|
|
path.frontier.clear();
|
|
}else if(!path.frontier.isEmpty()){
|
|
//skip if this path is processing
|
|
return;
|
|
}
|
|
|
|
//assign impassability to the tile
|
|
if(!passable(x, y, path.team)){
|
|
path.weights[x][y] = impassable;
|
|
}
|
|
|
|
//increment search, clear frontier
|
|
path.search++;
|
|
path.frontier.clear();
|
|
|
|
synchronized(path.targets){
|
|
//add targets
|
|
for(int i = 0; i < path.targets.size; i++){
|
|
int pos = path.targets.get(i);
|
|
int tx = Pos.x(pos), ty = Pos.y(pos);
|
|
|
|
path.weights[tx][ty] = 0;
|
|
path.searches[tx][ty] = (short)path.search;
|
|
path.frontier.addFirst(pos);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void preloadPath(Team team, PathTarget target){
|
|
updateFrontier(createPath(team, target, target.getTargets(team, new IntArray())), -1);
|
|
}
|
|
|
|
/** Created a new flowfield that aims to get to a certain target for a certain team.
|
|
* Pathfinding thread only. */
|
|
private PathData createPath(Team team, PathTarget target, IntArray targets){
|
|
PathData path = new PathData(team, target, world.width(), world.height());
|
|
|
|
list.add(path);
|
|
pathMap[team.id][target.ordinal()] = path;
|
|
|
|
//grab targets from passed array
|
|
synchronized(path.targets){
|
|
path.targets.clear();
|
|
path.targets.addAll(targets);
|
|
}
|
|
|
|
//fill with impassables by default
|
|
for(int x = 0; x < world.width(); x++){
|
|
for(int y = 0; y < world.height(); y++){
|
|
path.weights[x][y] = impassable;
|
|
}
|
|
}
|
|
|
|
//add targets
|
|
for(int i = 0; i < path.targets.size; i++){
|
|
int pos = path.targets.get(i);
|
|
path.weights[Pos.x(pos)][Pos.y(pos)] = 0;
|
|
path.frontier.addFirst(pos);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
/** Update the frontier for a path. Pathfinding thread only. */
|
|
private void updateFrontier(PathData path, long nsToRun){
|
|
long start = Time.nanos();
|
|
|
|
while(path.frontier.size > 0 && (nsToRun < 0 || Time.timeSinceNanos(start) <= nsToRun)){
|
|
Tile tile = world.tile(path.frontier.removeLast());
|
|
if(tile == null || path.weights == null) return; //something went horribly wrong, bail
|
|
int cost = path.weights[tile.x][tile.y];
|
|
|
|
//pathfinding overflowed for some reason, time to bail. the next block update will handle this, hopefully
|
|
if(path.frontier.size >= world.width() * world.height()){
|
|
path.frontier.clear();
|
|
return;
|
|
}
|
|
|
|
if(cost != impassable){
|
|
for(Point2 point : Geometry.d4){
|
|
|
|
int dx = tile.x + point.x, dy = tile.y + point.y;
|
|
Tile other = world.tile(dx, dy);
|
|
|
|
if(other != null && (path.weights[dx][dy] > cost + other.cost || path.searches[dx][dy] < path.search) && passable(dx, dy, path.team)){
|
|
if(other.cost < 0) throw new IllegalArgumentException("Tile cost cannot be negative! " + other);
|
|
path.frontier.addFirst(Pos.get(dx, dy));
|
|
path.weights[dx][dy] = cost + other.cost;
|
|
path.searches[dx][dy] = (short)path.search;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** A path target defines a set of targets for a path.*/
|
|
public enum PathTarget{
|
|
enemyCores((team, out) -> {
|
|
for(Tile other : indexer.getEnemy(team, BlockFlag.core)){
|
|
out.add(other.pos());
|
|
}
|
|
|
|
//spawn points are also enemies.
|
|
if(state.rules.waves && team == state.rules.defaultTeam){
|
|
for(Tile other : spawner.getGroundSpawns()){
|
|
out.add(other.pos());
|
|
}
|
|
}
|
|
}),
|
|
rallyPoints((team, out) -> {
|
|
for(Tile other : indexer.getAllied(team, BlockFlag.rally)){
|
|
out.add(other.pos());
|
|
}
|
|
});
|
|
|
|
public static final PathTarget[] all = values();
|
|
|
|
private final Cons2<Team, IntArray> targeter;
|
|
|
|
PathTarget(Cons2<Team, IntArray> targeter){
|
|
this.targeter = targeter;
|
|
}
|
|
|
|
/** Get targets. This must run on the main thread.*/
|
|
public IntArray getTargets(Team team, IntArray out){
|
|
targeter.get(team, out);
|
|
return out;
|
|
}
|
|
}
|
|
|
|
/** Data for a specific flow field to some set of destinations. */
|
|
class PathData{
|
|
/** Team this path is for. */
|
|
final Team team;
|
|
/** Flag that is being targeted. */
|
|
final PathTarget target;
|
|
/** costs of getting to a specific tile */
|
|
final int[][] weights;
|
|
/** search IDs of each position - the highest, most recent search is prioritized and overwritten */
|
|
final short[][] searches;
|
|
/** search frontier, these are Pos objects */
|
|
final IntQueue frontier = new IntQueue();
|
|
/** all target positions; these positions have a cost of 0, and must be synchronized on! */
|
|
final IntArray targets = new IntArray();
|
|
/** current search ID */
|
|
int search = 1;
|
|
|
|
PathData(Team team, PathTarget target, int width, int height){
|
|
this.team = team;
|
|
this.target = target;
|
|
|
|
this.weights = new int[width][height];
|
|
this.searches = new short[width][height];
|
|
this.frontier.ensureCapacity((width + height) * 3);
|
|
}
|
|
}
|
|
|
|
/** Holds a copy of tile data for a specific tile position. */
|
|
@Struct
|
|
class PathTileStruct{
|
|
//traversal cost
|
|
byte cost;
|
|
//team of block, if applicable (0 by default)
|
|
byte team;
|
|
//type of target; TODO remove
|
|
byte type;
|
|
//whether it's viable to pass this block
|
|
boolean passable;
|
|
}
|
|
}
|