0xf8/baritone
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move goals to api

Browse Source
This commit is contained in:
Brady
2018-09-24 20:32:39 -05:00
parent 1b74c8c8be
commit 0f7743263e
25 changed files with 48 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java/baritone/behavior/FollowBehavior.java
View File

@@ -20,8 +20,8 @@ package baritone.behavior;
import baritone.Baritone;
import baritone.api.behavior.IFollowBehavior;
import baritone.api.event.events.TickEvent;
import baritone.pathing.goals.GoalNear;
import baritone.pathing.goals.GoalXZ;
import baritone.api.pathing.goals.GoalNear;
import baritone.api.pathing.goals.GoalXZ;
import baritone.utils.Helper;
import net.minecraft.entity.Entity;
import net.minecraft.util.math.BlockPos;

6
src/main/java/baritone/behavior/MineBehavior.java
View File

@@ -26,9 +26,9 @@ import baritone.cache.CachedChunk;
import baritone.cache.ChunkPacker;
import baritone.cache.WorldProvider;
import baritone.cache.WorldScanner;
import baritone.pathing.goals.GoalBlock;
import baritone.pathing.goals.GoalComposite;
import baritone.pathing.goals.GoalTwoBlocks;
import baritone.api.pathing.goals.GoalBlock;
import baritone.api.pathing.goals.GoalComposite;
import baritone.api.pathing.goals.GoalTwoBlocks;
import baritone.utils.BlockStateInterface;
import baritone.utils.Helper;
import net.minecraft.block.Block;

4
src/main/java/baritone/behavior/PathingBehavior.java
View File

@@ -27,7 +27,7 @@ import baritone.api.pathing.goals.Goal;
import baritone.pathing.calc.AStarPathFinder;
import baritone.pathing.calc.AbstractNodeCostSearch;
import baritone.pathing.calc.IPathFinder;
import baritone.pathing.goals.GoalXZ;
import baritone.api.pathing.goals.GoalXZ;
import baritone.pathing.movement.MovementHelper;
import baritone.pathing.path.IPath;
import baritone.pathing.path.PathExecutor;
@@ -35,7 +35,7 @@ import baritone.utils.BlockBreakHelper;
import baritone.utils.BlockStateInterface;
import baritone.utils.Helper;
import baritone.utils.PathRenderer;
import baritone.utils.interfaces.IGoalRenderPos;
import baritone.api.utils.interfaces.IGoalRenderPos;
import baritone.utils.pathing.BetterBlockPos;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;

2
src/main/java/baritone/pathing/calc/AStarPathFinder.java
View File

@@ -20,7 +20,7 @@ package baritone.pathing.calc;
import baritone.Baritone;
import baritone.api.pathing.goals.Goal;
import baritone.pathing.calc.openset.BinaryHeapOpenSet;
import baritone.pathing.movement.ActionCosts;
import baritone.api.pathing.movement.ActionCosts;
import baritone.pathing.movement.CalculationContext;
import baritone.pathing.movement.Moves;
import baritone.pathing.path.IPath;

2
src/main/java/baritone/pathing/calc/PathNode.java
View File

@@ -18,7 +18,7 @@
package baritone.pathing.calc;
import baritone.api.pathing.goals.Goal;
import baritone.pathing.movement.ActionCosts;
import baritone.api.pathing.movement.ActionCosts;
/**
* A node in the path, containing the cost and steps to get to it.

50
src/main/java/baritone/pathing/goals/GoalAxis.java
View File

@@ -1,50 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.goals;
import baritone.Baritone;
import baritone.api.pathing.goals.Goal;
public class GoalAxis implements Goal {
private static final double SQRT_2_OVER_2 = Math.sqrt(2) / 2;
@Override
public boolean isInGoal(int x, int y, int z) {
return y == Baritone.settings().axisHeight.get() && (x == 0 || z == 0 || Math.abs(x) == Math.abs(z));
}
@Override
public double heuristic(int x0, int y, int z0) {
int x = Math.abs(x0);
int z = Math.abs(z0);
int shrt = Math.min(x, z);
int lng = Math.max(x, z);
int diff = lng - shrt;
double flatAxisDistance = Math.min(x, Math.min(z, diff * SQRT_2_OVER_2));
return flatAxisDistance * Baritone.settings().costHeuristic.get() + GoalYLevel.calculate(Baritone.settings().axisHeight.get(), y);
}
@Override
public String toString() {
return "GoalAxis";
}
}

93
src/main/java/baritone/pathing/goals/GoalBlock.java
View File

@@ -1,93 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.goals;
import baritone.api.pathing.goals.Goal;
import baritone.utils.interfaces.IGoalRenderPos;
import net.minecraft.util.math.BlockPos;
/**
* A specific BlockPos goal
*
* @author leijurv
*/
public class GoalBlock implements Goal, IGoalRenderPos {
/**
* The X block position of this goal
*/
private final int x;
/**
* The Y block position of this goal
*/
private final int y;
/**
* The Z block position of this goal
*/
private final int z;
public GoalBlock(BlockPos pos) {
this(pos.getX(), pos.getY(), pos.getZ());
}
public GoalBlock(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
@Override
public boolean isInGoal(int x, int y, int z) {
return x == this.x && y == this.y && z == this.z;
}
@Override
public double heuristic(int x, int y, int z) {
int xDiff = x - this.x;
int yDiff = y - this.y;
int zDiff = z - this.z;
return calculate(xDiff, yDiff, zDiff);
}
@Override
public String toString() {
return "GoalBlock{x=" + x + ",y=" + y + ",z=" + z + "}";
}
/**
* @return The position of this goal as a {@link BlockPos}
*/
@Override
public BlockPos getGoalPos() {
return new BlockPos(x, y, z);
}
public static double calculate(double xDiff, int yDiff, double zDiff) {
double heuristic = 0;
// if yDiff is 1 that means that pos.getY()-this.y==1 which means that we're 1 block below where we should be
// therefore going from 0,0,0 to a GoalYLevel of pos.getY()-this.y is accurate
heuristic += GoalYLevel.calculate(yDiff, 0);
//use the pythagorean and manhattan mixture from GoalXZ
heuristic += GoalXZ.calculate(xDiff, zDiff);
return heuristic;
}
}

80
src/main/java/baritone/pathing/goals/GoalComposite.java
View File

@@ -1,80 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.goals;
import baritone.api.pathing.goals.Goal;
import net.minecraft.util.math.BlockPos;
import java.util.Arrays;
import java.util.Collection;
/**
* A composite of many goals, any one of which satisfies the composite.
* For example, a GoalComposite of block goals for every oak log in loaded chunks
* would result in it pathing to the easiest oak log to get to
*
* @author avecowa
*/
public class GoalComposite implements Goal {
/**
* An array of goals that any one of must be satisfied
*/
private final Goal[] goals;
public GoalComposite(Goal... goals) {
this.goals = goals;
}
public GoalComposite(BlockPos... blocks) {
this(Arrays.asList(blocks));
}
public GoalComposite(Collection<BlockPos> blocks) {
this(blocks.stream().map(GoalBlock::new).toArray(Goal[]::new));
}
@Override
public boolean isInGoal(int x, int y, int z) {
for (Goal goal : goals) {
if (goal.isInGoal(x, y, z)) {
return true;
}
}
return false;
}
@Override
public double heuristic(int x, int y, int z) {
double min = Double.MAX_VALUE;
for (Goal g : goals) {
// TODO technically this isn't admissible...?
min = Math.min(min, g.heuristic(x, y, z)); // whichever is closest
}
return min;
}
@Override
public String toString() {
return "GoalComposite" + Arrays.toString(goals);
}
public Goal[] goals() {
return goals;
}
}

71
src/main/java/baritone/pathing/goals/GoalGetToBlock.java
View File

@@ -1,71 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.goals;
import baritone.api.pathing.goals.Goal;
import baritone.utils.interfaces.IGoalRenderPos;
import baritone.utils.pathing.BetterBlockPos;
import net.minecraft.util.math.BlockPos;
/**
* Don't get into the block, but get directly adjacent to it. Useful for chests.
*
* @author avecowa
*/
public class GoalGetToBlock implements Goal, IGoalRenderPos {
private final int x;
private final int y;
private final int z;
public GoalGetToBlock(BlockPos pos) {
this.x = pos.getX();
this.y = pos.getY();
this.z = pos.getZ();
}
@Override
public BlockPos getGoalPos() {
return new BetterBlockPos(x, y, z);
}
@Override
public boolean isInGoal(int x, int y, int z) {
int xDiff = x - this.x;
int yDiff = y - this.y;
int zDiff = z - this.z;
if (yDiff < 0) {
yDiff++;
}
return Math.abs(xDiff) + Math.abs(yDiff) + Math.abs(zDiff) <= 1;
}
@Override
public double heuristic(int x, int y, int z) {
int xDiff = x - this.x;
int yDiff = y - this.y;
int zDiff = z - this.z;
return GoalBlock.calculate(xDiff, yDiff, zDiff);
}
@Override
public String toString() {
return "GoalGetToBlock{x=" + x + ",y=" + y + ",z=" + z + "}";
}
}

67
src/main/java/baritone/pathing/goals/GoalNear.java
View File

@@ -1,67 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.goals;
import baritone.api.pathing.goals.Goal;
import baritone.utils.interfaces.IGoalRenderPos;
import net.minecraft.util.math.BlockPos;
public class GoalNear implements Goal, IGoalRenderPos {
private final int x;
private final int y;
private final int z;
private final int rangeSq;
public GoalNear(BlockPos pos, int range) {
this.x = pos.getX();
this.y = pos.getY();
this.z = pos.getZ();
this.rangeSq = range * range;
}
@Override
public boolean isInGoal(int x, int y, int z) {
int xDiff = x - this.x;
int yDiff = y - this.y;
int zDiff = z - this.z;
return xDiff * xDiff + yDiff * yDiff + zDiff * zDiff <= rangeSq;
}
@Override
public double heuristic(int x, int y, int z) {
int xDiff = x - this.x;
int yDiff = y - this.y;
int zDiff = z - this.z;
return GoalBlock.calculate(xDiff, yDiff, zDiff);
}
@Override
public BlockPos getGoalPos() {
return new BlockPos(x, y, z);
}
@Override
public String toString() {
return "GoalNear{" +
"x=" + x +
", y=" + y +
", z=" + z +
", rangeSq=" + rangeSq +
'}';
}
}

73
src/main/java/baritone/pathing/goals/GoalRunAway.java
View File

@@ -1,73 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.goals;
import baritone.api.pathing.goals.Goal;
import net.minecraft.util.math.BlockPos;
import java.util.Arrays;
/**
* Useful for automated combat (retreating specifically)
*
* @author leijurv
*/
public class GoalRunAway implements Goal {
private final BlockPos[] from;
private final double distanceSq;
public GoalRunAway(double distance, BlockPos... from) {
if (from.length == 0) {
throw new IllegalArgumentException();
}
this.from = from;
this.distanceSq = distance * distance;
}
@Override
public boolean isInGoal(int x, int y, int z) {
for (BlockPos p : from) {
int diffX = x - p.getX();
int diffZ = z - p.getZ();
double distSq = diffX * diffX + diffZ * diffZ;
if (distSq < distanceSq) {
return false;
}
}
return true;
}
@Override
public double heuristic(int x, int y, int z) {//mostly copied from GoalBlock
double min = Double.MAX_VALUE;
for (BlockPos p : from) {
double h = GoalXZ.calculate(p.getX() - x, p.getZ() - z);
if (h < min) {
min = h;
}
}
return -min;
}
@Override
public String toString() {
return "GoalRunAwayFrom" + Arrays.asList(from);
}
}

82
src/main/java/baritone/pathing/goals/GoalTwoBlocks.java
View File

@@ -1,82 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.goals;
import baritone.api.pathing.goals.Goal;
import baritone.utils.interfaces.IGoalRenderPos;
import net.minecraft.util.math.BlockPos;
/**
* Useful if the goal is just to mine a block. This goal will be satisfied if the specified
* {@link BlockPos} is at to or above the specified position for this goal.
*
* @author leijurv
*/
public class GoalTwoBlocks implements Goal, IGoalRenderPos {
/**
* The X block position of this goal
*/
private final int x;
/**
* The Y block position of this goal
*/
private final int y;
/**
* The Z block position of this goal
*/
private final int z;
public GoalTwoBlocks(BlockPos pos) {
this(pos.getX(), pos.getY(), pos.getZ());
}
public GoalTwoBlocks(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
@Override
public boolean isInGoal(int x, int y, int z) {
return x == this.x && (y == this.y || y == this.y - 1) && z == this.z;
}
@Override
public double heuristic(int x, int y, int z) {
int xDiff = x - this.x;
int yDiff = y - this.y;
int zDiff = z - this.z;
if (yDiff < 0) {
yDiff++;
}
return GoalBlock.calculate(xDiff, yDiff, zDiff);
}
@Override
public BlockPos getGoalPos() {
return new BlockPos(x, y, z);
}
@Override
public String toString() {
return "GoalTwoBlocks{x=" + x + ",y=" + y + ",z=" + z + "}";
}
}

102
src/main/java/baritone/pathing/goals/GoalXZ.java
View File

@@ -1,102 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.goals;
import baritone.Baritone;
import baritone.api.pathing.goals.Goal;
import baritone.utils.Utils;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
/**
* Useful for long-range goals that don't have a specific Y level.
*
* @author leijurv
*/
public class GoalXZ implements Goal {
private static final double SQRT_2 = Math.sqrt(2);
/**
* The X block position of this goal
*/
private final int x;
/**
* The Z block position of this goal
*/
private final int z;
public GoalXZ(int x, int z) {
this.x = x;
this.z = z;
}
@Override
public boolean isInGoal(int x, int y, int z) {
return x == this.x && z == this.z;
}
@Override
public double heuristic(int x, int y, int z) {//mostly copied from GoalBlock
int xDiff = x - this.x;
int zDiff = z - this.z;
return calculate(xDiff, zDiff);
}
@Override
public String toString() {
return "GoalXZ{x=" + x + ",z=" + z + "}";
}
public static double calculate(double xDiff, double zDiff) {
//This is a combination of pythagorean and manhattan distance
//It takes into account the fact that pathing can either walk diagonally or forwards
//It's not possible to walk forward 1 and right 2 in sqrt(5) time
//It's really 1+sqrt(2) because it'll walk forward 1 then diagonally 1
double x = Math.abs(xDiff);
double z = Math.abs(zDiff);
double straight;
double diagonal;
if (x < z) {
straight = z - x;
diagonal = x;
} else {
straight = x - z;
diagonal = z;
}
diagonal *= SQRT_2;
return (diagonal + straight) * Baritone.settings().costHeuristic.get(); // big TODO tune
}
public static GoalXZ fromDirection(Vec3d origin, float yaw, double distance) {
float theta = (float) Utils.degToRad(yaw);
double x = origin.x - MathHelper.sin(theta) * distance;
double z = origin.z + MathHelper.cos(theta) * distance;
return new GoalXZ((int) x, (int) z);
}
public int getX() {
return x;
}
public int getZ() {
return z;
}
}

65
src/main/java/baritone/pathing/goals/GoalYLevel.java
View File

@@ -1,65 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.goals;
import baritone.api.pathing.goals.Goal;
import baritone.pathing.movement.ActionCostsButOnlyTheOnesThatMakeMickeyDieInside;
/**
* Useful for mining (getting to diamond / iron level)
*
* @author leijurv
*/
public class GoalYLevel implements Goal, ActionCostsButOnlyTheOnesThatMakeMickeyDieInside {
/**
* The target Y level
*/
private final int level;
public GoalYLevel(int level) {
this.level = level;
}
@Override
public boolean isInGoal(int x, int y, int z) {
return y == level;
}
@Override
public double heuristic(int x, int y, int z) {
return calculate(level, y);
}
public static double calculate(int goalY, int currentY) {
if (currentY > goalY) {
// need to descend
return FALL_N_BLOCKS_COST[2] / 2 * (currentY - goalY);
}
if (currentY < goalY) {
// need to ascend
return (goalY - currentY) * JUMP_ONE_BLOCK_COST;
}
return 0;
}
@Override
public String toString() {
return "GoalYLevel{y=" + level + "}";
}
}

47
src/main/java/baritone/pathing/movement/ActionCosts.java
View File

@@ -1,47 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.movement;
public interface ActionCosts extends ActionCostsButOnlyTheOnesThatMakeMickeyDieInside {
/**
* These costs are measured roughly in ticks btw
*/
double WALK_ONE_BLOCK_COST = 20 / 4.317; // 4.633
double WALK_ONE_IN_WATER_COST = 20 / 2.2;
double WALK_ONE_OVER_SOUL_SAND_COST = WALK_ONE_BLOCK_COST * 2; // 0.4 in BlockSoulSand but effectively about half
double SPRINT_ONE_OVER_SOUL_SAND_COST = WALK_ONE_OVER_SOUL_SAND_COST * 0.75;
double LADDER_UP_ONE_COST = 20 / 2.35;
double LADDER_DOWN_ONE_COST = 20 / 3.0;
double SNEAK_ONE_BLOCK_COST = 20 / 1.3;
double SPRINT_ONE_BLOCK_COST = 20 / 5.612; // 3.564
/**
* To walk off an edge you need to walk 0.5 to the edge then 0.3 to start falling off
*/
double WALK_OFF_BLOCK_COST = WALK_ONE_BLOCK_COST * 0.8;
/**
* To walk the rest of the way to be centered on the new block
*/
double CENTER_AFTER_FALL_COST = WALK_ONE_BLOCK_COST - WALK_OFF_BLOCK_COST;
/**
* don't make this Double.MAX_VALUE because it's added to other things, maybe other COST_INFs,
* and that would make it overflow to negative
*/
double COST_INF = 1000000;
}

71
src/main/java/baritone/pathing/movement/ActionCostsButOnlyTheOnesThatMakeMickeyDieInside.java
View File

@@ -1,71 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.pathing.movement;
public interface ActionCostsButOnlyTheOnesThatMakeMickeyDieInside {
double[] FALL_N_BLOCKS_COST = generateFallNBlocksCost();
double FALL_1_25_BLOCKS_COST = distanceToTicks(1.25);
double FALL_0_25_BLOCKS_COST = distanceToTicks(0.25);
/**
* When you hit space, you get enough upward velocity to go 1.25 blocks
* Then, you fall the remaining 0.25 to get on the surface, on block higher.
* Since parabolas are symmetric, the amount of time it takes to ascend up from 1 to 1.25
* will be the same amount of time that it takes to fall back down from 1.25 to 1.
* And the same applies to the overall shape, if it takes X ticks to fall back down 1.25 blocks,
* it will take X ticks to reach the peak of your 1.25 block leap.
* Therefore, the part of your jump from y=0 to y=1.25 takes distanceToTicks(1.25) ticks,
* and the sub-part from y=1 to y=1.25 takes distanceToTicks(0.25) ticks.
* Therefore, the other sub-part, from y=0 to y-1, takes distanceToTicks(1.25)-distanceToTicks(0.25) ticks.
* That's why JUMP_ONE_BLOCK_COST = FALL_1_25_BLOCKS_COST - FALL_0_25_BLOCKS_COST
*/
double JUMP_ONE_BLOCK_COST = FALL_1_25_BLOCKS_COST - FALL_0_25_BLOCKS_COST;
static double[] generateFallNBlocksCost() {
double[] costs = new double[257];
for (int i = 0; i < 257; i++) {
costs[i] = distanceToTicks(i);
}
return costs;
}
static double velocity(int ticks) {
return (Math.pow(0.98, ticks) - 1) * -3.92;
}
static double oldFormula(double ticks) {
return -3.92 * (99 - 49.5 * (Math.pow(0.98, ticks) + 1) - ticks);
}
static double distanceToTicks(double distance) {
if (distance == 0) {
return 0; // Avoid 0/0 NaN
}
double tmpDistance = distance;
int tickCount = 0;
while (true) {
double fallDistance = velocity(tickCount);
if (tmpDistance <= fallDistance) {
return tickCount + tmpDistance / fallDistance;
}
tmpDistance -= fallDistance;
tickCount++;
}
}
}

1
src/main/java/baritone/pathing/movement/MovementHelper.java
View File

@@ -18,6 +18,7 @@
package baritone.pathing.movement;
import baritone.Baritone;
import baritone.api.pathing.movement.ActionCosts;
import baritone.api.utils.Rotation;
import baritone.behavior.LookBehaviorUtils;
import baritone.pathing.movement.MovementState.MovementTarget;

1
src/main/java/baritone/pathing/path/PathExecutor.java
View File

@@ -19,6 +19,7 @@ package baritone.pathing.path;
import baritone.Baritone;
import baritone.api.event.events.TickEvent;
import baritone.api.pathing.movement.ActionCosts;
import baritone.pathing.movement.*;
import baritone.pathing.movement.movements.*;
import baritone.utils.BlockStateInterface;

4
src/main/java/baritone/utils/ExampleBaritoneControl.java
View File

@@ -21,7 +21,8 @@ import baritone.Baritone;
import baritone.api.Settings;
import baritone.api.cache.IWaypoint;
import baritone.api.event.events.ChatEvent;
import baritone.api.pathing.goals.Goal;
import baritone.api.pathing.goals.*;
import baritone.api.pathing.movement.ActionCosts;
import baritone.behavior.Behavior;
import baritone.behavior.FollowBehavior;
import baritone.behavior.MineBehavior;
@@ -30,7 +31,6 @@ import baritone.cache.ChunkPacker;
import baritone.cache.Waypoint;
import baritone.cache.WorldProvider;
import baritone.pathing.calc.AbstractNodeCostSearch;
import baritone.pathing.goals.*;
import baritone.pathing.movement.*;
import net.minecraft.block.Block;
import net.minecraft.client.multiplayer.ChunkProviderClient;

8
src/main/java/baritone/utils/PathRenderer.java
View File

@@ -19,11 +19,11 @@ package baritone.utils;
import baritone.Baritone;
import baritone.api.pathing.goals.Goal;
import baritone.pathing.goals.GoalComposite;
import baritone.pathing.goals.GoalTwoBlocks;
import baritone.pathing.goals.GoalXZ;
import baritone.api.pathing.goals.GoalComposite;
import baritone.api.pathing.goals.GoalTwoBlocks;
import baritone.api.pathing.goals.GoalXZ;
import baritone.pathing.path.IPath;
import baritone.utils.interfaces.IGoalRenderPos;
import baritone.api.utils.interfaces.IGoalRenderPos;
import baritone.utils.pathing.BetterBlockPos;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;

24
src/main/java/baritone/utils/interfaces/IGoalRenderPos.java
View File

@@ -1,24 +0,0 @@
/*
* This file is part of Baritone.
*
* Baritone is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Baritone is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
*/
package baritone.utils.interfaces;
import net.minecraft.util.math.BlockPos;
public interface IGoalRenderPos {
BlockPos getGoalPos();
}

2
src/main/java/baritone/utils/pathing/MoveResult.java
View File

@@ -17,7 +17,7 @@
package baritone.utils.pathing;
import static baritone.pathing.movement.ActionCosts.COST_INF;
import static baritone.api.pathing.movement.ActionCosts.COST_INF;
/**
* The result of a calculated movement, with destination x, y, z, and the cost of performing the movement