2018-08-08 03:16:53 +00:00
/ *
* This file is part of Baritone .
*
* Baritone is free software : you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation , either version 3 of the License , or
* ( at your option ) any later version .
*
2018-08-08 04:15:22 +00:00
* Baritone is distributed in the hope that it will be useful ,
2018-08-08 03:16:53 +00:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with Baritone . If not , see < https : //www.gnu.org/licenses/>.
* /
/ *
* This file is part of Baritone .
*
* Baritone is free software : you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation , either version 3 of the License , or
* ( at your option ) any later version .
*
2018-08-08 04:15:22 +00:00
* Baritone is distributed in the hope that it will be useful ,
2018-08-08 03:16:53 +00:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with Baritone . If not , see < https : //www.gnu.org/licenses/>.
* /
2018-08-03 13:55:17 +00:00
package baritone.bot.pathing.calc ;
2018-08-14 03:17:16 +00:00
import baritone.bot.Baritone ;
2018-08-08 00:41:13 +00:00
import baritone.bot.chunk.CachedWorldProvider ;
2018-08-05 03:25:05 +00:00
import baritone.bot.pathing.calc.openset.BinaryHeapOpenSet ;
import baritone.bot.pathing.calc.openset.IOpenSet ;
2018-08-03 13:55:17 +00:00
import baritone.bot.pathing.goals.Goal ;
import baritone.bot.pathing.movement.ActionCosts ;
2018-08-07 21:36:32 +00:00
import baritone.bot.pathing.movement.CalculationContext ;
2018-08-03 13:55:17 +00:00
import baritone.bot.pathing.movement.Movement ;
2018-08-07 13:41:45 +00:00
import baritone.bot.pathing.movement.MovementHelper ;
2018-08-12 01:45:02 +00:00
import baritone.bot.pathing.movement.movements.* ;
2018-08-05 03:25:05 +00:00
import baritone.bot.pathing.path.IPath ;
2018-08-11 22:03:14 +00:00
import baritone.bot.utils.Helper ;
2018-08-14 17:47:31 +00:00
import baritone.bot.utils.pathing.BetterBlockPos ;
2018-08-03 13:55:17 +00:00
import net.minecraft.client.Minecraft ;
2018-08-07 02:48:09 +00:00
import net.minecraft.util.EnumFacing ;
2018-08-03 13:55:17 +00:00
import net.minecraft.util.math.BlockPos ;
import net.minecraft.world.chunk.EmptyChunk ;
2018-08-06 07:21:47 +00:00
import java.util.Optional ;
2018-08-03 13:55:17 +00:00
import java.util.Random ;
/ * *
* The actual A * pathfinding
*
* @author leijurv
* /
2018-08-11 22:03:14 +00:00
public class AStarPathFinder extends AbstractNodeCostSearch implements Helper {
2018-08-06 07:21:47 +00:00
2018-08-03 13:55:17 +00:00
public AStarPathFinder ( BlockPos start , Goal goal ) {
super ( start , goal ) ;
}
@Override
2018-08-06 07:21:47 +00:00
protected Optional < IPath > calculate0 ( ) {
2018-08-03 13:55:17 +00:00
startNode = getNodeAtPosition ( start ) ;
startNode . cost = 0 ;
2018-08-03 15:45:11 +00:00
startNode . combinedCost = startNode . estimatedCostToGoal ;
IOpenSet openSet = new BinaryHeapOpenSet ( ) ;
2018-08-03 13:55:17 +00:00
startNode . isOpen = true ;
openSet . insert ( startNode ) ;
bestSoFar = new PathNode [ COEFFICIENTS . length ] ; //keep track of the best node by the metric of (estimatedCostToGoal + cost / COEFFICIENTS[i])
double [ ] bestHeuristicSoFar = new double [ COEFFICIENTS . length ] ;
for ( int i = 0 ; i < bestHeuristicSoFar . length ; i + + ) {
bestHeuristicSoFar [ i ] = Double . MAX_VALUE ;
}
currentlyRunning = this ;
long startTime = System . currentTimeMillis ( ) ;
2018-08-14 17:47:31 +00:00
long timeoutTime = startTime + ( Baritone . settings ( ) . slowPath ? 40000 : 4000 ) ;
2018-08-03 13:55:17 +00:00
long lastPrintout = 0 ;
int numNodes = 0 ;
2018-08-08 22:41:58 +00:00
CalculationContext calcContext = new CalculationContext ( ) ;
2018-08-03 13:55:17 +00:00
int numEmptyChunk = 0 ;
2018-08-14 03:17:16 +00:00
boolean cache = Baritone . settings ( ) . chuckCaching ;
2018-08-03 13:55:17 +00:00
while ( ! openSet . isEmpty ( ) & & numEmptyChunk < 50 & & System . currentTimeMillis ( ) < timeoutTime ) {
2018-08-14 17:47:31 +00:00
if ( Baritone . settings ( ) . slowPath ) {
2018-08-03 13:55:17 +00:00
try {
Thread . sleep ( 100 ) ;
} catch ( InterruptedException ex ) {
}
2018-08-05 22:53:11 +00:00
}
2018-08-03 13:55:17 +00:00
PathNode currentNode = openSet . removeLowest ( ) ;
currentNode . isOpen = false ;
2018-08-05 15:30:50 +00:00
mostRecentConsidered = currentNode ;
2018-08-14 17:47:31 +00:00
BetterBlockPos currentNodePos = currentNode . pos ;
2018-08-03 13:55:17 +00:00
numNodes + + ;
if ( System . currentTimeMillis ( ) > lastPrintout + 1000 ) { //print once a second
System . out . println ( " searching... at " + currentNodePos + " , considered " + numNodes + " nodes so far " ) ;
lastPrintout = System . currentTimeMillis ( ) ;
}
if ( goal . isInGoal ( currentNodePos ) ) {
currentlyRunning = null ;
2018-08-14 17:50:41 +00:00
return Optional . of ( new Path ( startNode , currentNode , numNodes ) ) ;
2018-08-03 13:55:17 +00:00
}
//long constructStart = System.nanoTime();
2018-08-08 22:41:58 +00:00
Movement [ ] possibleMovements = getConnectedPositions ( currentNodePos , calcContext ) ; //movement that we could take that start at myPos, in random order
2018-08-03 13:55:17 +00:00
shuffle ( possibleMovements ) ;
//long constructEnd = System.nanoTime();
//System.out.println(constructEnd - constructStart);
for ( Movement movementToGetToNeighbor : possibleMovements ) {
2018-08-07 02:48:09 +00:00
if ( movementToGetToNeighbor = = null ) {
continue ;
}
2018-08-08 00:41:13 +00:00
boolean isPositionCached = false ;
2018-08-14 03:17:16 +00:00
if ( cache ) {
if ( CachedWorldProvider . INSTANCE . getCurrentWorld ( ) ! = null ) {
if ( CachedWorldProvider . INSTANCE . getCurrentWorld ( ) . getBlockType ( movementToGetToNeighbor . getDest ( ) ) ! = null ) {
isPositionCached = true ;
}
}
}
if ( ! isPositionCached & & Minecraft . getMinecraft ( ) . world . getChunk ( movementToGetToNeighbor . getDest ( ) ) instanceof EmptyChunk ) {
2018-08-04 02:14:50 +00:00
numEmptyChunk + + ;
continue ;
}
2018-08-03 13:55:17 +00:00
//long costStart = System.nanoTime();
// TODO cache cost
2018-08-08 22:41:58 +00:00
double actionCost = movementToGetToNeighbor . getCost ( calcContext ) ;
2018-08-03 13:55:17 +00:00
//long costEnd = System.nanoTime();
//System.out.println(movementToGetToNeighbor.getClass() + "" + (costEnd - costStart));
if ( actionCost > = ActionCosts . COST_INF ) {
continue ;
}
2018-08-06 15:42:26 +00:00
if ( actionCost < = 0 ) {
throw new IllegalStateException ( movementToGetToNeighbor . getClass ( ) + " " + movementToGetToNeighbor + " calculated implausible cost " + actionCost ) ;
}
2018-08-14 17:47:31 +00:00
PathNode neighbor = getNodeAtPosition ( ( BetterBlockPos ) movementToGetToNeighbor . getDest ( ) ) ;
2018-08-03 13:55:17 +00:00
double tentativeCost = currentNode . cost + actionCost ;
if ( tentativeCost < neighbor . cost ) {
2018-08-06 15:42:26 +00:00
if ( tentativeCost < 0 ) {
throw new IllegalStateException ( movementToGetToNeighbor . getClass ( ) + " " + movementToGetToNeighbor + " overflowed into negative " + actionCost + " " + neighbor . cost + " " + tentativeCost ) ;
}
2018-08-03 13:55:17 +00:00
neighbor . previous = currentNode ;
neighbor . previousMovement = movementToGetToNeighbor ;
neighbor . cost = tentativeCost ;
2018-08-03 15:45:11 +00:00
neighbor . combinedCost = tentativeCost + neighbor . estimatedCostToGoal ;
2018-08-05 15:30:50 +00:00
if ( neighbor . isOpen ) {
openSet . update ( neighbor ) ;
} else {
2018-08-03 13:55:17 +00:00
openSet . insert ( neighbor ) ; //dont double count, dont insert into open set if it's already there
neighbor . isOpen = true ;
}
for ( int i = 0 ; i < bestSoFar . length ; i + + ) {
double heuristic = neighbor . estimatedCostToGoal + neighbor . cost / COEFFICIENTS [ i ] ;
if ( heuristic < bestHeuristicSoFar [ i ] ) {
bestHeuristicSoFar [ i ] = heuristic ;
bestSoFar [ i ] = neighbor ;
}
}
}
}
}
double bestDist = 0 ;
for ( int i = 0 ; i < bestSoFar . length ; i + + ) {
if ( bestSoFar [ i ] = = null ) {
continue ;
}
double dist = getDistFromStartSq ( bestSoFar [ i ] ) ;
if ( dist > bestDist ) {
bestDist = dist ;
}
if ( dist > MIN_DIST_PATH * MIN_DIST_PATH ) { // square the comparison since distFromStartSq is squared
2018-08-12 01:05:55 +00:00
displayChatMessageRaw ( " A* cost coefficient " + COEFFICIENTS [ i ] ) ;
2018-08-03 13:55:17 +00:00
if ( COEFFICIENTS [ i ] > = 3 ) {
System . out . println ( " Warning: cost coefficient is greater than three! Probably means that " ) ;
System . out . println ( " the path I found is pretty terrible (like sneak-bridging for dozens of blocks) " ) ;
System . out . println ( " But I'm going to do it anyway, because yolo " ) ;
}
System . out . println ( " Path goes for " + dist + " blocks " ) ;
currentlyRunning = null ;
2018-08-14 17:50:41 +00:00
return Optional . of ( new Path ( startNode , bestSoFar [ i ] , numNodes ) ) ;
2018-08-03 13:55:17 +00:00
}
}
2018-08-12 01:05:55 +00:00
displayChatMessageRaw ( " Even with a cost coefficient of " + COEFFICIENTS [ COEFFICIENTS . length - 1 ] + " , I couldn't get more than " + bestDist + " blocks =( " ) ;
2018-08-11 22:03:14 +00:00
displayChatMessageRaw ( " No path found =( " ) ;
2018-08-03 13:55:17 +00:00
currentlyRunning = null ;
2018-08-06 07:21:47 +00:00
return Optional . empty ( ) ;
2018-08-03 13:55:17 +00:00
}
2018-08-14 17:47:31 +00:00
private static Movement [ ] getConnectedPositions ( BetterBlockPos pos , CalculationContext calcContext ) {
2018-08-03 13:55:17 +00:00
int x = pos . getX ( ) ;
int y = pos . getY ( ) ;
int z = pos . getZ ( ) ;
2018-08-14 17:47:31 +00:00
BetterBlockPos east = new BetterBlockPos ( x + 1 , y , z ) ;
BetterBlockPos west = new BetterBlockPos ( x - 1 , y , z ) ;
BetterBlockPos south = new BetterBlockPos ( x , y , z + 1 ) ;
BetterBlockPos north = new BetterBlockPos ( x , y , z - 1 ) ;
2018-08-08 22:41:58 +00:00
return new Movement [ ] {
2018-08-14 17:47:31 +00:00
new MovementTraverse ( pos , east ) ,
new MovementTraverse ( pos , west ) ,
new MovementTraverse ( pos , north ) ,
new MovementTraverse ( pos , south ) ,
new MovementAscend ( pos , new BetterBlockPos ( x + 1 , y + 1 , z ) ) ,
new MovementAscend ( pos , new BetterBlockPos ( x - 1 , y + 1 , z ) ) ,
new MovementAscend ( pos , new BetterBlockPos ( x , y + 1 , z + 1 ) ) ,
new MovementAscend ( pos , new BetterBlockPos ( x , y + 1 , z - 1 ) ) ,
MovementHelper . generateMovementFallOrDescend ( pos , east , calcContext ) ,
MovementHelper . generateMovementFallOrDescend ( pos , west , calcContext ) ,
MovementHelper . generateMovementFallOrDescend ( pos , north , calcContext ) ,
MovementHelper . generateMovementFallOrDescend ( pos , south , calcContext ) ,
new MovementDownward ( pos , new BetterBlockPos ( x , y - 1 , z ) ) ,
2018-08-08 03:03:41 +00:00
new MovementDiagonal ( pos , EnumFacing . NORTH , EnumFacing . WEST ) ,
new MovementDiagonal ( pos , EnumFacing . NORTH , EnumFacing . EAST ) ,
new MovementDiagonal ( pos , EnumFacing . SOUTH , EnumFacing . WEST ) ,
2018-08-12 01:45:02 +00:00
new MovementDiagonal ( pos , EnumFacing . SOUTH , EnumFacing . EAST ) ,
2018-08-14 17:47:31 +00:00
new MovementPillar ( pos , new BetterBlockPos ( x , y + 1 , z ) )
2018-08-08 03:03:41 +00:00
} ;
2018-08-03 13:55:17 +00:00
}
private final Random random = new Random ( ) ;
private < T > void shuffle ( T [ ] list ) {
int len = list . length ;
for ( int i = 0 ; i < len ; i + + ) {
int j = random . nextInt ( len ) ;
T t = list [ j ] ;
list [ j ] = list [ i ] ;
list [ i ] = t ;
}
}
}